====== 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. 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 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. 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 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. #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 Jetzt folgen einige Schleifen, die verschiedene Methoden und Variablen aufrufen. Diese steuern dann die Funktionen und Sichtbarkeiten der einzelnen Knöpfe. 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 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ====== 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