PYQT5 "Eingang und Ausgang GUI"

[Pumajuma]

Hallo ,

Ich habe beim Programmieren einer Gui, für die Arbeit, ein paar Probleme nach vieler Zeit des suchens eine Lösung dafür zu finden in Youtube via Google usw bin ich auf dieses Forum gestoßen, mit der Hoffnung hier vllt Hilfreiche tipps oder lösungen zu bekommen. Dazu sei gesagt ich bin kein absoluter Profi in Python und PyQt. Habe mich mit beiden erst vor kurzem auseinander gesetzt.

Nun zur Aufgabe:D

Und zwar ist meine Aufgabe eine GUI zu entwickeln welche auf einen Raspberry 4B läuft. Über die 2 Hdmi outputs sind zwei Touchdisplay angeschlossen. Über das drücken eines Warnbuttons auf dem Display 1 switcht die Ui in den Gefahrenmodus:
2 Neue Fenster auf beiden Display erscheinen, wobei nun bei display 1 sich Gefahrenmodusbeenden-Button befindet und auf Display 2 ein Klingelbutton.
Beim Klingeln soll auf Display 1 nun ein Popup fenster erscheinen ( "Bitte Warten Tür wird gleich Geöffnet", "Ignorieren", "Keine Zeit").
Beim Drücken auf den Gefahrenmodus Beenden Button:
Werden bei Display 1 und 2 wieder die Anfangsfenster geöffnet.

Mein Plan Bisher

Ich habe eine Main Worüber ich alle Fenster erstellen und Verwalten kann Mit .show .hide.
. Bei Knopfdruck auf die Klingel soll auch ein GPIO vom PI aktiviert werden für 30 sek. welches mit einem Relay verbunden ist und eine Alarmleuchte aktivieren soll.

Mein Problem:

Wie Kann ich von einer Klasse zur Main Signale senden, sodass ich mit Knopfdruck bei der einen klasse ein signal oder string zur Main sende?
Dieser String z.B. durchläuft dann Mehrere Cases oder mehrere If Abfragen in der Main, welche entscheiden was geschieht (Pop Up Fenster Öffnen, 2 andere Fenster verstecken und andere Fenster anzeigen).

mfG

[Sirius3]

Statt vieler Worte, schreibe ein kurzes Demo-Programm, das Dein Problem zeigt und an welcher Stelle Du nicht mehr weiter kommst. Das Signal-Slot-Konzept von Qt ist Dir klar?

[Pumajuma]

Danke für den Tip, habe mich auch dann über Signals und Slots belesen und über PyQt an sich. Nu konnte ich eine Hauptmain erstellen, nur werden in der hauptmain wenn ich das Programm starte keine eingefügten Bilder im Fenster angezeigt, aber im Qt Designer aber schon.

Code: Alles auswählen

import sys
import PyQt5.QtCore as core
from PyQt5.QtCore import QTimer
from PyQt5.QtGui import QMovie
import PyQt5.QtWidgets as widgets
import PyQt5.QtGui as gui
import PyQt5.uic as uic
from PyQt5.QtWidgets import QApplication, QDesktopWidget
import time



app = widgets.QApplication(sys.argv)

start_time = time.time()

display1 = 0
display2 = 1

wi1 = uic.loadUi("Main_Innen.ui")
wi2 = uic.loadUi("WarnungInnen.ui")
wi3 = uic.loadUi("Klingelpopup.ui")

monitor = QDesktopWidget().screenGeometry(display1)
wi1.move(monitor.left(), monitor.top())
wi2.move(monitor.left(), monitor.top())
wi3.move(monitor.left(), monitor.top())
#wa1.showFullScreen()


wa1 = uic.loadUi("MainAussen.ui")
wa2 = uic.loadUi("WarnungAussen.ui")
wa3 = uic.loadUi("Klingelvideo.ui")
wa4 = uic.loadUi("Eintretenfenster.ui")

monitor = QDesktopWidget().screenGeometry(display2)
wa1.move(monitor.left(), monitor.top())
wa2.move(monitor.left(), monitor.top())
wa3.move(monitor.left(), monitor.top())
wa4.move(monitor.left(), monitor.top())


gif = QMovie('Loading_2.gif')
wa3.Anzeigefeld.setMovie(gif)

#timer.singleShot(3000, stopwa3)

def stopwa3():
	wa3.close()

def stopwa4():
	wa4.close()

def w1gefahrenmodus():
	wi2.show()
	wa2.show()
	wi1.hide()
	wa1.hide()

def w2klingeln():
	#wa3.Anzeigefeld.setText("")
	timer=QTimer(wa3)
	timer.singleShot(3000, stopwa3)
	wi3.show()
	wa3.show()
	gif.start()

	#gpi0 aktivieren Zeit 5sekunden Tröte, 30 sekunden licht
	#nach 30 sekunden Hide


def w3Eintreten():
	#wa3.Anzeigefeld.setText("bitte Eintreten :)")
	wa4.show()
	timer=QTimer(wa4)
	timer.singleShot(3000, stopwa4)
	wi3.hide()
	

	#wa3 und Textlabel Ändern nach 45 sek schließen "time implementieren"
	
	#start_time = time.time()
	#end_time = time.time()
	#dauer = time.time()-start_time
	#while  dauer < 10:
		#wa3.Anzeigefeld.setText("bitte Eintreten :)"+ " "+ str(dauer))
		#dauer = time.time()-start_time
	#else:
		#wa3.hide()


def w3Warten():
	wa3.Anzeigefeld.setText("In " + "min können sie es erneut versuchen")
	#wa3.hide() in 4min
	wi3.hide()

def w3Abbrechen():
	wi3.hide()
	wa3.hide()

def w2Gefahrmodusende():
	wi1.show()
	wa1.show()
	wi3.hide()
	wa3.hide()
	wi2.hide()
	wa2.hide()


wi3.Reglerbutton.clicked.connect(w3Warten)
wi3.AbbrechenButton.clicked.connect(w3Abbrechen)
wi3.okButton.clicked.connect(w3Eintreten)

wi1.pushButton.clicked.connect(w1gefahrenmodus)

wa2.Klingel.clicked.connect(w2klingeln)
wi2.GefahrbeendenButton.clicked.connect(w2Gefahrmodusende)

#wi2.show()
#wa2.show()
wi1.show()
wa1.show()


sys.exit(app.exec_())

[__blackjack__]

@Pumajuma: Das ist alles extrem unübersichtlich. Ich würde das Thema GUI mal kurz beiseite legen und Grundlagen bis einschliesslich Klassen durcharbeiten, denn die braucht man bei jeder nicht-trivialen GUI. Vor Klassen müsste man Funktionen lernen, denn davon enthält der gezeigte Quelltext im Grunde keine einzige. Funktionsdefinitionen werden dort nur für so etwas wie Sprungmarken missbraucht.

Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst. Funktionen und Methoden bekommen alles was sie ausser Konstanten benötigen als Argument(e) übergeben. Ergebnisse werden als Rückgabewerte zum Aufrufer zurückgegeben. Und falls das nicht geht, man sich also Zustand über Aufrufe hinweg merken muss, braucht man Klassen.

Da steht auskommentierter Code mit einer ``while``-Schleife der so nicht funktionieren wird: Bei GUIs muss die GUI-Hauptschleife laufen. Die ruft bei bestimmten Ereignissen (Button geklickt, bestimmte Zeit verstrichen, …) vom Programmierer gegistrierte Slots auf. Der Code dort darf dann *kurz* etwas machen, und muss zur GUI-Hauptschleife zurückkehren. Sonst blockiert die GUI und nimmt keine Eingaben mehr entgegen und wird nicht aktualisiert.

Sehr viele von den Namen sind sehr schlecht. Namen sollten keine kryptischen Abkürzungen enthalten und schon gar nicht nur aus solchen bestehen und Namen nummeriert man nicht. Nummerierte Namen sind ein Zeichen das man sich entweder bessere Namen ausdenken will oder gar keine Einzelnamen sondern eine Datenstruktur verwenden will. Oft eine Liste.

Die Importe sehen auch sehr durcheinander aus. Da wird soweit ich das sehe auch nicht alles verwendet. Die ganzen umbenannten Modulimporte könnte man sich sparen.

[AxelN]

@__blackjack__, hallo, ich habe deine Einwände gelesen und habe zum 3. Absatz eine Frage:
Wie kann man nun das Problem mit der while-Schleife umgehen?

Ich will eigentlich etwas ähnliches realisieren, einen Temperatursensor im Hintergrund abfragen, die Temperatur und Feuchte dann natürlich an die GUI übergeben und anzeigen.
Der Sensor soll allerdings Pausen einlegen, so zwischen 5 Sekunden bis mehrere Stunden, ja nach Eingabe.

[__blackjack__]

@AxelN: Wenn das auslesen des Temperatursensors schnell geht und nicht blockieren kann, dann kann man das einfach mit einerm `QTimer` lösen. Ansonsten braucht man Threads. Bei Qt würde sich ein QThread anbieten der den Messwert als Signal zur Verfügung stellt, das man per `connect()` dann mit einer Methode verbindet, die diesen Wert in der GUI anzeigt.