Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- waggelomma [2022/06/23 20:51] – student
+++ waggelomma [2023/07/03 10:16] (aktuell) – Externe Bearbeitung 127.0.0.1
@@ Zeile 1: / Zeile 1: @@
+====== Kurzbeschreibung ======
+Der Hintergrund unseres Projekts ist ein medizinischer: eine Dekubitus-Prophylaxe. Das Sitzkissen basiert auf dem Prinzip einer Wechseldruckmatratze. Durch verschiedene Komponenten lässt sich der Druck im Kissen steuern. Mithilfe des Touch-Displays lässt sich im Voraus festlegen, ob der Druck manuell gesteuert werden soll oder durch ein integriertes Programm. Das Sitzkissen kann somit nach den Belieben des Anwenders gesteuert werden.
+{{:gruen.jpg?400|}}  {{:blau.jpg?400|}}  {{:aufbau_waggelomma.jpeg?200|}}
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+====== Aufbau ======
+Das 7‘‘ LCD Touch-Display lässt sich über ein Desktop-Icon starten. Es öffnet sich eine grafische Oberfläche mit zwei Buttons mit den Beschriftungen „Zeitprogramm“ und „Manuell“. Nachdem sich der Anwender zwischen den zwei Optionen entschieden hat, erscheinen mehrere Buttons, die bedient werden können. Je nachdem für welche Option sich der Benutzer entschieden hat, lassen sich die Buttons unterschiedlich bedienen. Beispielsweise kann man bei der Auswahl „Manuell“ kein Zeitprogramm starten, sondern nur per manueller Steuerung die einzelnen Kammern füllen oder leeren. Welche Buttons sich wann bedienen lassen, wird durch das angehangene Fließdiagramm deutlich. Die Motoren (ONPIRA Luftpumpen, 12V) pumpen Luft in die jeweiligen Kammern rein bzw. saugen diese ab. Da die Motoren immer zeitgleich Luft pumpen und absaugen, müssen die Magnetventile (stromlos offen, 12V) die Luftzufuhr steuern. Über die Steckplatinen sind die H-Brücken angeschlossen. An den H-Brücken sind die Motoren und die Magnetventile verkabelt.
+{{ :fliessdiagramm_waggelomma.jpg?600 |}}
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+====== Bauteile ======
+  * 3x H-Brücke
+{{ :h-bruecke.jpg?200 |}}
+  * 2x ONPIRA Luftpumpe, 12V
+{{ :luftpumpe.jpg?200 |}}
+  * 4x Magnetventile 12V, 0.4bar, offen
+{{ :magnetventil.png?200 |}}
+  * 1x DR. WINKLER Zwilling Sitzkissen mit 2 getrennten Luftkammern (43x43cm)
+{{ :sitzkissen.jpg?200 |}}
+  * 2x Steckplatinen
+{{ :steckbrett.png?200 |}}
+  * 1x 7‘‘ LCD Touch-Display
+{{ :7_lcd.png?200 |}}
+  * 1x GPIO-Adapterkabel
+  * 1x T-Cobbler für den Raspberry Pi
+{{ :adapter.jpg?200 |}}
+  * 1x ZIPPY FlightMax 2800mAh 30C
+{{ :batterie.jpg?200 |}}
+  * Kabel
+  * Schläuche
+  * Adapter für die Schläuche aufgrund unterschiedlicher Durchmesser
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+====== Schaltplan ======
+{{ :schaltplan_waggelomma.jpg?600 |}}
+//Schläuche, Sitzkissen und Schlauchadapter sind auf dem Schaltplan nicht sichtbar//
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+====== Quellcode ======
+Zunächst haben wir alle benötigten Bibliotheken und GPIO's importiert.
+<file c Code.c>
+import RPi.GPIO as gpio                 #klassische Bibliothek um die Pins anzusteuern
+import pygame_horstEdition as horst     #vereinfachte Pygame-Bibliothek
+import time                             #Erlaubt Zugriff auf sleep() und Systemzeit
+#region GPIO-Müll
+gpio.setwarnings(False)
+gpio.setmode(gpio.BOARD)  #GPIO-Belegung auf die des Shields stellen
+gpio.setup(12, gpio.OUT)  #GPIOs als Ausgang deklarieren
+gpio.setup(11, gpio.OUT)     #11 und 12 sind Ventile rechts
+gpio.setup(13, gpio.OUT)
+gpio.setup(15, gpio.OUT)
+gpio.setup(29, gpio.OUT)
+gpio.setup(21, gpio.OUT)     #21 und 22 sind Ventile links
+gpio.setup(22, gpio.OUT)
+gpio.setup(36, gpio.OUT)     #40 36 32 16  --> 40 & 36 und 32 & 16 Motor
+gpio.setup(16, gpio.OUT)
+gpio.setup(32, gpio.OUT)
+gpio.setup(40, gpio.OUT)
+#endregion
+</file>
+Danach haben wir uns um das Touch-Display gekümmert. Hier haben wir die Auflösung des Bildschirms festgelegt und alle Knöpfe, Icons und die dazugehörigen Texte angelegt.
+<file c Code.c>
+horst.start((1920,1080),(1,1,1))   #startet die Horstbibliothek mit einer Auflösung von 1920x1080 und mit Hintergrundfarbe RGB(1,1,1)
+bildschenTitel = horst.Picture((217,55),("/home/pi/Desktop/ProjektAktuell/WaggelommaText.png"))   #Titel WaggelOmma
+knoppekAutomatisch = horst.Knopp((138,300),(770,700),(0,145,0))        #Knopf "Automatisch"
+bildschenAutomatisch = horst.Picture((225,426),("/home/pi/Desktop/ProjektAktuell/Audomatique.png"))    #Icon + Text
+knoppekManuell = horst.Knopp((1026,300),(770,700),(0,145,0))            #Knopf "Manuell"
+bildschenManuell = horst.Picture((1248,426),("/home/pi/Desktop/ProjektAktuell/Manuéla.png"))            #Icon + Text
+Kammerli = horst.Rect((74,338),(557,122),(25,174,255))    #Feld für Kammer links
+Kammerli.setVisible(False)                                #Feld zu Beginn unsichtbar
+schriftKammerli = horst.Text((214,375),("Kammer links"),(255,255,255))  #Beschriftung des Feldes links
+schriftKammerli.setVisible(False)      #Beschriftung zu Beginn unsichtbar
+Kammerre= horst.Rect((1289,338),(557,122),(25,174,255))   #Feld für Kammer rechts
+Kammerre.setVisible(False)    #Feld zu Beginn unsichtbar
+schriftKammerre = horst.Text((1420,375),("Kammer rechts"),(255,255,255))  #Beschriftung des Feldes rechts
+schriftKammerre.setVisible(False)  #Schrift zu Beginn unsichtbar
+#region HorstElemente
+knoppekStart = horst.Knopp((74,885),(374,140),(25,174,255))  #Start Knopf --> Kissen wird aufgeblasen
+knoppekStart.setActive(False)  #Start Knopf zu Beginn inaktiv
+knoppekStart.setVisible(False)  #Start Knopf zu Beginn nicht sichtbar
+schriftStart = horst.Text((207,929),("Start"),(255,255,255))  #Beschriftung
+schriftStart.setVisible(False)  #Beschriftung zu Beginn nicht sichtbar
+knoppekZeitprogramm = horst.Knopp((544,885),(374,140),(25,174,255))  #Zeitprogramm Knopf --> Zeitprogramm startet
+knoppekZeitprogramm.setActive(False)  #Knopf zu Beginn inaktiv
+knoppekZeitprogramm.setVisible(False)  #Knopf zu Beginn nicht sichtbar
+schriftZeitprogramm = horst.Text((624,929),("Programm"),(255,255,255))  #Beschriftung
+schriftZeitprogramm.setVisible(False)  #Schrift zu Beginn nicht sichtbar
+knoppekPause = horst.Knopp((1019,885),(374,140),(25,174,255)) #Pause Knopf --> Zeitprogramm wird auf Pause gesetzt
+knoppekPause.setActive(False)  #Knopf zu Beginn inaktiv
+knoppekPause.setVisible(False)  #Knopf zu Beginn nicht sichtbar
+schriftPause = horst.Text((1135,929),("Pause"),(255,255,255))  #Beschriftung
+schriftPause.setVisible(False)  #Schrift zu Beginn nicht sichtbar
+knoppekEnde = horst.Knopp((1482,885),(374,140),(25,174,255)) #Ende Knopf --> bricht alles ab
+knoppekEnde.setActive(False)  #Knopf zu Beginn inaktiv
+knoppekEnde.setVisible(False)  #Knopf zu Beginn nicht sichtbar
+schriftEnde = horst.Text((1618,929),("Ende"),(255,255,255))  #Beschriftung
+schriftEnde.setVisible(False)  #Schrift zu Beginn nicht sichtbar
+knoppekDrucklihoch = horst.Knopp((74,495),(257,118),(25,174,255)) #Knopf erhöht den Druck re
+knoppekDrucklihoch.setActive(False)  #Knopf zu Beginn inaktiv
+knoppekDrucklihoch.setVisible(False)  #Knopf zu Beginn nicht sichtbar
+bildschenDrucklihoch = horst.Picture((150,504),("/home/pi/Desktop/ProjektAktuell/PfeilHochKleener.png")) #Icon Pfeil hoch
+bildschenDrucklihoch.setVisible(False)  #Icon zu Beginn nicht sichtbar
+knoppekDrucklirunter = horst.Knopp((374,495),(257,118),(25,174,255)) #Knopf senkt den Druck re
+knoppekDrucklirunter.setActive(False)  #Knopf zu Beginn inaktiv
+knoppekDrucklirunter.setVisible(False)  #Knopf zu Beginn nicht sichtbar
+bildschenDrucklirunter = horst.Picture((450,504),("/home/pi/Desktop/ProjektAktuell/PfeilRunterKleener.png"))  #Icon Pfeil runter
+bildschenDrucklirunter.setVisible(False)  #Icon zu Beginn nicht sichtbar
+knoppekDruckrehoch = horst.Knopp((1294,495),(257,118),(25,174,255)) #Knopf erhöht den Druck li
+knoppekDruckrehoch.setActive(False)  #Knopf zu Beginn inaktiv
+knoppekDruckrehoch.setVisible(False)  #Knopf zu Beginn nicht sichtbar
+bildschenDruckrehoch = horst.Picture((1370,504),("/home/pi/Desktop/ProjektAktuell/PfeilHochKleener.png"))  #Icon Pfeil hoch
+bildschenDruckrehoch.setVisible(False)  #Icon zu Beginn nicht sichtbar
+knoppekDruckrerunter = horst.Knopp((1591,495),(257,118),(25,174,255)) #Knopf senkt den Druck li
+knoppekDruckrerunter.setActive(False)  #Knopf zu Beginn inaktiv
+knoppekDruckrerunter.setVisible(False)  #Knopf zu Beginn nicht sichtbar
+bildschenDruckrerunter = horst.Picture((1665,504),("/home/pi/Desktop/ProjektAktuell/PfeilRunterKleener.png"))  #Icon Pfeil runter
+bildschenDruckrerunter.setVisible(False)  #Icon zu Beginn nicht sichtbar
+slider = horst.Slider((74,670),(1774,146),(1,1,1),(25,174,255),(0),(1)) #Slider wieviel Zeit übrig ist
+slider.setVisible(False)  #Slider zu Beginn nicht sichtbar
+#endregion
+horst.refresh()  #Bildelemente werden neu geladen, damit sie endgültig verschwinden und das 'Verschwinden' auch wirksam ist
+</file>
+Nun werden alle benötigten Methoden deklariert. Dies haben wir gemacht, um später weniger Arbeit zu haben, da dann nur noch die einzelnen Methoden aufgerufen werden müssen und man sich unnötige Schreibarbeit spart.
+<file c Code.c>
+#region Hauptfunktionen
+def ElBlaso(kammer):                #Methode: Der Kammer [kammer] wird Luft zugeführt, bzw. Ventile vom Blasen sind auf (stromlos offen) und Ventil vom Saugen zu
+    #print("blaso "+str(kammer))     #zum debuggen, um in der Konsole zu sehen, was grade passiert
+    if(kammer ==1):          #wir pusten in Kammer 1
+        gpio.output(22, 1)   #ventil zu
+        gpio.output(21, 0)   #ventil offen
+    else:                    #wir pusten in Kammer 2
+        gpio.output(12, 0)   #ventil offen
+        gpio.output(11, 1)   #ventil zu
+def ElSaugo(kammer):                #Methode: Der Kammer [kammer] wird Luft abgezogen, bzw. Ventile vom Saugen sind offen und vom Blasen zu
+    #print("saugo "+str(kammer))    #zum debuggen, um in der Konsole zu sehen, was grade passiert
+    if(kammer==1):           #Kammer 1 wird angesprochen
+        gpio.output(22, 0)   #ventil offen
+        gpio.output(21, 1)   #ventil zu
+    else:                    #Kammer 2 wird angesprochen
+        gpio.output(12, 1)   #ventil zu
+        gpio.output(11, 0)   #ventil offen
+def ElHalto(kammer):                #Methode: Die Ventile zu Kammer [kammer] halten die Luft, bzw. Ventile sind zu
+    #print("halto "+str(kammer))  #zum debuggen, um in der Konsole zu sehen, was grade passiert
+    #gpio.output(36, 0)   #Motoren aus
+    if(kammer==1):          #Kammer 1 wird angesprochen
+        gpio.output(22, 1)  #ventil zu
+        gpio.output(21, 1)  #ventil zu
+    else:                   #Kammer 2 wird angesprochen
+        gpio.output(12, 1)  #ventil zu
+        gpio.output(11, 1)  #ventil zu
+def reicht():                           #Methode: Motor aus, ventile offen --> Luft geht raus
+    gpio.output(36, 0)   #Motoren aus
+    gpio.output(11, 0)   #ventil offen
+    gpio.output(22, 0)   #offen
+    gpio.output(21, 0)   #offen
+    gpio.output(12, 0)   #offen
+    gpio.cleanup()      #räumt uff
+def Motörchen(state):           #Methode: setzt die Motoren auf [state] --> 1 oder 0
+    #print("Motor "+str(state))  #zum debuggen, um in der Konsole zu sehen, was grade passiert
+    gpio.output(36, state)      #Motoren werden auf [state] gestellt --> 1 oder 0
+def KritischeAbbruchfrage():        #Methode: Bricht ab wenn der Ende-Knoppek gedrückt wird
+    if knoppekEnde.isPressed():     #Ist der Ende-Knoppek gedrückt?
+        reicht()            #Motoren aus, Ventile auf
+        exit()              #Programm wird beendet
+def DruckVerstello(input):      #Methode: verstellt einen bestimmten Kammerdruck für 10 Sekunden, Definiert als 1: Links rein; 2: Links raus, 3: Rechts rein; 4: Rechts raus
+    horst.keepAlive()       #verhindert, dass pygame-Bibliothek abstürtzt und sucht nach gerade gedrückten Knöpfen
+    time.sleep(0.2)
+    zeitpunkt = time.time()   #neue variable [zeitpunkt] wird mit der aktuellen zeit in sekunden seit 1970 belegt
+    if(input ==1):    #wenn input = 1
+       ElBlaso(1)     #Luft in linke kammer rein
+       ElHalto(2)    #luft bleibt in rechter kammer drin
+    if(input == 2):   #wenn input = 2
+        ElSaugo(1)    #luft aus kammer links raus
+        ElHalto(2)    #luft bleibt in kammer rechts drin
+    if(input == 3):   #wenn input=3
+        ElBlaso(2)    #luft in kammer rechts rein
+        ElHalto(1)    #luft bleibt in kammer links drin
+    if(input == 4):   #wenn input = 4
+        ElSaugo(2)    #luft aus rechter kammer raus
+        ElHalto(1)    #luft bleibt in kammer links drin
+    Motörchen(1)  #motor wird angeschaltet
+    while time.time()-zeitpunkt < 10:  #zeit - jetzigem zeitpunkt kleiner 10 --> while schleife läuft 10sek
+        horst.keepAlive()  #verhindert absturz des programmes und sucht nach gedrückten knöpfen
+        time.sleep(0.2)
+        KritischeAbbruchfrage()   #wenn ende knopf gedrückt wird, wird alles beendet --> Methode wird aufgerufen
+        if (knoppekDruckrehoch.isPressed()or knoppekDruckrerunter.isPressed()or knoppekDrucklihoch.isPressed()or knoppekDrucklirunter.isPressed()):  #wenn irgendein Druckregulationsknopf gedrückt wird,...
+            break #... dann brich ab --> 10sek werden nicht abgewartet, sondern bricht ab
+    Motörchen(0) #motoren aus
+def MannoProgram():     #manuelles Programm
+    while 1:  #endlosschleife
+            horst.keepAlive()  #verhindert absturz des programmes und sucht nach gedrückten knöpfen
+            if knoppekDruckrehoch.isPressed(): #wenn Knopf rehoch gedrückt,...
+                DruckVerstello(3)  #... dann luft rechts rein
+            if knoppekDruckrerunter.isPressed():
+                DruckVerstello(4)  #... dann luft rechts raus
+            if knoppekDrucklihoch.isPressed():
+                DruckVerstello(1)  #... dann luft links rein
+            if knoppekDrucklirunter.isPressed():
+                DruckVerstello(2)  #... dann luft links raus
+            KritischeAbbruchfrage() #wenn ende knopf gedrückt wird, wird alles beendet --> Methode wird aufgerufen
+            if knoppekPause.isPressed():break  #wenn knopf pause gedrückt wird, break
+            time.sleep(0.2)
+def GroßKnoppeksWech():    #Methode: grüne Knöpfe weg
+    knoppekAutomatisch.setActive(False)  #Knopf automatisch nicht aktiv
+    knoppekAutomatisch.setVisible(False)  #knopf automatisch nicht sichtbar
+    knoppekManuell.setActive(False)  #knopf manuell nicht aktiv
+    knoppekManuell.setVisible(False)  #knopf manuell nicht sichtbar
+    bildschenAutomatisch.setVisible(False)  #bild automatisch unsichtbar
+    bildschenManuell.setVisible(False)  #bild manuell unsichtbar
+def KleineKnoppeksHer():  #methode: kleine knöpfe sichtbar machen und aktivieren
+    knoppekZeitprogramm.setActive(True)  #knopf zeitprogramm aktiv
+    knoppekZeitprogramm.setVisible(True)  #knopf zeitprogramm sichtbar
+    knoppekStart.setActive(True)  #knopf start aktiv
+    knoppekStart.setVisible(True)  #knopf start sichtbar
+    knoppekPause.setActive(True)  #knopf pause aktiv
+    knoppekPause.setVisible(True)  #knopf pause sichtbar
+    knoppekEnde.setActive(True)  #knopf ende aktiv
+    knoppekEnde.setVisible(True)  #knopf ende sichtbar
+    knoppekDrucklihoch.setActive(True)  #knopf drucklihoch aktiv
+    knoppekDrucklihoch.setVisible(True)  #knopf drucklihoch sichtbar
+    knoppekDrucklirunter.setActive(True)  #knopf drucklirunter aktiv
+    knoppekDrucklirunter.setVisible(True)  #knopf drucklirunter sichtbar
+    knoppekDruckrehoch.setActive(True)  #knopf druckrehoch aktiv
+    knoppekDruckrehoch.setVisible(True)  #knopf druckrehoch sichtbar
+    knoppekDruckrerunter.setActive(True)  #knopf druckrerunter aktiv
+    knoppekDruckrerunter.setVisible(True)  #knopf druckrerunter sichtbar
+    slider.setVisible(True)  #slider sichtbar
+    Kammerli.setVisible(True)  #feld kammerli sichtbar
+    Kammerre.setVisible(True)  #feld kammerre sichtbar
+def bildschenWech():  #methode: bilder ausblenden
+    bildschenDrucklihoch.setVisible(False)  #pfeil drucklihoch unsichtbar
+    bildschenDrucklirunter.setVisible(False)  #pfeil drucklirunter unsichtbar
+    bildschenDruckrehoch.setVisible(False)  #pfeil druckrehoch unsichtbar
+    bildschenDruckrerunter.setVisible(False)  #pfeil druckrerunter unsichtbar
+def bildschenHer():  #methode: bilder anzeigen
+    bildschenDrucklihoch.setVisible(True)  #pfeil drucklihoch sichtbar
+    bildschenDrucklirunter.setVisible(True)  #pfeil drucklirunter sichtbar
+    bildschenDruckrehoch.setVisible(True)  #pfeil druckrehoch sichtbar
+    bildschenDruckrerunter.setVisible(True)  #pfeil druckrerunter sichtbar
+def textWech():  #methode: text unsichtbar machen
+    schriftKammerli.setVisible(False)  #schrift kammerli unsichtbar
+    schriftKammerre.setVisible(False)  #schrift kammerre unsichtbar
+    schriftStart.setVisible(False)  #schrift start unsichtbar
+    schriftZeitprogramm.setVisible(False)  #schrift zeitprogramm unsichtbar
+    schriftPause.setVisible(False)  #schrift pause unsichtbar
+    schriftEnde.setVisible(False)  #schrift ende unsichtbar
+def textHer():  #methode: text sichtbar machen
+    schriftKammerli.setVisible(True)  #schrift kammerli sichtbar
+    schriftKammerre.setVisible(True)  #schrift kammerre sichtbar
+    schriftStart.setVisible(True)  #schrift start sichtbar
+    schriftZeitprogramm.setVisible(True)  #schrift zeitprogramm sichtbar
+    schriftPause.setVisible(True)  #schrift pause sichtbar
+    schriftEnde.setVisible(True)  #schrift ende sichtbar
+#endregion
+</file>
+Jetzt folgen einige Schleifen, die verschiedene Methoden und Variablen aufrufen. Diese steuern dann die Funktionen und Sichtbarkeiten der einzelnen Knöpfe.
+<file c Code.c>
+while 1:
+    horst.keepAlive()  #verhindert absturz des programmes und sucht nach gedrückten knöpfen
+    time.sleep(0.2)
+    if knoppekAutomatisch.isPressed():    #ZeitprogrammKnopf -> startet den Zeitprogrammmoddus
+        #print("Automode selected")       #zum debuggen, um in der Konsole zu sehen, was grade passiert
+        GroßKnoppeksWech()    #Methode wird aufgerufen
+        KleineKnoppeksHer()   #Methode wird aufgerufen
+        bildschenHer()        #Methode wird aufgerufen
+        textHer()             #Methode wird aufgerufen
+        while 1:    #endlosschleife, die auf eine knoppek wartet
+            horst.keepAlive()  #verhindert absturz des programmes und sucht nach gedrückten knöpfen
+            if knoppekStart.isPressed():    #knoppek start wird gedrückt
+                timenow = time.time()   #neue variable [timenow] wird mit der aktuellen zeit in sekunden seit 1970 belegt
+                ElBlaso(1)       #luft in kammer links rein
+                ElBlaso(2)     #luft in kammer rechts rein
+                Motörchen(1)   #motoren an
+                while time.time()-timenow < 150:  #zeit - jetzigem zeitpunkt kleiner 150 --> while schleife läuft 150sek
+                    horst.keepAlive()  #verhindert absturz des programmes und sucht nach gedrückten knöpfen
+                    time.sleep(0.2)
+                    KritischeAbbruchfrage() #wenn ende knopf gedrückt wird, wird alles beendet --> Methode wird aufgerufen
+                ElHalto(1)    #luft bleibt in kammer links
+                ElHalto(2)   #luft bleibt in kammer rechts
+                Motörchen(0) #motoren aus
+                knoppekStart.setActive(False)   #deaktiviert StartKnoppek
+                knoppekZeitprogramm.setActive(True) #aktiviert Zeitprgrammknoppek
+            KritischeAbbruchfrage() #wenn ende knopf gedrückt wird, wird alles beendet --> Methode wird aufgerufen
+            if knoppekZeitprogramm.isPressed(): #Zeitprogrammknopf gedrückt -> startet Zeitprogramm
+                timenow = time.time() #legt aktuelle Zeit auf timenow
+                while time.time()-timenow < 20:  #zeit - jetzigem zeitpunkt kleiner 20 --> while schleife läuft 20sek
+                    zeitjeloofen = 0  #variable zeitjeloofen am anfang auf 0 gesetzt
+                    horst.keepAlive()  #verhindert absturz des programmes und sucht nach gedrückten knöpfen
+                    slider.newValue((time.time()-timenow)/20)  #berechnet balkenlänge, indem es den slider-wert auf (abgelaufenezeit:20) setzt
+                    horst.refresh()  #aktualisiert die bildinhalte
+                    if time.time()-timenow < 15: #zeit - jetzigem zeitpunkt kleiner 15 --> wenn wir innerhlab der 15sek sind, dann...
+                        ElSaugo(2) #... luft aus kammer rechts raus
+                        Motörchen(1) #motoren an
+                    else:
+                        ElHalto(2)  #Methode elhalto für kammerre
+                        Motörchen(0) #motoren aus
+                    KritischeAbbruchfrage()  #wenn ende knopf gedrückt wird, wird alles beendet --> Methode wird aufgerufen
+                    if knoppekPause.isPressed(): #wenn knopf pause gedrückt wird,...
+                        zeitjeloofen = time.time()-timenow  #anzahl der sekunden, die bis jetzt in der schleife gelaufen sind
+                        Motörchen(0) #motoren aus
+                        ElHalto(1) #elhalto kammerli
+                        ElHalto(2)  #elhalto kammerre
+                        while 1: #endlosschleife
+                            horst.keepAlive()  #verhindert absturz des programmes und sucht nach gedrückten knöpfen
+                            time.sleep(0.2)
+                            MannoProgram()  #manuelles Programm wird gestartet (Methode wird aufgerufen)
+                            KritischeAbbruchfrage()  #wenn ende knopf gedrückt wird, wird alles beendet --> Methode wird aufgerufen
+                            if knoppekPause.isPressed():  #wenn pause knopf gedrückt wird,...
+                                timenow = time.time()-zeitjeloofen  #slider und zeitprogramm machen da weiter, wo sie aufgehört haben
+                                break  #pause-schleife wird beendet
+                    ElHalto(1)  #in den ersten 20sek nach dem start, muss die luft in der linken kammer gehalten werden
+                ElHalto(1) #nach den 20sek, luft halten in beiden kammern
+                ElHalto(2)
+                KammerMehr = 2   #kammer links, die luft kriegt, wird auf kammermehr gesetzt
+                KammerWenig= 1   #kammer rechts, die luft verliert, wird auf kammerwenig gesetzt
+                while 1:  #endlosschleife
+                    zeitjeloofen = 0  #zeit, die gelaufen ist, liegt bei 0sek
+                    timenow = time.time() #legt aktuelle Zeit auf timenow
+                    while time.time()-timenow < 20:  #schleife, wechselspiel der kammern beginnt und slider läuft insgesamt 20sek
+                        horst.keepAlive()  #verhindert absturz des programmes und sucht nach gedrückten knöpfen
+                        slider.newValue((time.time()-timenow)/20)  #berechnet balkenlänge, indem es den slider-wert auf (abgelaufenezeit:20) setzt
+                        horst.refresh()  #aktualisiert die bildinhalte
+                        if time.time()-timenow < 15:  #wechselspiel der kammern läuft 15sek lang
+                            ElSaugo(KammerWenig)  #kammer wird luft entzogen
+                            ElBlaso(KammerMehr)  #kammer wird luft zugeführt
+                            Motörchen(1)  #motoren sind an
+                        else: #nach den 15sek, wird luft in beiden kammern für 5sek gehalten
+                            ElHalto(KammerMehr) #luft wird gehalten
+                            ElHalto(KammerWenig)  #luft wird gehalten
+                            Motörchen(0)  #motoren sind aus
+                        KritischeAbbruchfrage()  #wenn ende knopf gedrückt wird, wird alles beendet --> Methode wird aufgerufen
+                        if knoppekPause.isPressed():  #wenn knopf pause gedrückt wird
+                            zeitjeloofen = time.time()-timenow  #anzahl der sekunden, die bis jetzt in der schleife gelaufen sind
+                            Motörchen(0) #motoren aus
+                            ElHalto(1) #luft wird in kammer gehalten
+                            ElHalto(2)  #luft wird in kammer gehalten
+                            while 1:  #endlosschleife
+                                horst.keepAlive()  #verhindert absturz des programmes und sucht nach gedrückten knöpfen
+                                time.sleep(0.2)
+                                MannoProgram() #manuelles Programm wird gestartet (Methode wird aufgerufen)
+                                KritischeAbbruchfrage()  #wenn ende knopf gedrückt wird, wird alles beendet --> Methode wird aufgerufen
+                                if knoppekPause.isPressed():  #wenn knopf pause gedrückt wird,...
+                                    timenow = time.time()-zeitjeloofen  #slider und zeitprogramm machen da weiter, wo sie aufgehört haben
+                                    break
+                    if(KammerMehr==1):  #wenn kammer links luft kriegt,..
+                        KammerMehr=2 #.. kriegt kammer rechts in der nächsten runde luft
+                        KammerWenig=1 #.. und die linke kriegt luft abgezogen
+                    else:  #andererseits...
+                        KammerMehr=1  #..kriegt kammer rechts luft abgezogen
+                        KammerWenig=2  #..und kammer links kriegt luft
+            time.sleep(0.2)
+    if knoppekManuell.isPressed(): #falls man ganz zu beginn den manuell knopf drückt,...
+        GroßKnoppeksWech() #methodenaufruf: grüne knöpfe+icons verschwinden
+        KleineKnoppeksHer()  #methodenaufruf: blaue knöpfe werden angezeigt
+        bildschenHer() #methodenaufruf: icons erscheinen und sind aktiv
+        textHer()  #methodenaufruf: text (blau) wird sichtbar gemacht
+        MannoProgram()  #methodenaufruf: manuelles programm bedienbar
+</file>
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+====== Probleme ======
+Zu Beginn unseres Projekts hatten wir die Idee, die Motoren mit dem Luftdruck in den Kammern zu steuern und diesen auch ausgeben zu lassen. Das heißt, dass die Kammern einen gewissen Druck erreicht hätten und sich der Kammerdruck anhand dessen reguliert hätte. Allerdings hat dies nicht funktioniert.
+Zuerst hatten wir die MPX5500DP Drucksensoren erhalten, die den Druck analog ausgeben, weshalb wir hier mit dem AD-Wandler arbeiten mussten. Da der Druck in den Kammern zu gering war und die Drucksensoren ihn nicht registrieren konnten, hat es nicht funktioniert. Danach bekamen wir die Drucksensoren BME280, die bereits digital waren, wodurch der AD-Wandler wegfiel. Leider bekamen wir immer wieder die Fehlermeldung „Connection timed out“. Warum es letztendlich nicht funktionierte, ist unklar. Wahrscheinlich lag es an einem Teil der Programmierung für das Touch-Display, womit die Sensoren dann Probleme hatten. Dadurch kamen wir zu dem Entschluss, ohne die Drucksensoren weiterzumachen.
+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+====== Quellen ======
+Extern bezogene Bibliothek (pygame_horstEdition as horst)
+Skripte aus der Vorlesung
+Anleitung zur Erstellung vom Desktop-Icon: https://www.hackster.io/kamal-khan/desktop-shortcut-for-python-script-on-raspberry-pi-fd1c63