` import time
import unittest
from selenium.webdriver import Chrome
from selenium.webdriver.common.by import By
driver = Chrome() # launch the chrome browser
class MyTestCase(unittest.TestCase):
#classmethod
def setUpClass(cls) -> None:
driver.get("https://automationexercise.com/")
def test_homepage_is_displayed(self):
time.sleep(2)
home_page_icon = driver.find_element(By.XPATH, "//i[#class='fa fa-home']")
status = self.assertTrue(home_page_icon.is_displayed())
if status is True:
print("home page is displayed..")
def test_new_user_sign_up_visible(self):
time.sleep(2)
driver.find_element(By.XPATH, "//a[#href='/login']").click()
time.sleep(2)
new_user_sign_up = driver.find_element(By.XPATH, "//h2[.='New User Signup!']")
status = self.assertTrue(new_user_sign_up.is_displayed())
if status is True:
print("text displayed on register screen is:", new_user_sign_up.text)
time.sleep(10)
def test_error_email_address_already_exist(self):
driver.find_element(By.XPATH, "//input[#data-qa='signup-name']").send_keys("Zenith Mohanty")
time.sleep(2)
driver.find_element(By.NAME, "email").send_keys("mohantyzenith#gmail.com")
time.sleep(2)
driver.find_element(By.XPATH, "//button[.='Signup']").click()
time.sleep(2)
error_msg = driver.find_element(By.XPATH, "//p[.='Email Address already exist!']")
status = self.assertTrue(error_msg.is_displayed())
if status is True:
print("error msg displayed on screen is:", error_msg.text)
if name == 'main':
unittest.main()
``
Related
I'm working on a basic client-server desktop app project using kivy & sockets & threading.
The client & server work on it's own, however when I try to integrate it with kivy, python & kivy don't want to respond & yet no definitive error pops up.
Could i have some ideas as to how to fix this?
This is the code that freezes when i run it, if i take away the import server_sock it works as a general gui and doesnt freeze.
import kivy
from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.gridlayout import GridLayout
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.clock import Clock
import server_sock
import sys
kivy.require("2.1.0") #latest version
class ConnectPage(GridLayout):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cols = 2
self.add_widget(Label(text="IP:"))
self.ip = TextInput(multiline=False)
self.add_widget(self.ip)
self.add_widget(Label(text="PORT:"))
self.port = TextInput(multiline=False)
self.add_widget(self.port)
self.add_widget(Label(text="USERNAME:"))
self.user = TextInput(multiline=False)
self.add_widget(self.user)
self.join = Button(text="Join")
self.join.bind(on_press=self.join_button)
self.add_widget(Label())
self.add_widget(self.join)
def join_button(self, instance):
port = self.port.text
ip = self.ip.text
user = self.user.text
info = f"Attempting to join {ip}:{port} as {user}"
chat_app.info_page.update_info(info)
chat_app.screen_manager.current = "Info"
Clock.shedule_once(self.connect,1)
def connect(self, _):
port = int(self.port.text)
ip = self.ip.text
user = self.user.text
try:
server_sock.connect(ip, port)
chat_app.create_chat_page()
chat_app.screen_manager.current = "Chat"
except:
show_error(message="not gonna happen")
class InfoPage(GridLayout):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cols = 1
self.message = Label(halign="center", valign="middle", font_size="30")
self.message.bind(width=self.update_text_width)
self.add_widget(self.message)
def update_info(self,message):
self.message.text = message
def update_text_width(self, *_):
self.message.text_size = (self.message.width*0.9, None)
class ChatPage(GridLayout):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cols = 1
self.add_widget(Label(text="Hey at least it works till now"))
class ChatApp(App):
def build(self):
self.screen_manager = ScreenManager()
self.connect_page = ConnectPage()
screen = Screen(name="Connect")
screen.add_widget(self.connect_page)
self.screen_manager.add_widget(screen)
self.info_page = InfoPage()
screen= Screen(name="Info")
screen.add_widget(self.info_page)
self.screen_manager.add_widget(screen)
return self.screen_manager
def create_chat_page(self):
self.chat_page = ChatPage()
screen = Screen(name="Chat")
screen.add_widget(self.chat_page)
self.screen_manager.add_widget(screen)
def show_error(message):
chat_app.info_page.update_info(message)
chat_app.screen_manager.current = "Info"
Clock.shedule_once(sys.exit, 10)
if __name__ == "__main__":
chat_app =ChatApp()
chat_app.run()
This is the server_sock file
import socket
import threading
import socket
HOST = '127.0.0.1'
PORT = 55555
server = socket.socket(
socket.AF_INET,
socket.SOCK_STREAM
)
try:
server.bind((HOST, PORT))
except:
print(f'unable to bind to {HOST} and {PORT}')
server.listen()
print(f"Listening for connections on {HOST}: {PORT}")
clients = []
nicknames = []
def broadcast(message):
for client in clients:
client.send(message)
def message_recv(client):
while True:
try:
message = client.recv(2048)
broadcast(message)
except:
index = clients.index(client)
clients.remove(client)
nickname = nicknames[index]
broadcast(f'{nickname} left the chat'.encode('ascii'))
nicknames.remove(nickname)
break
def recieve():
while True:
client, address = server.accept()
print(f"Connected with {str(address)}")
client.send("SOMETHING".encode('ascii'))
nickname = client.recv(2048).decode('ascii')
nicknames.append(nickname)
clients.append(client)
print(f"Nickname of the client is {nickname}")
broadcast(f"{nickname} joined the chat".encode('ascii'))
client.send("Connected to the server".encode('ascii'))
thread = threading.Thread(target=message_recv, args=(client,))
thread.start()
print("Server is listening")
recieve()
I am working on a buffet simulation of a buffet. So basically the client will first go through the payment. Then he should go to get his tray which is the part that does not work. After, he should go get his food.
I dont understand why the Clients are not going to the tray queue.
In fact, right-now the client is paying and then he his going directly to tale his food without taking a tray so something must be wrong in the class function but I can't figure what.
import threading
import random
import time
import concurrent.futures
import traceback
class Queue:
def __init__(self) -> None:
self.list_of_products = []
self.queue = []
self.lock = threading.Lock()
self.bill = 0
self.type_of_products = random.randrange(1, 4)
def add_client(self, client):
self.lock.acquire()
self.queue.append(client)
self.lock.release()
def remove_client(self, client):
self.lock.acquire()
self.queue.remove(client)
self.lock.release()
def check_if_client_in_queue(self, client) -> bool:
self.lock.acquire()
student_in_queue = True if client in self.queue else False
self.lock.release()
return student_in_queue
def check_if_empty(self) -> bool:
self.lock.acquire()
empty = len(self.queue) == 0
self.lock.release()
return empty
def get_first_client(self):
if not self.check_if_empty():
return self.queue.pop(0)
return None
def result_of_random_range(self):
x = self.type_of_products
return x
def paying(self):
self.lock.acquire()
if self.type_of_products == 1:
self.list_of_products.append(self.type_of_products)#i think it is not appending
self.bill = 1 * 25.90
elif self.type_of_products == 2:
self.list_of_products.append(self.type_of_products)
self.bill = 1 * 17.90
else:
self.list_of_products.append(self.type_of_products)
self.bill = 1 * 13.50
type_of_payment = random.randrange(1, 3)
if type_of_payment == 1:
print("Client has to pay", self.bill, "and he is paying in cash")
change = random.randrange(int(self.bill), round(int(self.bill) + 5)) - int(self.bill)
print("Amount to be returned", change, "€")
else:
print("Client has to pay", self.bill, "and he is paying with his credit card")
self.lock.release()
return self.bill
def tray(self):
self.lock.acquire()
random_fall = random.randrange(1,25)
if random_fall != 1:
print("Client got his Tray")
else:
print("Client dropped his tray")
time.sleep(10)
self.lock.release()
class Clients:
def __init__(self, id, queues):
self.id = id
self.queues = queues
if random.randrange(1, 3) == 1:
self.queues["clients_waiting_to_pay_manually"].add_client(self)
else:
self.queues["clients_waiting_to_pay_automatically"].add_client(self)
def __str__(self) -> str:
return f"{self.id}"
def change_queues(self) -> None:
try:
while True:
if not self.queues["clients_waiting_to_pay_manually"].check_if_client_in_queue(self) and not \
self.queues["clients_waiting_to_pay_automatically"].check_if_client_in_queue(self):
break
change_criteria = random.randrange(1, 10)
if change_criteria != 1:
time.sleep(1)
continue
print(f"Client with id {self.id} is gonna switch queue")
if self.queues["clients_waiting_to_pay_manually"].check_if_client_in_queue(self):
self.queues["clients_waiting_to_pay_manually"].remove_client(self)
self.queues["clients_waiting_to_pay_automatically"].add_client(self)
time.sleep(1)
continue
if self.queues["clients_waiting_to_pay_automatically"].check_if_client_in_queue(self):
self.queues["clients_waiting_to_pay_automatically"].remove_client(self)
self.queues["clients_waiting_to_pay_manually"].add_client(self)
time.sleep(1)
continue
except Exception:
traceback.print_exc()
class Station:
def __init__(self, id, queues):
self.id = id
self.queues = queues
def moving_station(self):
try:
while True:
if not self.queues["clients_waiting_to_pay_automatically"].check_if_empty():
client = self.queues["clients_waiting_to_pay_automatically"].get_first_client()
print(f"Cashier {self.id}: Serving the client {client} in the automatic queue")
self.queues["clients_waiting_to_pay_automatically"].paying()
print(f"Client {client} has paid and is going to another station ")
self.queues["clients_getting_main_food"].add_client(client)
print(f"Client {client} is getting his food ")
time.sleep(2)
elif not self.queues["clients_waiting_to_pay_manually"].check_if_empty():
client = self.queues["clients_waiting_to_pay_manually"].get_first_client()
print(f"Cashier {self.id}: Serving the client {client} in the manual queue")
self.queues["clients_waiting_to_pay_manually"].paying()
print(f"Client {client} has paid and is going to another station ")
self.queues["clients_getting_main_food"].add_client(client)
print(f"Client {client} is getting his food ")
time.sleep(2)
else:
break
except Exception:
traceback.print_exc()
class Trays:
def __init__(self,queues) -> None:
self.queues = queues
def giving_trays(self):
try:
while True:
if self.queues["clients_waiting_for_tray"].check_if_empty():
print(f"There is no more clients waiting for a tray")
break
elif not self.queues["clients_waiting_for_tray"].check_if_empty():
client = self.queues["clients_waiting_for_tray"].get_first_client()
print(f"{client} got his tray")
print(f"Client {client} just got his tray")
time.sleep(2)
else:
break
except Exception as e:
traceback.print_exc()
class Main_food:
def __init__(self,id,queues):
self.id = id
self.queues = queues
def getting_food(self):
pasta_menu = ["Carbonara ", "Pesto", "Basilico", "Bolognese", "Truffle", "Chicken Alfredo"]
protein_menu = ["Beef","Pork","Fish","chicken","Beyond Meat","turkey"]
pasta_stock = [2,1,4,5,6,3]
protein_stock = [2,1,4,5,6,3]
try:
if not self.queues["clients_getting_main_food"].check_if_empty():
client_getting_served = self.queues["clients_getting_main_food"].get_first_client()
if self.queues["clients_waiting_to_pay_automatically"].result_of_random_range() == 1:
self.queues["clients_getting_menu_1"].add_client(client_getting_served)
elif self.queues["clients_waiting_to_pay_manually"].result_of_random_range() == 1:
self.queues["clients_getting_menu_1"].add_client(client_getting_served)
if self.queues["clients_waiting_to_pay_automatically"].result_of_random_range() == 2:
self.queues["clients_getting_menu_2"].add_client(client_getting_served)
elif self.queues["clients_waiting_to_pay_manually"].result_of_random_range() == 2:
self.queues["clients_getting_menu_2"].add_client(client_getting_served)
elif self.queues["clients_waiting_to_pay_manually"].result_of_random_range() == 3:
self.queues["clients_getting_menu_3"].add_client(client_getting_served)
else:
self.queues["clients_getting_menu_3"].add_client(client_getting_served)
x = random.randrange(0,6)
y = random.randrange(0,6)
stock = pasta_stock[x]
stock1 = protein_stock[y]
if not self.queues["clients_getting_menu_1"].check_if_empty():
client_being_served_1 = self.queues["clients_getting_menu_1"].get_first_client()
if stock != 0:
pasta_stock[x] = pasta_stock[x]-1
if stock1 != 0:
protein_stock[y] = protein_stock[y]-1
print(f"Client {client_being_served_1} is getting Pasta : {pasta_menu[x]} and Protein : {protein_menu[y]}")
print(f"pasta {pasta_stock[x]} protein {protein_stock[y]} ")
self.queues["clients_getting_desert"].add_client(client_being_served_1)
if not self.queues["clients_getting_menu_2"].check_if_empty():
client_being_served_2 = self.queues["clients_getting_menu_2"].get_first_client()
if stock != 0:
pasta_stock[x] = pasta_stock[x]-1
print(f"Client {client_being_served_2} is getting Pasta :{pasta_menu[x]}")
print(f"pasta2 {pasta_stock[x]} ")
self.queues["clients_getting_desert"].add_client(client_being_served_2)
elif not self.queues["clients_getting_menu_3"].check_if_empty():
client_being_served_3 = self.queues["clients_getting_menu_3"].get_first_client()
if stock1 != 0:
protein_stock[y] = protein_stock[y]-1
print(f"Client {client_being_served_3} is getting Protein :{protein_menu[y]}")
print(f"protein3 {protein_stock[y]} ")
self.queues["clients_getting_desert"].add_client(client_being_served_3)
except Exception as e:
traceback.print_exc()
queues ={
"clients_waiting_to_pay_manually": Queue(),
"clients_waiting_to_pay_automatically": Queue(),
"clients_waiting_for_tray": Queue(),
"clients_getting_main_food": Queue(),
"clients_not_getting_main_food": Queue(),
"clients_getting_menu_1": Queue(),
"clients_getting_menu_2": Queue(),
"clients_getting_menu_3": Queue(),
"clients_getting_desert": Queue()
}
number_of_cashiers = 3
number_of_clients = 10
clients = [Clients(id, queues) for id in range(number_of_clients)]
stations = [Station(id, queues) for id in range(number_of_clients)]
trays = [Trays(queues) for id in range(number_of_clients)]
foods = [Main_food(id, queues) for id in range(number_of_clients)]
with concurrent.futures.ThreadPoolExecutor(max_workers=number_of_clients) as executor:
for client in clients:
executor.submit(client.change_queues)
with concurrent.futures.ThreadPoolExecutor(max_workers=number_of_clients) as executor:
for station in stations:
executor.submit(station.moving_station)
with concurrent.futures.ThreadPoolExecutor(max_workers=number_of_clients) as executor:
for tray in trays:
executor.submit(tray.giving_trays)
with concurrent.futures.ThreadPoolExecutor(max_workers=number_of_clients) as executor:
for food in foods:
executor.submit(food.getting_food)
im running a chat app on my computer and i tried to send a message and this ERROR accured. it suppose to send a " will joind the chat" and another message " connected to server" after that i should send my message to the group and it didnt worked.
any ideas?
import kivy
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
import socket
import threading
kivy.require("1.9.0")
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
class MyRoot(BoxLayout):
def __init__(self):
super(MyRoot, self).__init__()
def send_message(self):
client.send(f"{self.nickname_text.text}: {self.message_text.text}".encode('utf-8'))
def connect_to_server(self):
if self.nickname_text != "":
client.connect((self.ip_text.text, 9999))
message = client.recv(1024).decode('utf-8')
if message == "NICK":
client.send(self.nickname_text.text.encode('utf-8'))
self.send_btn.disabled = False
self.message_text.disabled = False
self.connect_btn.disabled = True
self.ip_text.disabled = True
self.make_invisible(self.connection_grid)
self.make_invisible(self.connect_btn)
thread = threading.Thread(target=self.receive)
thread.start()
def make_invisible(self, widget):
widget.visible = False
widget.size_hint_x = None
widget.size_hint_y = None
widget.height = 0
widget.width = 0
widget.text = ""
widget.opacity = 0
def receive(self):
stop = False
while not stop:
try:
message = client.recv(1024).decode('utf-8')
self.chat_text.text += message + "\n"
except:
print("ERROR")
client.close()
stop = True
class TraboChat(App):
def build(self):
return MyRoot()
trabo_chat = TraboChat()
trabo_chat.run()
serve.py:
import socket
import threading
HOST = socket.gethostbyname(socket.gethostname())
PORT = 9999
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((HOST, PORT))
server.listen()
clients = []
nicknames = []
def broadcast(message):
for client in clients:
client.send(message)
def handle_connection(client):
stop = False
while not stop:
try:
message = client.recv(1024)
broadcast(message)
except:
index = clients.index(client)
clients.remove(client)
nickname = nicknames[index]
nicknames.remove(nickname)
broadcast(f"{nickname} left the chat!".encode('utf-8'))
stop = True
def main():
print("server is running..")
while True:
client, addr = server.accept()
print(f"connected to {addr}")
client.send("NICK".encode('utf-8'))
nickname = client.recv(1024).decode('utf-8')
nicknames.append(nickname)
clients.append(client)
print(f"Nickname is {nickname}")
broadcast(f"{nickname} join the chat!")
client.send("You are now connected".encode('utf-8'))
thread = threading.Thread(target=handle_connection, args=(client,))
if name == 'main':
main()
I want to get path of the file dropped on QLabel. So I code like this, but label doesn't accept the file. What is the problem..?
Here is my code. So long code sorry and thank you!
import random
import sys
import pygame
import time
from PyQt5.QtGui import QPixmap
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtWidgets import QWidget, QLabel, QApplication, QDesktopWidget
class Example(QWidget):
size=100
imgNum=0
frameCount=4
isXmin = False
isXmax = False
isYmin = False
isYmax = False
isLeft= True
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
sizeObject = QDesktopWidget().screenGeometry()
# print(" Screen size : " + str(sizeObject.height()) + "x" + str(sizeObject.width()))
self.xMax=sizeObject.width()-10
self.yMax=sizeObject.height()-10
print(self.xMax)
print(self.yMax)
self.setWindowFlags(Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground)
self.setStyleSheet("background-color:transparent;")
self.setGeometry(100, 100, 100, 100)
self.setWindowFlags(Qt.SplashScreen | Qt.WindowStaysOnTopHint)
self.setAcceptDrops(True)
self.label=QLabel(self)
self.label.setAcceptDrops(True)
self.pixmaps=[QPixmap('left.png'),QPixmap('stand.png'),QPixmap('right.png'),QPixmap('stand.png'),QPixmap('leftR.png'),QPixmap('standR.png'),QPixmap('rightR.png'),QPixmap('standR.png')]
for x in range(len(self.pixmaps)):
self.pixmaps[x]=self.pixmaps[x].scaled(self.size,self.size,Qt.KeepAspectRatio)
self.resize(self.pixmaps[2].width(),self.pixmaps[2].height())
self.label.setPixmap(self.pixmaps[len(self.pixmaps)-1])
self.changeTimer=QTimer(self)
self.changeTimer.timeout.connect(self.changeFoot)
self.moveTimer=QTimer(self)
self.moveTimer.timeout.connect(self.moving)
self.setAcceptDrops(True)
pygame.init()
pygame.mixer.music.load('hoi_imtemmie.mp3')
pygame.mixer.music.play()
self.show()
def dragEnterEvent(self, event):
if event.mimeData().hasUrls:
event.accept()
else:
event.ingore()
def dropEvent(self, event):
self.path=event.mimeData.urls()
def moving(self):
if self.distance == 0:
print(self.distance)
print(self.x(),"x",self.y())
self.label.setPixmap(self.pixmaps[1])
self.moveTimer.stop()
self.changeTimer.stop()
time.sleep(3)
self.setMovement()
return 0
else:
self.move(self.x()+self.direct[0],self.y()+self.direct[1])
self.distance-=1
if self.x()<=-10 :
self.distance=0
print("xm")
self.isXmin = True
if self.y()<=-10 :
self.distance=0
print("ym")
self.isYmin = True
if self.x()>=self.xMax:
self.distance=0
print("xM")
self.isXmax=True
if self.y()>=self.yMax :
self.distance=0
print("yM")
self.isYmax=True
def setMovement(self):
self.direct=[0,0]
while(self.direct[0]==0 and self.direct[1]==0):
self.direct=[random.randint(-1,1),random.randint(-1,1)]
if self.isXmax:
self.direct[0]=-1
if self.isXmin:
self.direct[0]=1
if self.isYmin:
self.direct[1]=1
if self.isYmax:
self.direct[1]=-1
if self.direct[0]== -1:
self.isLeft=True
self.imgNum=0
elif self.direct[0]== 1:
self.isLeft=False
self.imgNum=4
self.isXmax = False
self.isXmin = False
self.isYmin = False
self.isYmax = False
# if direct[0]*direct[1]==0 : self.delta = QPoint(dX*direct[0],dY*direct[1])
# else: self.delta=QPoint(direct[0]*(dX**(1/2)),direct[1]*(dY**1/2))
self.distance=random.randint(200,400)
self.changeTimer.start(300)
self.moveTimer.start(30)
def changeFoot(self):
self.label.setPixmap(self.pixmaps[self.imgNum])
if self.isLeft:
if self.imgNum<self.frameCount-1:
self.imgNum+=1
else :
self.imgNum=0
else:
if self.imgNum<2*self.frameCount-1:
self.imgNum+=1
else :
self.imgNum=self.frameCount
def mousePressEvent(self, QMouseEvent):
self.setMovement()
pygame.mixer.music.load('hoi_imtemmie.mp3')
pygame.mixer.music.play()
def keyPressEvent(self, QKeyEvent):
if QKeyEvent.key() == Qt.Key_Escape:
sys.exit()
# if QKeyEvent.key() == Qt.Key_G:
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
i set AcceptDrops(True)
self.setAcceptDrops(True)
and code about get filepath ▼
def dragEnterEvent(self, event):
if event.mimeData().hasUrls:
event.accept()
else:
event.ingore()
def dropEvent(self, event):
self.path=event.mimeData.urls()
Try to loop through event.mimeData().urls()
for url in event.mimeData().urls():
self.path = url.toLocalFile()
What are the intentions of this program:
I want to send some commands from a client to a server using sockets, the server then send these command to an Arduino using serial. And another thing that I want the server to do in the future is that periodically sends other commands to the Arduino without getting any input from the client, so the sockets needs to be non-blocking or there needs to be another way to run the code separately from the sockets code.
The problem is that the part that is supposed to send the command to the Arduino only runs once.
What I have come up with after playing with the debugger in Pycharm, is that the problem is that the following line blocks after a connection has been established, and thus not allowing the rest of the code to be run.
conn, addr = s.accept()
Is this correct, or is there something else wrong?
I have tried to set the socket to non-blocking but when I do this I get an error.
"BlockingIOError: [WinError 10035] A non-blocking socket operation could not be completed immediately"
I have some basic knowledge of C/C++ and C# and am new to Python.
server.py
import socket
import serial
import sys
from _thread import *
import threading
import queue
# command that the client sends are "ON" and "OFF"
class serialConnect:
comPort =' '
baudrate = 115200
myserial = serial.Serial('COM5', baudrate)
def serialstart(self):
# self.comPort = input('Comport: ')
try:
self.myserial.open()
except IOError:
print('Port is already open!')
def serialRead(self):
data = self.myserial.read(16)
data.decode('UTF-8')
return data
def serialWrite(self, data):
data += '\n' #the arduino needs a \n after each command.
databytes = data.encode('UTF-8')
self.myserial.write(databytes)
print('send data: ', databytes)
def threaded_client(conn, dataqueue):
data = {bytes}
conn.send(str.encode('welcome, type your info \n'))
while True:
data = conn.recv(2048)
if not data:
break
reply = 'server output: ' + data.decode('UTF-8')
dataqueue.put(data.decode('UTF-8'))
print("Items in queue: ",dataqueue.qsize())
#conn.sendall(str.encode(reply))
print("Recieved data in threaded_client: ", data.decode('UTF-8') + '\n')
conn.close()
def Main():
ser = serialConnect()
host = ''
port = 5555
dataRecieved = 'hello'
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(2)
s.setblocking(1) #when set to non-blocking error occurs : "BlockingIOError: [WinError 10035] A non-blocking socket operation could not be completed immediately"
workQueue = queue.Queue(10)
try:
s.bind((host,port))
except socket.error as e:
print(str(e))
s.listen(5)
print('waiting for a connection')
while True:
try:
conn, addr = s.accept() #once connection is established it blocks?
print('connected to: ' + addr[0] + ':' + str())
t = threading.Thread(target=threaded_client, args=(conn, workQueue))
t.daemon = True
t.start()
except:
e = sys.exc_info()
print('Error:', e)
# This section of code is only run once, doesn't matter if put inside try block or not. :(
dataRecieved = workQueue.get()
print('The recieved data: ', dataRecieved)
ser.serialstart()
ser.serialWrite(dataRecieved)
if __name__ == '__main__':
Main()
client.py
import socket
def Main():
host = '127.0.0.1'
port = 5555
message = "<,R,G,B,>"
mySocket = socket.socket()
mySocket.connect((host, port))
while message != 'q':
message = input(" -> ")
mySocket.send(message.encode())
mySocket.close()
if __name__ == '__main__':
Main()
Arduino Code
String inputString = ""; // a string to hold incoming data
boolean stringComplete = false; // whether the string is complete
int LEDpin = 10;
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin 13 as an output.
pinMode(10, OUTPUT);
Serial.begin(19200);
}
// the loop function runs over and over again forever
void loop() {
serialEvent();
if(stringComplete){
Serial.println(inputString);
if(inputString == "ON\n"){
digitalWrite(LEDpin, HIGH); // turn the LED on (HIGH is the voltage level)
}
if(inputString == "OFF\n"){
digitalWrite(LEDpin, LOW); // turn the LED off by making the voltage LOW
}
inputString = "";
stringComplete = false;
}
}
void serialEvent()
{
while (Serial.available()) {
// get the new byte:
char inChar = (char)Serial.read();
// add it to the inputString:
inputString += inChar;
// if the incoming character is a newline, set a flag
// so the main loop can do something about it:
if (inChar == '\n') {
stringComplete = true;
}
}
}
Refactored server code for anyone that is interested in it.
I am not sure if this is up to standard, but it is working.
import serial
import socket
import queue
import sys
import threading
class serialConnect:
comPort = 'COM5'
baudrate = 115200
myserial = serial.Serial(comPort, baudrate)
def serial_run(self):
# self.comPort = input('Comport: ')
try:
if not self.myserial.isOpen():
self.myserial.open()
else:
print('Port is already open!')
except IOError as e:
print('Error: ', e)
def serial_read(self):
data = self.myserial.read(16)
data.decode('UTF-8')
return data
def serial_write(self, data):
data += '\n' #the arduino needs a \n after each command.
databytes = data.encode('UTF-8')
self.myserial.write(databytes)
print('send data: ', databytes)
class socketServer:
host = ''
port = 5555
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
soc.setblocking(1)
data_queue = queue.Queue(1)
def __init__(self):
try:
self.soc.bind((self.host, self.port))
except:
print('Bind error: ', sys.exc_info())
self.soc.listen(5)
def socket_accept_thread(self):
while True:
try:
print('Waiting for a new connection')
conn, addr = self.soc.accept()
client_thread = threading.Thread(target=self.threaded_client, args=(conn, self.data_queue))
client_thread.daemon = True
client_thread.start()
except:
print('Accept thread Error: ', sys.exc_info())
def threaded_client(self, conn, data_queue):
# conn.send(str.encode('welcome, type your info \n'))
try:
while True:
data = conn.recv(2048)
if not data:
break
# reply = 'server output: ' + data.decode('UTF-8')
data_queue.put(data.decode('UTF-8'))
print("Items in queue: ", data_queue.qsize())
# conn.sendall(str.encode(reply))
print("Received data in threaded_client: ", data.decode('UTF-8'))
except:
print("Error: ", sys.exc_info())
conn.close()
def get_data(self):
data = self.data_queue.get()
return data
def Main():
server = socketServer()
arduino_conn = serialConnect()
accept_thread = threading.Thread(target=server.socket_accept_thread)
data_received = 'Nothing received'
while True:
if not accept_thread.is_alive():
accept_thread.daemon = True
accept_thread.start()
arduino_conn.serial_run()
data_received = server.get_data()
arduino_conn.serial_write(data_received)
if __name__ == '__main__':
Main()