Hallo
ich würde gerne eine gui haben in der sich auch ein sich ständig aktualisierender Graph befindet. mein Problem ist nun , dass bei jeder aktualisieren die gui gut eine halbe Sekunde eingefroren ist.Die genaue Schilderung meines Problems lautet dass ich ein Temperatur zeit Graphen erstellen will der alle 2 Sekunden Aktualisiert wird. ich habe es nun schon mit pyqtgraph(self.plot_item.plot([1,2,3,4,5,6],[23,23,24,24,23,23,24])) und matplotbib ausprobiert das "einfrieren" passiert bei beiden Bibliotheken. aber ich will die gui immer benutzen können. ich vermute zumindest eine Lösung wäre es das Erstellen des Graphen irgendwie in ein anderen Thread auszulagern.
Liebe Grüße sauterle
ständig aktualisirender graph in qt
Nein, das wird garantiert nicht die Loesung sein. Denn GUIs koennen nur im Main-Thread manipuliert werden.
Ich habe mit pyqtgraph animierte Ansichten gebaut (wenn ich mich recht erinnere irgendwas mit einer IMU, schon ne Weile her), und das ging ohne solche Verzoegrerungen. Ich vermute also mal eher das Problem liegt bei deinem konkreten Vorgehen. Das ohne Quelltext nicht beurteilbar ist.
Ich habe mit pyqtgraph animierte Ansichten gebaut (wenn ich mich recht erinnere irgendwas mit einer IMU, schon ne Weile her), und das ging ohne solche Verzoegrerungen. Ich vermute also mal eher das Problem liegt bei deinem konkreten Vorgehen. Das ohne Quelltext nicht beurteilbar ist.
das holen/aktualisieren der Temperaturdaten dürfte der interessantere Teil für einen eigenen Thread sein.
hallo und Danke für eure Antworten
Ich habe eure Beiträge gelesen und ein vereinfachtes Progrämmchen geschriebeb(code 1) in dem das Problem nicht auftrat. Danach habe ich nach und nach mehr sachen hinzugetan bis ich darauf gekommen bin, dass das Problem nur Auftritt wenn ich eine Instanz der Klasse Fernsteuerung(code 2) als Thread starte. Jetzt bin ich wierklich vollkommen ratlos
code 1:
code 2:
LG sauterle
Ich habe eure Beiträge gelesen und ein vereinfachtes Progrämmchen geschriebeb(code 1) in dem das Problem nicht auftrat. Danach habe ich nach und nach mehr sachen hinzugetan bis ich darauf gekommen bin, dass das Problem nur Auftritt wenn ich eine Instanz der Klasse Fernsteuerung(code 2) als Thread starte. Jetzt bin ich wierklich vollkommen ratlos
code 1:
Code: Alles auswählen
from worker import *
from random import randint
from PyQt6.QtCore import QThreadPool
import pyqtgraph as pg
from time import sleep
class Signals(QObject):
plot = pyqtSignal(list,list)
class MainWindow(QMainWindow):
def __init__(self,signals, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
layout = QVBoxLayout()
signals.plot.connect(self.plot)
self.label_start = QLabel("Start")
b = QSlider()
self.graphWidget = pg.PlotWidget()
layout.addWidget(self.label_start)
layout.addWidget(b)
layout.addWidget(self.graphWidget)
w = QWidget()
w.setLayout(layout)
self.setCentralWidget(w)
self.show()
def plot(self , plotx, ploty):
self.graphWidget.plot(plotx,ploty)
class Thread2(QRunnable):
def __init__(self):
super().__init__()
self.xlist = []
self.ylist = []
self.x=0
self.signals = Signals()
def zahl(self):
self.xlist.append(self.x)
self.ylist.append(randint(0, 15))
self.x += 1
@pyqtSlot()
def emiter(self):
self.signals.plot.emit(self.xlist, self.ylist)
def run(self):
while True:
sleep(1)
self.zahl()
self.emiter()
threadpool = QThreadPool()
app = QApplication([])
thread = Thread2()
window = MainWindow(thread.signals)
threadpool.start(thread)
app.exec()
Code: Alles auswählen
import serial
from worker import *
import time
from PyQt6.QtCore import *
class Fernsteuerung(QRunnable):
def __init__(self, q1 , q2 ,sig ,*args,**kwargs):
super().__init__()
self.signals = sig
self.fernqueue = q2
self.queue = q1
self.z=0
self.threadpool = QThreadPool()
self.write = b""
self.broken = True
self.fehler = 0
self.port_finder()
def port_finder(self):
self.port_try=None
try:
self.port = serial.Serial('/dev/ttyUSB0')
except:
self.port_try = False
else:
self.port_try = True
if self.port_try == False:
try:
self.port = serial.Serial("/dev/ttyUSB1")
except:
print("Fehler bei ferbindungsaufbau zu fernbedienung")
@pyqtSlot()
def reader(self):
self.read=self.port.readline()
if self.read != b"":
self.erst = self.read[0:2]
try:
self.wert = int(self.read[2:])
except:
self.wert = None
if self.erst == b"j1":
self.wert = self.lehr_bereich(self.wert)
self.signals.j1.emit(self.wert)
if self.erst == b"j2":
self.wert += 3
self.wert = self.lehr_bereich(self.wert)
self.signals.j2.emit(self.wert)
if self.erst == b"kr":
self.signals.kamera.emit(self.wert)
if self.erst == b"kl":
self.signals.kamera.emit(self.wert)
if self.erst == b"mk":
if self.wert == 1:
self.signals.rueck.emit()
if self.wert == 2:
self.signals.aus.emit()
if self.wert == 3:
self.signals.vor.emit()
if self.erst == b"wd":
self.wert = self.lehrbereich(self.wert)
self.signals.wd.emit(self.wert)
if self.erst == b"k1":
self.signals.k1.emit()
if self.erst == b"k2":
self.signals.kk2.emit()
if self.erst == b"k3":
self.signals.k3.emit()
if self.write != None:
self.port.write(self.write)
self.write = None
def writer(self,writer):
self.port.write(writer)
def worker(self):
warker = Worker(self.write)
self.threadpool.start(warker)
def run(self):
while True:
if self.broken:
try:
self.write = self.fernqueue.get(block=False)
except:
pass
try:
self.reader()
except:
self.port_finder()
print("port mistake")
time.sleep(1)
self.fehler += 1
if self.fehler == 3:
self.broken = False
else:
self.fehler = 0
def restart(self):
self.broken=True
self.fehler=0
self.run()
def lehr_bereich(self , wert):
self.bereich = 2
self.funktions_wert = wert
if (self.funktions_wert >=50 - self.bereich) and (self.funktions_wert <= 50 + self.bereich):
self.funktions_wert = 50
if self.funktions_wert > self.bereich + 50:
self.funktions_wert -= self.bereich
if self.funktions_wert <50 - self.bereich:
self.funktions_wert += self.bereich
return self.funktions_wert
das holen ,errechen, und als signal zum main window schicken tut schon ein Threaddas holen/aktualisieren der Temperaturdaten dürfte der interessantere Teil für einen eigenen Thread sein.
LG sauterle
Die ganze Threaderei ist Murks. Wie leider fast immer. Da wird viel zu viel gethreadpooled und dieses extra Signals-Objekt ist auch ueberfluessig. Eine Klasse, abgeleitet von QThread, mit einem oder mehreren Signalen, das reicht. Und dann kommt das wichtige: es muessen QueuedConnections zwischen den Signalen und Slots sein! Unbedingt. Denn sonst wird - und das ist hier so - der slot eben doch im Hintergrundthread aufgerufen. Es ist ein weit verbreiteter Irrglaube zu denken, weil verschiedene Objekte im Spiel sind, die Signale da irgendwie von Thread zu Thread wandern. Dsa tun sie nicht. Nur mit QueuedConnection passiert das.
Man googled den Begriff mal, um die sich erklären zu lassen. Ist ja schon viel drüber geschrieben worden, muss ich ja nicht wiederholen. Und ich hab’s doch beschrieben, warum die dein Problem lösen. Was genau ist da unklar?
Hallo ich habe die vermutung, dass das wahrscheinlich ein sehr doofer Fehler ist, aber dahinter komme ich leider trotzdem nicht. Wenn Ich dass mache kommt die Fehlermeldung:
File "/home/levin/PycharmProjects/qtTest/mainwindow.py", line 59, in __init__
self.signals.j1.connect(self.geschwinichkeit, type=Qt.QueuedConnection)
AttributeError: type object 'Qt' has no attribute 'QueuedConnection'
Code:
LG sauterle
File "/home/levin/PycharmProjects/qtTest/mainwindow.py", line 59, in __init__
self.signals.j1.connect(self.geschwinichkeit, type=Qt.QueuedConnection)
AttributeError: type object 'Qt' has no attribute 'QueuedConnection'
Code:
Code: Alles auswählen
self.signals.j1.connect(self.geschwinichkeit, type=Qt.QueuedConnection)
self.signals.j2.connect(self.lenkung, type=Qt.QueuedConnection)
self.signals.kamera.connect(self.kamera, type=Qt.QueuedConnection)
self.signals.rueck.connect(self.rueckwaerts, type=Qt.QueuedConnection)
self.signals.aus.connect(self.aus, type=Qt.QueuedConnection)
self.signals.vor.connect(self.vorwaerts, type=Qt.QueuedConnection)
self.signals.wd.connect(self.winde, type=Qt.QueuedConnection)
self.signals.k1.connect(self.licht_aus, type=Qt.QueuedConnection)
self.signals.kk2.connect(self.frontlicht, type=Qt.QueuedConnection)
self.signals.k3.connect(self.nebler, type=Qt.QueuedConnection)
self.signals.camdreh.connect(self.kamera_winkel, type=Qt.QueuedConnection)
Code: Alles auswählen
from PyQt6 import uic
import threading
from worker import *
import time
from PyQt6.QtCore import Qt, pyqtSlot
from PyQt6.QtCore import QTimer
import pyqtgraph as pg
class MainWindow(QMainWindow):
def __init__(self, q4 , q1 , q5 , q2 , signals, *args, **kwargs):
super().__init__()#MainWindow, self).__init__(*args, **kwargs)
self.art = "t"
self.ui = uic.loadUi("Robo_GUI.ui")
#self.ax = plt.subplots()
self.graphWidget = pg.PlotWidget()
self.ui.verticalLayout_5.addWidget(self.graphWidget)
self.timer = QTimer()# der Timer ist dafür da um zu kuken ob das Problem der Gui noch besteht ohne den Ganzen poteziel Fehlerbehafteten Rest mit einzubinden
self.timer.setInterval(1000)
self.timer.timeout.connect(self.plot)
self.timer.start()
self.queue4 = q4
self.fernqueue = q2
self.queue5 = q5
self.queue = q1
self.signals = signals
self.locker = threading.Lock
self.threadpool = QThreadPool()
self.lenk = 0
self.gesch = 0
self.kamera_grad = 50
self.ui.Kamerawinkel_dreher.sliderMoved.connect(self.kamera_dreher_queue)
self.ui.Lenkung_Slider.sliderMoved.connect(self.lenkung_queue)
self.ui.geschwindichkeit_Slider.sliderMoved.connect(self.geschwindichkeit_queue)
self.ui.winden_Slider.sliderMoved.connect(self.winde_queue)
self.ui.Vorwaerts_Button.toggled.connect(self.vorwaerts_queue)
self.ui.aus_Button.toggled.connect(self.aus_queue)
self.ui.Rueckwaerts_Butten.toggled.connect(self.rueckwaerts_queue)
self.ui.Licht_box_1.pressed.connect(self.licht_queue)
self.ui.Frontlicht_box_1.pressed.connect(self.frontlicht_queue)
self.ui.nebler_box.pressed.connect(self.nebler_queue)
self.ui.licht_Slider.sliderMoved.connect(self.licht_slider_queue)
self.ui.Luft_Probe_Button.clicked.connect(self.luft_probe_queue)
self.ui.Boden_Probe_Button.clicked.connect(self.boden_probe_queue)
self.ui.winden_Slider.setTickPosition(self.ui.winden_Slider.TickPosition.TicksBothSides)
self.signals.j1.connect(self.geschwinichkeit, type=Qt.QueuedConnection)
self.signals.j2.connect(self.lenkung, type=Qt.QueuedConnection)
self.signals.kamera.connect(self.kamera, type=Qt.QueuedConnection)
self.signals.rueck.connect(self.rueckwaerts, type=Qt.QueuedConnection)
self.signals.aus.connect(self.aus, type=Qt.QueuedConnection)
self.signals.vor.connect(self.vorwaerts, type=Qt.QueuedConnection)
self.signals.wd.connect(self.winde, type=Qt.QueuedConnection)
self.signals.k1.connect(self.licht_aus, type=Qt.QueuedConnection)
self.signals.kk2.connect(self.frontlicht, type=Qt.QueuedConnection)
self.signals.k3.connect(self.nebler, type=Qt.QueuedConnection)
self.signals.camdreh.connect(self.kamera_winkel, type=Qt.QueuedConnection)
self.block = False
self.bopro = 1
self.lupro = 1
self.winde(50)
self.kamera_winkel(50)
self.ui.show()
def plot(self):
self.graphWidget.plot([1,2,3,4,5,6],[6,9,3,7,5,8]) #zum testen ob das problem noch besteht
def mess_emiter(self , emit):
self.signals.signals.farber.emit(emit)
def motoren(self, **kwargs):
# ausrechnen der protzentwerte
for key in kwargs:
exec("self." + str(key) + "=" + str(kwargs[key]))
# ausrechnen Motor daten !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
self.motor1 = 0
self.motor2 = 0
self.queue.put("m1"+str(self.motor1))
self.queue.put("m2"+str(self.motor2))
def kamera_dreher_queue(self):
self.queue.put("cd"+str(self.ui.Kamerawinkel_dreher.value()))
def boden_probe_queue(self):
if self.bopro >= 1:
self.queue.put("bp")
self.bopro -= 1
self.ui.label_4.setText(str(self.bopro)+" verfürbar")
if self.bopro == 0:
self.ui.Boden_Probe_Button.setEnabled(False)
self.ui.label_4.setText("0 verfürbar")
def boden_probe_queue_reactivator(self):
self.bopro = 1
self.ui.Boden_Probe_Button.setEnabled(True)
self.ui.label_4.setText("1 verfürbar")
def luft_probe_queue(self):
if self.lupro >= 1:
self.queue.put("lp")
self.lupro -= 1
self.ui.label_5.setText(str(self.lupro) + " verfürbar")
if self.lupro == 0:
self.ui.Luft_Probe_Button.setEnabled(False)
self.ui.label_5.setText("0 verfürbar")
def luft_probe_queue_reactivator(self):
self.lupro = 1
self.ui.Luft_Probe_Button.setEnabled(True)
self.ui.label_5.setText("1 verfürbar")
def licht_slider_queue(self):
self.queue.put("ls"+str(self.ui.licht_Slider.value()))
def nebler_queue(self):
self.queue.put("ne"+str(int(self.invert(self.ui.nebler_box.isChecked()))))
self.fernqueue.put(b"taster3.led(" + bytes(str(int(self.invert(self.ui.nebler_box.isChecked()))),"utf-8")+b")")
#vileict int weg
def aus_queue(self):
if self.ui.aus_Button.isChecked():
self.queue.put("as")
def licht_queue(self):
self.queue.put("li"+str(int(self.invert(self.ui.Licht_box_1.isChecked()))))
self.fernqueue.put(b"taster2.led(" + bytes(str(int(self.invert(self.ui.Licht_box_1.isChecked()))), "utf-8") + b")")
def frontlicht_queue(self):
self.queue.put("fl"+str(int(self.invert(self.ui.Frontlicht_box_1.isChecked()))))
self.fernqueue.put(b"taster1.led(" + bytes(str(int(self.invert(self.ui.Frontlicht_box_1.isChecked()))), "utf-8") + b")")
# vileicht int weg
def rueckwaerts_queue(self):
if self.ui.Rueckwaerts_Butten.isChecked():
self.queue.put("rw")
def vorwaerts_queue(self):
if self.ui.Vorwaerts_Button.isChecked():
self.queue.put("vw")
def lenkung_queue(self):
self.motoren("le"+str(lenk=self.ui.Lenkung_Slider.value()))
def geschwindichkeit_queue(self):
self.motoren(gesch=self.ui.geschwindichkeit_Slider.value())
def winde_queue(self):
self.queue.put(int((self.ui.winden_Slider.value()-50)*2))
def kamera_winkel(self , wert):
self.ui.Kamerawinkel_dreher.setValue(wert)
self.queue.put(wert)
def lenkung(self , wert):
self.ui.Lenkung_Slider.setValue(wert)
self.motoren(lenk = wert )
def geschwinichkeit(self, wert):
self.ui.geschwindichkeit_Slider.setValue(wert)
self.motoren(gesch = wert)
def winde(self, wert):
self.ui.winden_Slider.setValue(wert)
self.queue.put(wert)
def vorwaerts(self):
self.ui.Vorwaerts_Button.setChecked(True)
self.queue.put("vw")
def aus(self):
self.ui.aus_Button.setChecked(True)
self.queue.put("as")
def rueckwaerts(self):
self.ui.Rueckwaerts_Butten.setChecked(True)
self.queue.put("rw")
def licht_aus(self):
self.lwert = self.ui.Licht_box_1.isChecked()
print(self.lwert)
if self.lwert == True:
self.ui.Licht_box_1.setChecked(False)
self.queue.put(False)
self.fernqueue.put(b"taster2.led(0)")
if self.lwert == False:
self.fernqueue.put(b"taster2.led(1)")
self.ui.Licht_box_1.setChecked(True)
self.queue.put(True)
def nebler(self):
self.nwert = self.ui.nebler_box.isChecked()
if self.nwert == True:
self.ui.nebler_box.setChecked(False)
self.queue.put(False)
self.fernqueue.put(b"taster3.led(0)")
if self.nwert == False:
self.fernqueue.put(b"taster3.led(1)")
self.ui.nebler_box.setChecked(True)
self.queue.put(True)
def frontlicht(self):
self.fwert=self.ui.Frontlicht_box_1.isChecked()
if self.fwert == True:
self.ui.Frontlicht_box_1.setChecked(False)
self.queue.put(False)
self.fernqueue.put(b"taster1.led(0)")
if self.fwert == False:
self.fernqueue.put(b"taster1.led(1)")
self.ui.Frontlicht_box_1.setChecked(True)
self.queue.put(True)
def kamera(self, wert , richtung):
if self.block:
self.block = False
self.kamera(False , richtung)
time.sleep(0.0001)
return
if wert:
self.block = True
self.queue4.queue.clear()
self.queue5.queue.clear()
self.classe = Kamera_Dreher(self.queue4 , self.kamera_winkel , self.kamera_grad , richtung , self.queue5, self.signals)
self.classe.start()
if not wert:
self.queue4.put("_")
try:
self.o = self.queue5.get(block=False)
except:
print("Queue 5 non availible")
else:
self.kamera_grad = self.o
self.block = False
def invert(self,inv):
self.inv = inv
if self.inv:
return False
if not self.inv:
return True
class Kamera_Dreher(QRunnable):
def __init__(self , q4 , winkel ,g , richtung , q5 ,signals):
super().__init__()
self.signals = signals
self.lock=threading.Lock()
self.queue4 =q4
self.queue5 = q5
self.send_winkel = winkel
self.grad = g
self.richtung = richtung
def run(self):
self.booll = True
while self.booll:
try:
self.queue4.get(block = True , timeout = 0.05)
except:
if ((self.grad == 0) and (self.richtung == -1)):
self.grad = 100
if ((self.grad == 100) and (self.richtung == 1)):
self.grad = 0
self.grad += self.richtung
self.queue5.put(self.grad)
self.emiter()
else:
self.booll = False
self.queue5.put(self.grad)
@pyqtSlot()
def emiter(self):
self.signals.camdreh.emit(self.grad)
Fehlermeldung:
Traceback (most recent call last):
File "/home/levin/PycharmProjects/qtTest/main.py", line 23, in <module>
window = MainWindow(dreh_queue , robo , dreh_queue2 , main_fern , gr.signals)
File "/home/levin/PycharmProjects/qtTest/mainwindow.py", line 59, in __init__
self.signals.j1.connect(self.geschwinichkeit, type=Qt.QueuedConnection)
AttributeError: type object 'Qt' has no attribute 'QueuedConnection'
LG sauterle
Traceback (most recent call last):
File "/home/levin/PycharmProjects/qtTest/main.py", line 23, in <module>
window = MainWindow(dreh_queue , robo , dreh_queue2 , main_fern , gr.signals)
File "/home/levin/PycharmProjects/qtTest/mainwindow.py", line 59, in __init__
self.signals.j1.connect(self.geschwinichkeit, type=Qt.QueuedConnection)
AttributeError: type object 'Qt' has no attribute 'QueuedConnection'
LG sauterle
- __blackjack__
- User
- Beiträge: 13181
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
Ich glaube PyQt6 stellt die Aufzählungswerte nicht mehr einfach so direkt zur Verfügung, sondern nur noch über den Datentyp: ``Qt.ConnectionType.QueuedConnection``.
“There will always be things we wish to say in our programs that in all known languages can only be said poorly.” — Alan J. Perlis
danke Blackjack dass war tatsächlich die Lösung dieses Problems.Das Problem dass die gui immer kurz einfriert besteht leider weiterhin (aber nur solange ich keine Instanz der klasse Fernsteuerung als Thread starte)
LG sauterle
LG sauterle
Der Code hat wirklich eine Menge Probleme. Lauter unnoetiger Kram, der nicht benutzt wird, fehlerhaft ist, und verwirrt. ZB self.threadpool, self.locker. Durchnummerierte queues, statt die vernuenftig zu benennen. Oder noch besser: q2 dann in fernqueue umbennen. Warum heisst die nicht ueberall fernqueue?
Und das ganze ge-queue, wenn man qt signale/slots benutzt, ist eigentlich auch ueberfluessig.
Da der Kamera_Dreher nirgendwo instatiiert wird, ist es aber aufgerufen, ist es wohl doch nicht der Code, der wirklich laeuft. Also doch wieder: bitte den *gesamten* Quellcode zeigen. Nicht irgendwas kuratiertes, von dem du denkst, dass es ausreichend ist.
Und das ganze ge-queue, wenn man qt signale/slots benutzt, ist eigentlich auch ueberfluessig.
Da der Kamera_Dreher nirgendwo instatiiert wird, ist es aber aufgerufen, ist es wohl doch nicht der Code, der wirklich laeuft. Also doch wieder: bitte den *gesamten* Quellcode zeigen. Nicht irgendwas kuratiertes, von dem du denkst, dass es ausreichend ist.
- __blackjack__
- User
- Beiträge: 13181
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
Wobei kürzen an sich auch keine schlechte Idee ist, aber dann gekürzt *und* lauffähig *und* getestet, dass das Problem auch im gekürzten und getesteten Code noch besteht.
“There will always be things we wish to say in our programs that in all known languages can only be said poorly.” — Alan J. Perlis
der fehler tritt auf wenn ich folgende funktion aud Fernsteuerung in einem try block laufen lasse:
kommentiere ich aber folgende stücke aus und setze ein bsp. print(876) darunter dann tritt er nicht auf:
und zu
mache ich das print wieder weg tritt der fehler wieder auf
Code: Alles auswählen
@pyqtSlot()
def reader(self):
self.read=self.port.readline()
if self.read != b"":
self.erst = self.read[0:2]
try:
self.wert = int(self.read[2:])
except:
self.wert = None
if self.erst == b"j1":
self.wert = self.lehr_bereich(self.wert)
self.signals.j1.emit(self.wert)
if self.erst == b"j2":
self.wert += 3
self.wert = self.lehr_bereich(self.wert)
self.signals.j2.emit(self.wert)
if self.erst == b"kr":
self.signals.kamera.emit(self.wert)
if self.erst == b"kl":
self.signals.kamera.emit(self.wert)
if self.erst == b"mk":
if self.wert == 1:
self.signals.rueck.emit()
if self.wert == 2:
self.signals.aus.emit()
if self.wert == 3:
self.signals.vor.emit()
if self.erst == b"wd":
self.wert = self.lehrbereich(self.wert)
self.signals.wd.emit(self.wert)
if self.erst == b"k1":
self.signals.k1.emit()
if self.erst == b"k2":
self.signals.kk2.emit()
if self.erst == b"k3":
self.signals.k3.emit()
if self.write != None:
self.port.write(self.write)
self.write = None
Code: Alles auswählen
if self.write != None:
self.port.write(self.write)
self.write = None
Code: Alles auswählen
self.read=self.port.readline()
Code: Alles auswählen
self.read=b""#self.port.readline()