ständig aktualisirender graph in qt

sauterle · Dienstag 29. August 2023, 14:54

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

__deets__ · Dienstag 29. August 2023, 14:58

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.

grubenfox · Dienstag 29. August 2023, 15:05

fundsache... https://www.pythonguis.com/tutorials/pl ... g-the-plot

grubenfox · Dienstag 29. August 2023, 15:10

das holen/aktualisieren der Temperaturdaten dürfte der interessantere Teil für einen eigenen Thread sein.

sauterle · Dienstag 29. August 2023, 18:26

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

__deets__ · Dienstag 29. August 2023, 19:17

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.

sauterle · Dienstag 29. August 2023, 20:13

wie macht man das mit den QueuedConnections und wie löst das mein Problem?
LG sauterle

__deets__ · Dienstag 29. August 2023, 20:26

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?

sauterle · Mittwoch 30. August 2023, 10:31

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

__deets__ · Mittwoch 30. August 2023, 10:34

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.

sauterle · Mittwoch 30. August 2023, 11:17

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

__deets__ · Mittwoch 30. August 2023, 12:08

Bitte den gesamten Code und vollständige Fehlermeldung zeigen.

sauterle · Mittwoch 30. August 2023, 12:21

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)

sauterle · Mittwoch 30. August 2023, 12:22

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

__blackjack__ · Mittwoch 30. August 2023, 12:23

Ich glaube PyQt6 stellt die Aufzählungswerte nicht mehr einfach so direkt zur Verfügung, sondern nur noch über den Datentyp: ``Qt.ConnectionType.QueuedConnection``.

sauterle · Mittwoch 30. August 2023, 12:31

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

__deets__ · Mittwoch 30. August 2023, 12:38

Edit: mein Fehler, ich habe den Post davor mit dem Code nicht gesehen. Schaue mir das an.

__deets__ · Mittwoch 30. August 2023, 12:48

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.

__blackjack__ · Mittwoch 30. August 2023, 12:51

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.

sauterle · Mittwoch 30. August 2023, 13:04

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

Code: Alles auswählen

self.read=self.port.readline()

zu

Code: Alles auswählen

self.read=b""#self.port.readline()

mache ich das print wieder weg tritt der fehler wieder auf