Seite 1 von 3
ständig aktualisirender graph in qt
Verfasst: Dienstag 29. August 2023, 14:54
von sauterle
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
Re: ständig aktualisirender graph in qt
Verfasst: Dienstag 29. August 2023, 14:58
von __deets__
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.
Re: ständig aktualisirender graph in qt
Verfasst: Dienstag 29. August 2023, 15:05
von grubenfox
Re: ständig aktualisirender graph in qt
Verfasst: Dienstag 29. August 2023, 15:10
von grubenfox
das holen/aktualisieren der Temperaturdaten dürfte der interessantere Teil für einen eigenen Thread sein.
Re: ständig aktualisirender graph in qt
Verfasst: Dienstag 29. August 2023, 18:26
von sauterle
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: 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 2:
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/aktualisieren der Temperaturdaten dürfte der interessantere Teil für einen eigenen Thread sein.
das holen ,errechen, und als signal zum main window schicken tut schon ein Thread
LG sauterle
Re: ständig aktualisirender graph in qt
Verfasst: Dienstag 29. August 2023, 19:17
von __deets__
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.
Re: ständig aktualisirender graph in qt
Verfasst: Dienstag 29. August 2023, 20:13
von sauterle
wie macht man das mit den QueuedConnections und wie löst das mein Problem?
LG sauterle
Re: ständig aktualisirender graph in qt
Verfasst: Dienstag 29. August 2023, 20:26
von __deets__
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?
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 10:31
von sauterle
Hallo so wie ich dass jetzt verstanden habe muss ich einfach bei jedem "connect " type=Qt.QueuedConnection als benanntes Argument mit "einbauen". ist dass richtig?
LG sauterle
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 10:34
von __deets__
Nicht bei jedem, aber bei den Signalen, die ueber die Grenzen von Threads macht. Das wuerde automatisch passieren, wenn man die Thread-Ownership korrekt handhabt, aber das muss man auch erstmal verstehen.
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 11:17
von sauterle
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:
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)
LG sauterle
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 12:08
von __deets__
Bitte den gesamten Code und vollständige Fehlermeldung zeigen.
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 12:21
von sauterle
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)
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 12:22
von sauterle
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
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 12:23
von __blackjack__
Ich glaube PyQt6 stellt die Aufzählungswerte nicht mehr einfach so direkt zur Verfügung, sondern nur noch über den Datentyp: ``Qt.ConnectionType.QueuedConnection``.
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 12:31
von sauterle
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
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 12:38
von __deets__
Edit: mein Fehler, ich habe den Post davor mit dem Code nicht gesehen. Schaue mir das an.
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 12:48
von __deets__
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.
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 12:51
von __blackjack__
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.
Re: ständig aktualisirender graph in qt
Verfasst: Mittwoch 30. August 2023, 13:04
von sauterle
der fehler tritt auf wenn ich folgende funktion aud Fernsteuerung in einem try block laufen lasse:
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
kommentiere ich aber folgende stücke aus und setze ein bsp. print(876) darunter dann tritt er nicht auf:
Code: Alles auswählen
if self.write != None:
self.port.write(self.write)
self.write = None
und
zu
mache ich das print wieder weg tritt der fehler wieder auf