Eigene Cocktailmaschine

[Kallinero]

Sehr geehrte Python-Gemeinde,
ich habe ein Problem, abgesehen davon, dass ich mir gerade versuche Python im Alleingang in einer Woche beizubringen, bin ich dabei eine Cocktailmaschine zu bauen. Ich habe schon alle Teile beisammen und es funktioniert alles mehr oder minder auch im Einklang, nur bei dem Programmierteil habe ich meine Schwierigkeiten. Ich habe leichtes Verständnis in C++ also ist Python mehr oder minder Neuland, also bitte versteht das wenn ihr meinen sehr sehr aufwendigen Quellcode seht.
Meine Probleme sind die folgenden, ich möchte eine Oberfläche haben, in der man durch die verschiedenen Cocktails scrollen kann und des Weiteren das ein Ladebalken oder sowas in der Art erscheint, damit man nicht einfach alle Cocktails gleichzeitig drücken kann. Außerdem bekomm ich es einfach nicht hin alles smart in einem Algorithmus zu schreiben(aber das ist mir im Endeffekt egal).
Ich hoffe ihr könnt mir weiterhelfen.

Code: Alles auswählen

import sys
import Tkinter
import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)      #gleiche Bezeichnung wie rasp
GPIO.setwarnings(False)     #keine Fehlermeldung
GPIO.setup(2,GPIO.OUT)      #Initiualisierung der GPIOs
GPIO.setup(3,GPIO.OUT)
GPIO.setup(4,GPIO.OUT)
GPIO.setup(5,GPIO.OUT)
GPIO.setup(6,GPIO.OUT)
GPIO.setup(17,GPIO.OUT)
GPIO.setup(18,GPIO.OUT)
GPIO.setup(19,GPIO.OUT)

GPIO.output(2,True)     #Zum Start alle GPIOs aus
GPIO.output(3,True)
GPIO.output(4,True)
GPIO.output(5,True)
GPIO.output(6,True)
GPIO.output(17,True)
GPIO.output(18,True)
GPIO.output(19,True)

n = .1       #Sekunden-Masseinheit

i = 0
kanister = {}
for i in range(8):          #Kanisterfuellmenge
    kanister[i+1] = int(input("Geben sie die Menge des Kanisters an:"))
    kanister[i+1] = kanister[i+1]*1000
"""
for i in range(8):          #Fehlermeldung
    if kanister[i+1]<0:
        print"Der Kanister ist leer, bitte auffuellen"
"""
def ausgabe():              #aktuelle Kanisterfuellmenge
    for i in range(8):
        print(i+1 ,kanister[i+1])
    print("")

def allinone(event):
        GPIO.output(2,False)
        GPIO.output(3,False)
        GPIO.output(4,False)
        GPIO.output(5,False)
        GPIO.output(6,False)
        GPIO.output(17,False)
        GPIO.output(18,False)
        GPIO.output(19,False)
        time.sleep(3.75*n)
        GPIO.output(2,True)
        GPIO.output(3,True)
        GPIO.output(4,True)
        GPIO.output(5,True)
        GPIO.output(6,True)
        GPIO.output(17,True)
        GPIO.output(18,True)
        GPIO.output(19,True)
        kanister[1] = kanister[1]-3.75
        kanister[2] = kanister[2]-3.75
        kanister[3] = kanister[3]-3.75
        kanister[4] = kanister[4]-3.75
        kanister[5] = kanister[5]-3.75
        kanister[6] = kanister[6]-3.75
        kanister[7] = kanister[7]-3.75
        kanister[8] = kanister[8]-3.75
        ausgabe()
        
def alicedeluxe(event):                     #Alice Deluxe
        GPIO.output(19,False)
        GPIO.output(2,False)
        GPIO.output(3,False)
        GPIO.output(6,False)
        time.sleep(4*n)
        GPIO.output(3,True)
        GPIO.output(6,True)
        time.sleep(6*n)
        GPIO.output(2,True)
        time.sleep(2*n)
        GPIO.output(19,True)
        kanister[8] = kanister[8]-12
        kanister[2] = kanister[2]-10
        kanister[5] = kanister[5]-4
        kanister[6] = kanister[6]-4
        ausgabe()
        
def baltic(event):                           #Baltic
        GPIO.output(2,False)
        GPIO.output(6,False)
        GPIO.output(18,False)
        GPIO.output(4,False)
        GPIO.output(17,False)
        time.sleep(2*n)
        GPIO.output(4,True)
        GPIO.output(17,True)
        time.sleep(2*n)
        GPIO.output(18,True)
        time.sleep(2*n)
        GPIO.output(6,True)
        time.sleep(9*n)
        GPIO.output(2,True)
        kanister[1] = kanister[1]-15
        kanister[5] = kanister[5]-6
        kanister[7] = kanister[7]-4
        kanister[5] = kanister[5]-2
        kanister[6] = kanister[6]-2
        ausgabe()
        
def blackdeath(event):                      #Black Death
        GPIO.output(2,False)
        GPIO.output(4,False)
        GPIO.output(5,False)
        GPIO.output(17,False)
        GPIO.output(3,False)
        time.sleep(3*n)
        GPIO.output(3,True)
        time.sleep(3*n)
        GPIO.output(4,True)
        GPIO.output(5,True)
        GPIO.output(17,True)
        time.sleep(4*n)
        GPIO.output(2,True)
        kanister[1] = kanister[1]-10
        kanister[2] = kanister[2]-3
        kanister[3] = kanister[3]-6
        kanister[4] = kanister[4]-6
        kanister[6] = kanister[6]-6
        ausgabe()

def eldorado(event):                        #El Dorado
        GPIO.output(5,False)
        GPIO.output(4,False)
        time.sleep(12*n)
        GPIO.output(4,True)
        time.sleep(6*n)
        GPIO.output(5,True)
        kanister[3] = kanister[3]-6
        kanister[4] = kanister[4]-6
        ausgabe()

def emeralddream(event):                    #Emerald Dream
        GPIO.output(17,False)
        GPIO.output(6,False)
        GPIO.output(2,False)
        time.sleep(4*n)
        GPIO.output(17,True)
        time.sleep(4*n)
        GPIO.output(6,True)
        time.sleep(8*n)
        GPIO.output(2,True)
        kanister[1] = kanister[1]-16
        kanister[5] = kanister[5]-8
        kanister[6] = kanister[6]-4
        ausgabe()
        
def exoticblue(event):                      #Exotic Blue
        GPIO.output(17,False)
        GPIO.output(19,False)
        time.sleep(10*n)
        GPIO.output(17,True)
        time.sleep(8*n)
        GPIO.output(19,True)
        kanister[6] = kanister[6]-10
        kanister[8] = kanister[8]-18
        ausgabe()

def festini(event):                         #Festini
        GPIO.output(18,False)
        GPIO.output(6,False)
        time.sleep(8*n)
        GPIO.output(6,True)
        time.sleep(12*n)
        GPIO.output(18,True)
        kanister[5] = kanister[5]-8
        kanister[7] = kanister[7]-20
        ausgabe()

def floridasunrise(event):                         #Florida Sunrise
        GPIO.output(2,False)
        GPIO.output(5,False)
        GPIO.output(19,False)
        GPIO.output(3,False)
        time.sleep(4*n)
        GPIO.output(3,True)
        time.sleep(4*n)
        GPIO.output(2,True)
        GPIO.output(5,True)
        GPIO.output(19,True)
        kanister[1] = kanister[1]-8
        kanister[4] = kanister[4]-8
        kanister[8] = kanister[8]-8
        kanister[2] = kanister[2]-4
        ausgabe()

def greeneyes(event):                         #Green Eyes
        GPIO.output(2,False)
        GPIO.output(6,False)
        GPIO.output(17,False)
        time.sleep(5*n)
        GPIO.output(6,True)
        GPIO.output(17,True)
        time.sleep(13*n)
        GPIO.output(2,True)
        kanister[1] = kanister[1]-18
        kanister[5] = kanister[5]-5
        kanister[6] = kanister[6]-5
        ausgabe()

def greenpoisen(event):                         #Green Poisen
        GPIO.output(17,False)
        GPIO.output(4,False)
        GPIO.output(5,False)
        GPIO.output(18,False)
        time.sleep(3*n)
        GPIO.output(4,True)
        GPIO.output(17,True)
        time.sleep(3*n)
        GPIO.output(5,True)
        time.sleep(9*n)
        GPIO.output(18,True)
        kanister[6] = kanister[6]-3
        kanister[5] = kanister[5]-3
        kanister[6] = kanister[6]-6
        kanister[7] = kanister[7]-15
        ausgabe()

def gruenewiese(event):                         #Gruene Wiese
        GPIO.output(17,False)
        GPIO.output(2,False)
        time.sleep(9*n)
        GPIO.output(17,True)
        time.sleep(12*n)
        GPIO.output(2,True)
        kanister[6] = kanister[6]-9
        kanister[1] = kanister[1]-21
        ausgabe()
        
def happyhour(event):                         #Happy Hour
        GPIO.output(2,False)
        GPIO.output(5,False)
        GPIO.output(4,False)
        time.sleep(2*n)
        GPIO.output(4,True)
        time.sleep(8*n)
        GPIO.output(5,True)
        time.sleep(5*n)
        GPIO.output(2,True)
        kanister[1] = kanister[1]-15
        kanister[4] = kanister[4]-10
        kanister[3] = kanister[3]-2
        ausgabe()

def hawaiianvodka(event):                         #Hawaiian Vodka
        GPIO.output(6,False)
        GPIO.output(19,False)
        GPIO.output(2,False)
        GPIO.output(3,False)
        GPIO.output(4,False)
        time.sleep(4*n)
        GPIO.output(4,True)
        GPIO.output(3,True)
        GPIO.output(2,True)
        GPIO.output(19,True)
        time.sleep(8*n)
        GPIO.output(6,True)
        kanister[1] = kanister[1]-15
        kanister[4] = kanister[4]-10
        kanister[3] = kanister[3]-2
        kanister[3] = kanister[3]-2
        kanister[3] = kanister[3]-2
        ausgabe()

def knockout(event):                         #Knock Out
        GPIO.output(2,False)
        GPIO.output(4,False)
        GPIO.output(5,False)
        time.sleep(7*n)
        GPIO.output(2,True)
        time.sleep(1*n)
        GPIO.output(4,True)
        time.sleep(7*n)
        GPIO.output(5,True)
        kanister[1] = kanister[1]-7
        kanister[3] = kanister[3]-8
        kanister[4] = kanister[4]-15
        ausgabe()

def mexicano(event):                         #Mexicano
        GPIO.output(3,False)
        GPIO.output(4,False)
        GPIO.output(5,False)
        GPIO.output(19,False)
        time.sleep(6*n)
        GPIO.output(3,True)
        GPIO.output(4,True)
        GPIO.output(19,True)
        time.sleep(6*n)
        GPIO.output(5,True)
        kanister[2] = kanister[2]-6
        kanister[3] = kanister[3]-6
        kanister[4] = kanister[4]-12
        kanister[8] = kanister[8]-6
        ausgabe()
        
def pinkpussycat(event):                         #Pink Pussycat
        GPIO.output(3,False)
        GPIO.output(6,False)
        GPIO.output(19,False)
        time.sleep(2*n)
        GPIO.output(3,True)
        time.sleep(9*n)
        GPIO.output(6,True)
        time.sleep(5*n)
        GPIO.output(19,True)
        kanister[2] = kanister[2]-2
        kanister[5] = kanister[5]-11
        kanister[8] = kanister[8]-16
        ausgabe()

        
def screwdriver(event):                         #Screwdriver
        GPIO.output(2,False)
        GPIO.output(6,False)
        time.sleep(10*n)
        GPIO.output(6,True)
        time.sleep(20*n)
        GPIO.output(2,True)
        kanister[1] = kanister[1]-20
        kanister[5] = kanister[5]-10
        ausgabe()
        
def simplered(event):                         #Simple Red
        GPIO.output(2,False)
        GPIO.output(3,False)
        GPIO.output(6,False)
        GPIO.output(18,False)
        time.sleep(3*n)
        GPIO.output(3,True)
        time.sleep(3*n)
        GPIO.output(6,True)
        time.sleep(4*n)
        GPIO.output(2,True)
        GPIO.output(18,True)
        kanister[1] = kanister[1]-10
        kanister[2] = kanister[2]-3
        kanister[5] = kanister[5]-6
        kanister[7] = kanister[7]-10
        ausgabe()
        
def springtimecooler(event):                         #Springtime Cooler
        GPIO.output(2,False)
        GPIO.output(4,False)
        GPIO.output(6,False)
        GPIO.output(17,False)
        time.sleep(4*n)
        GPIO.output(17,True)
        time.sleep(2*n)
        GPIO.output(4,True)
        time.sleep(2*n)
        GPIO.output(6,True)
        time.sleep(4*n)
        GPIO.output(2,True)
        kanister[1] = kanister[1]-12
        kanister[3] = kanister[3]-6
        kanister[5] = kanister[5]-8
        kanister[6] = kanister[6]-4
        ausgabe()
        
def tequilasunrise(event):                         #Tequila Sunrise
        GPIO.output(2,False)
        GPIO.output(3,False)
        GPIO.output(4,False)
        GPIO.output(5,False)
        time.sleep(2*n)
        GPIO.output(4,True)
        time.sleep(1*n)
        GPIO.output(3,True)
        time.sleep(6*n)
        GPIO.output(5,True)
        time.sleep(7*n)
        GPIO.output(2,True)
        kanister[1] = kanister[1]-16
        kanister[2] = kanister[2]-3
        kanister[3] = kanister[3]-2
        kanister[4] = kanister[4]-9
        ausgabe()
    
    
top = Tkinter.Tk()      # Erzeugen eines Fensters
top.geometry("1024x900")

w = Tkinter.Label(top,text='Choose your Cocktail')    #Header
w.grid(row=0,column=3)

"""
def wechslefarbe ():
    knopf["bg"]="#FF0000"
    knopf["fg"]="#FF0000"
    knopf1["bg"]="#FF0000"
    knopf1["fg"]="#FF0000"
    knopf2["bg"]="#FF0000"
    knopf2["fg"]="#FF0000"
    knopf3["bg"]="#FF0000"
    knopf3["fg"]="#FF0000"
    knopf4["bg"]="#FF0000"
    knopf4["fg"]="#FF0000"
    knopf5["bg"]="#FF0000"
    knopf5["fg"]="#FF0000"
    knopf6["bg"]="#FF0000"
    knopf6["fg"]="#FF0000"
    knopf7["bg"]="#FF0000"
    knopf7["fg"]="#FF0000"
    knopf8["bg"]="#FF0000"
    knopf8["fg"]="#FF0000"
    knopf9["bg"]="#FF0000"
    knopf9["fg"]="#FF0000"
    knopf10["bg"]="#FF0000"
    knopf10["fg"]="#FF0000"
    knopf11["bg"]="#FF0000"
    knopf11["fg"]="#FF0000"
    knopf12["bg"]="#FF0000"
    knopf12["fg"]="#FF0000"
    knopf13["bg"]="#FF0000"
    knopf13["fg"]="#FF0000"
    knopf14["bg"]="#FF0000"
    knopf14["fg"]="#FF0000"
    time.sleep(20*n)

liste= Listbox(root,height=5)
liste.insert("end","All in One")
liste.insert("end","Alice Deluxe")
liste.insert("end","Baltic")

liste.grid(row=1,column=1)
"""

knopf = Tkinter.Button(top,text='All in One',height=12,width=22,command=wechslefarbe)
knopf.grid(row=1,column=1)
knopf.bind('<Button-1>', allinone)

knopf1 = Tkinter.Button(top,text='Alice Deluxe',height=12,width=22,command=wechslefarbe)
knopf1.grid(row=1,column=2)
knopf1.bind('<Button-1>', alicedeluxe)

knopf2 = Tkinter.Button(top,text='Baltic',height=12,width=22)
knopf2.grid(row=1,column=3)
knopf2.bind('<Button-1>', baltic)

knopf3 = Tkinter.Button(top,text='Black Death',height=12,width=22)
knopf3.grid(row=1,column=4)
knopf3.bind('<Button-1>', blackdeath)

knopf4 = Tkinter.Button(top,text='El Dorado',height=12,width=22)
knopf4.grid(row=1,column=5)
knopf4.bind('<Button-1>', eldorado)

knopf5 = Tkinter.Button(top,text='Emerald Dream',height=12,width=22)
knopf5.grid(row=2,column=1)
knopf5.bind('<Button-1>', emeralddream)

knopf6 = Tkinter.Button(top,text='Exotic Blue',height=12,width=22)
knopf6.grid(row=2,column=2)
knopf6.bind('<Button-1>', exoticblue)

knopf7 = Tkinter.Button(top,text='Festini',height=12,width=22)
knopf7.grid(row=2,column=3)
knopf7.bind('<Button-1>', festini)

knopf8 = Tkinter.Button(top,text='Florida Sunrise',height=12,width=22)
knopf8.grid(row=2,column=4)
knopf8.bind('<Button-1>', floridasunrise)

knopf9 = Tkinter.Button(top,text='Green Eyes',height=12,width=22)
knopf9.grid(row=2,column=5)
knopf9.bind('<Button-1>', greeneyes)

knopf10 = Tkinter.Button(top,text='Green Poisen',height=12,width=22)
knopf10.grid(row=3,column=1)
knopf10.bind('<Button-1>', greenpoisen)

knopf11 = Tkinter.Button(top,text='Gruene Wiese',height=12,width=22)
knopf11.grid(row=3,column=2)
knopf11.bind('<Button-1>', gruenewiese)

knopf12 = Tkinter.Button(top,text='Happy Hour',height=12,width=22)
knopf12.grid(row=3,column=3)
knopf12.bind('<Button-1>', happyhour)

knopf13 = Tkinter.Button(top,text='Hawaiian Vodka',height=12,width=22)
knopf13.grid(row=3,column=4)
knopf13.bind('<Button-1>', hawaiianvodka)

knopf14 = Tkinter.Button(top,text='Knock Out',height=12,width=22)
knopf14.grid(row=3,column=5)
knopf14.bind('<Button-1>', knockout)
"""
knopf15 = Tkinter.Button(top,text='Mexicano')
knopf15.pack()
knopf15.bind('<Button-1>', mexicano)

knopf16 = Tkinter.Button(top,text='Pink Pussycat')
knopf16.pack()
knopf16.bind('<Button-1>', pinkpussycat)

knopf17 = Tkinter.Button(top,text='Screwdriver')
knopf17.pack()
knopf17.bind('<Button-1>', screwdriver)

knopf18 = Tkinter.Button(top,text='Simple Red')
knopf18.pack()
knopf18.bind('<Button-1>', simplered)

knopf19 = Tkinter.Button(top,text='Springtime Cooler')
knopf19.pack()
knopf19.bind('<Button-1>', springtimecooler)

knopf20 = Tkinter.Button(top,text='Tequila Sunrise')
knopf20.pack()
knopf20.bind('<Button-1>', tequilasunrise)
"""
top.mainloop()

[BlackJack]

@Kallinero: Da ist viel Code der eigentlich Daten sein sollte. Man schreibt nicht pro Cocktail eine Funktion die fast immer das gleiche enthält, sondern die Unterschiede, also welche Pins und die Zeiten, als Daten und *eine* Funktion die dann so ein Rezept erhält und die Pins entsprechend schaltet. Das der Programmierer bei den Zeiten und den Mengen mitdenken und rechnen muss, ist auch keine gute Idee, weil das genau so gut, oder eben besser, der Rechner übernehmen könnte.

Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.

Bei den Pins und den Kanistern werden ausschliesslich ”magische” Zahlen verwendet, was nicht wirklich nachvollziehbar und sehr fehleranfällig ist. Bei Rechnern fängt man ausserdem üblicherweise mit 0 an bei der Zählung was das Programm vereinfacht. Und wenn man eine Abbildung von fortlaufenden Zahlen die bei 0 beginnen braucht, nimmt man eine Liste und kein Wörterbuch.

Statt die Warnungen vom GPIO-Modul auszuschalten sollte man sich die Anschauen und die Ursache(n) beseitigen statt sie zu ignorieren. Meistens ist es einfach nur ein fehlendes `GPIO.cleanup()` das beim Verlassen des Programms unbedingt ausgeführt werden sollte. Dazu am besten mal ``try``/``finally`` anschauen.

Mehrzeilige Zeichenketten sind keine Kommentare.

Wenn man anfängt Namen zu nummerieren, macht man in der Regel etwas falsch und möchte bessere Namen verwenden, oder eigentlich gar keine Einzelnamen sondern eine Datenstruktur. Oft eine Liste. Bei den ganzen Schaltflächen beispielsweise.

Die Aktion bei einer Schaltfläche legt man nicht mit `bind()` fest, sondern mit der `command`-Option der Schaltfläche. Sonst verhält sich dieses Anzeigeelement nicht so wie der Benutzer das erwartet.

Bei GUI-Programmierung kommt man nicht wirklich um objektorientierte Programmierung herum. Und auch die ”Funktionen” für dir Rezepte sollten nicht einfach so auf dem globalen Kanisterfüllständen operieren. Alle Werte die eine Funktion oder Methode verwendet (ausser Konstanten) sollten als Argumente herein kommen und nicht ”magisch” in der Umgebung existieren. Das macht Programme schwer nachvollziehbar und einzelne Funktionen/Methoden schwer bis fast gar nicht testbar.

Während ein Rezept gemixt wird müsstest Du alle Schaltflächen deaktivieren. Die haben dafür eine `state`-Option die man auf `Tkinter.DISABLED` oder `Tkinter.NORMAL` setzen kann. Letzteres müsste man dann nach dem mixen tun.

Das mit `time.sleep()` funktioniert so nicht mit der GUI zusammen. Da muss man entweder `time.sleep()` durch `Widget.after()` ersetzen und die Schritte in mehrere Methodenaufrufe unterteilen, oder mit dem `threading`-Modul arbeiten und beispielsweise `Queue.Queue`-Objekte zur Kommunikation mit dem GUI-Thread verwenden. Denn die GUI darf nur vom GUI-Thread aus verändert werden. Dort würde man dann mit der `Widget.after()`-Methode regelmässig schauen ob neue Daten in der Queue sind.

Ich würde als erstes mit der Geschäftslogik anfangen und die GUI-unabhängig programmieren und testen, und dann hinterher eine GUI dort draufsetzen. Die Geschäftslogik würde ich auch gleich objektorientiert implementieren, denn die Pinnummer und der Kanisterfüllstand lassen sich sinnvoll zusammenfassen, und statt magischer Nummern würde ich dort auch einen Namen für den Inhalt verwenden. Dann ist man auch nicht auf die Kanisterreihenfolge angewiesen und auch die Inhalte sind nicht fest. Man könnte also auch mehr als acht verschiedene Getränke haben wenn man bei Kanistern und Rezepten Namen verwendet und das Programm kann dann auch damit umgehen wenn die Kanister in einer beliebigen Reihenfolge eingesetzt werden und wenn für einen Cocktail nicht alle Zutaten vorhanden sind.

Mögliche Ausbaustufe davon wäre es auch zu erlauben das mehr als ein Kanister von einer Sorte eingesetzt wird, wenn man eine Sorte hat die besonders oft und viel verwendet wird. Das schränkt dann natürlich die Zahl der Rezepte ein.

[Kallinero]

Ich danke dir vielmals für deine sehr ausführliche Antwort.Habe nicht so schnell damit gerechnet. Ich hoffe ich schaffe es mit meinen kleinen Kenntnissen, mein Programm zu optimieren. Denn wenn ich es wirklich schaffe, das durchzusetzen, was du da vorschlägst, dann wäre das nach lagem endlich mal ein schönes vorzeigbares Projekt, das man sogar erweitern könnte. Besten Dank.
Ich programmier mal noch ein bisschen und halt alle auf dem Laufendem.

[Kallinero]

So,
ich habe mich nun den ganzen Tag versucht, aber mich erschließt sich der Algorithmus nicht. Ich weiss nicht wie ich durch sortieren der Wartezeiten immer noch die Zuordnung zu den Ventilen hinbekomme, damit sich die falschen Ventile nicht einfach schließen.

Code: Alles auswählen

import sys
import Tkinter
import RPi.GPIO as GPIO
import time

main()

oSaft = 2				#Ventile zugeordnet
grenadine = 3
zitronensaft = 4
tequila = 5
wodka = 6
blueCoracao = 17
maracujasaft =18
ananassaft = 19

GPIO.setmode(GPIO.BCM)      		#gleiche Bezeichnung wie rasp

GPIO.setup(oSaft,GPIO.OUT)      	#Initiualisierung der GPIOs
GPIO.setup(geradine,GPIO.OUT)
GPIO.setup(zitronensaft,GPIO.OUT)
GPIO.setup(tequila,GPIO.OUT)
GPIO.setup(wodka,GPIO.OUT)
GPIO.setup(blueCoracao,GPIO.OUT)
GPIO.setup(maracujasaft,GPIO.OUT)
GPIO.setup(ananassaft,GPIO.OUT)

GPIO.setup(oSaft,True)      		#Alle Ventile schließen
GPIO.setup(geradine,True)
GPIO.setup(zitronensaft,True)
GPIO.setup(tequila,True)
GPIO.setup(wodka,True)
GPIO.setup(blueCoracao,True)
GPIO.setup(maracujasaft,True)
GPIO.setup(ananassaft,True)

for i in range(5)			#generieren der Wartezeit-Variablen
	wartezeit{i} = 0

#Datenbank...

def sortieren() 
	

def mixen()
	#1. Wartezeit muss nach groeße sortiert werden
	#2. alle Ventile müssen geoeffnet werden
	#3. kürzeste Wartezeit ... das zugeordnete Ventil muss schliessen
	#4. nach und nach die anderen

	GPIO.output(a1,False)
	GPIO.output(a2,False)
	GPIO.output(a3,False)
	GPIO.output(a4,False)
	GPIO.output(a5,False)
	sortieren()
	time.sleep(b1)
	GPIO.output(a1,False)
	GPIO.output(a2,False)
	GPIO.output(a3,False)
	GPIO.output(a4,False)
	GPIO.output(a5,False)
	sortieren()
	time.sleep(b2-b1)
	GPIO.output(a4,False)
	GPIO.output(a1,False)
	GPIO.output(a2,False)
	GPIO.output(a3,False)
	GPIO.output(a4,False)
	sortieren()
	time.sleep(b3-b2)
	GPIO.output(a1,False)
	GPIO.output(a2,False)
	GPIO.output(a3,False)
	sortieren()
	time.sleep(b4-b3)
	GPIO.output(a1,False)
	GPIO.output(a2,False)
	sortieren()
	time.sleep(b5-b4)
	GPIO.output(a1,False)

[Sirius3]

@Kallinero: versuch erst einmal, ganz allgemein zu beschreiben, wie ein Cocktail gemixt wird. Dann überleg Dir, welche Datenstruktur zur Beschreibung geeignet ist. Dann erst, wie Du diese Beschreibung in eine Auf/Zu-Sequenz übersetzen kannst. Hast Du das in natürlicher Sprache aufgeschrieben, kannst Du Dir Gedanken machen, wie man das in Python ausdrücken könnte und was Dir da noch an Kenntnissen fehlt.

[Kallinero]

Also ich habe mir ein paar mehr Gedanken gemacht. Ich hab versucht herauszufinden wie das ganze System mit Datenbanken funktioniert(bin da aber auch nicht viel weitergekommen) und nochmal über meinen Code nachgedacht und die einzige Möglichkeit die mir einfällt ist diese. Ich habe mir viel dabei gedacht, aber weiss nicht ganz ob das ganze so funktioniert (Also nein sind wir ehrlich, ich habe es versucht und es funktioniert natürlich nicht). Vll könnt ihr mir nen Gedankenanstoß geben, warum das nicht geht.

Code: Alles auswählen

import sys
import RPi.GPIO as GPIO
import time

main():

	oSaft_ventil = 2				#Ventile zugeordnet
	grenadine_ventil = 3
	zitronensaft_ventil = 4
	tequila_ventil = 5
	wodka_ventil = 6
	blueCoracao_ventil = 17
	maracujasaft_ventil =18
	ananassaft_ventil = 19

	GPIO.setmode(GPIO.BCM)      		#gleiche Bezeichnung wie rasp

	GPIO.setup(oSaft_ventil,GPIO.OUT)      	#Initiualisierung der GPIOs
	GPIO.setup(grenadine_ventil,GPIO.OUT)
	GPIO.setup(zitronensaft_ventil,GPIO.OUT)
	GPIO.setup(tequila_ventil,GPIO.OUT)
	GPIO.setup(wodka_ventil,GPIO.OUT)
	GPIO.setup(blueCoracao_ventil,GPIO.OUT)
	GPIO.setup(maracujasaft_ventil,GPIO.OUT)
	GPIO.setup(ananassaft_ventil,GPIO.OUT)

	GPIO.setup(oSaft_ventil,True)      		#Alle Ventile schließen
	GPIO.setup(grenadine_ventil,True)
	GPIO.setup(zitronensaft_ventil,True)
	GPIO.setup(tequila_ventil,True)
	GPIO.setup(wodka_ventil,True)
	GPIO.setup(blueCoracao_ventil,True)
	GPIO.setup(maracujasaft_ventil,True)
	GPIO.setup(ananassaft_ventil,True)

#allgemeine Bedingung

oSaft = 0
geradine = 0
zitronensaft = 0
tequila = 0
wodka = 0
blueCoracao = 0
maracujasaft = 0
ananassaft = 0

#Beispiel-Rezept

oSaft = 10
geradine = 4
wodka = 4
ananassaft = 12

def mixen():
	if oSaft != 0:
		GPIO.output(oSaft_ventil,False)
	elif geradine != 0:
		GPIO.output(geradine_ventil,False)
	elif zitronensaft != 0:
		GPIO.output(zitronensaft_ventil,False)
	elif tequila != 0:
		GPIO.output(tequila_ventil,False)
	elif wodka != 0:
		GPIO.output(wodka_ventil,False)
	elif blueCoracao != 0:
		GPIO.output(blueCoracao_ventil,False)
	elif maracujasaft != 0:
		GPIO.output(maracujasaft_ventil,False)
	else:
		GPIO.output(ananassaft_ventil,False)
	#2.
	for i in range(25):
		if oSaft == i:
			GPIO.output(oSaft_ventil,True)
		elif geradine == i:
			GPIO.output(geradine_ventil,True)
		elif zitronensaft == i:
			GPIO.output(zitronensaft_ventil,True)
		elif tequila == i:
			GPIO.output(tequila_ventil,True)
		elif wodka == i:
			GPIO.output(wodka_ventil,True)
		elif blueCoracao == i:
			GPIO.output(blueCoracao_ventil,True)
		elif maracujasaft == i:
			GPIO.output(maracujasaft_ventil,True)
		else:
			GPIO.output(ananassaft_ventil,True)
		time.sleep(1)
  
GPIO.cleanup()

[BlackJack]

@Kallinero: Was heisst denn „funktioniert nicht“? Gibt es Fehlermeldungen? Verhält es sich nicht so wie es sollte? Wie weicht das Verhalten von dem ab was Du erwartest? An welcher Stelle im Code passiert das?

Das ist immer noch alles Code und keine Datenstrukturen.

[Kallinero]

Es gibt eine Fehlermeldung. Die kann ich morgen auch einmal posten. Handelt sich irgendwie um die GPIO die nicht als outputs definiert sind, obwohl ich das oben getan habe.

Zu den Datenstrukturen hab ich dann ne Frage. So wie ich das jetzt durch anlesen herausgefunden habe. Sind Datenstrukturen doch nur die Möglichkeit wie ich meine Informationen abrufe bzw. abspeichere (also gehts doch um Code) oder habe ich das falsch verstanden. Dadurch ist es doch nur eine Frage der Effektivität welche ich jetzt wähle.

[BlackJack]

@Kallinero: Der gezeigte Code definiert keine GPIOs als output. Das ist Code der das tun *würde*, wenn er denn ausgeführt *würde*.

Wobei mir gerade auffällt das selbst das nicht so ganz stimmt denn der gezeigte Code läuft gar nicht, weil er syntaktisch nicht korrekt ist. In Zeile 5 müsste gibt es einen Syntaxfehler geben, weil der Compiler mit dem Doppelpunkt hinter dem Aufruf von `main` nichts anfangen kann. Da fehlt ein ``def`` damit das eine Funktionsdefinition ist.

Eine Funktionsdefinition definiert beim ausführen aber erst einmal nur eine Funktion. Um den Code in einer Funktion auszuführen muss man die Funktion auch *aufrufen*.

`mixen()` wird zwar korrekt definiert, aber ebenfalls nirgends aufgerufen.

Die „allgemeine(n) Bedingungen”, das „Beispiel-Rezept“, und der `GPIO.cleanup()`-Aufruf stehen auf Modulebene, wo sie nichts zu suchen haben.

Datenstrukturen werden durch Code während der Laufzeit verarbeitet, sind also flexibel. Code ist dagegen etwas statisches was nicht von Code verändert wird. Zumindest solange man nicht in Sprachen programmiert die den Code auch als Datenstrukturen repräsentieren und ein Makrokonzept bieten wie Lisp oder Scheme und daran angelehnte Programmiersprachen.

Den letzten Satz habe ich nicht verstanden. Beziehungsweise ja, es ist auf Deine Art nicht wirklich möglich effektiv zu programmieren. Daten nicht als Daten zu handhaben und für jeden Datensatz wieder den grundsätzlich gleichen Code zu schreiben ist Wahnsinn. Fürchterlich redundant und fehleranfällig, insbesondere wenn es um die Fehlersuche und Änderungen geht, weil man dann nicht *einmal* den *einen* Code ändern muss, sondern immer alle ähnlichen Kopien, was wesentlich mehr Arbeit und wesentlich mehr Angriffsfläche für Fehler bietet. Man muss ja immer alle Kopien gleich bzw. äquivalent ändern, darf nichts vergessen, sich bei jeder gleichen Änderung muss man immer das gleiche Tippen, also kann man sich x-mal *ver*tippen, statt nur einmal, und das dann auch an der einen Stelle fixen, und so weiter.

Wie willst Du denn das was Du jetzt hast um ein zweites Rezept erweitern? Um ein Drittes? Das skaliert doch überhaupt nicht.

Man will hier normalerweise eine `mixen()`-Funktion die ein Rezept als Daten beim Aufruf übergeben bekommt. Dann hat man *eine* Funktion mit der man alle Rezepte mixen kann die mit den gegebenen Zutaten möglich sind.

[Zizibee]

@Kallinero : Lass mich mal versuchen dir die Notwendigkeit zum Trennen von Code und Daten zu erklären.

Angenommen du programmierst so weiter und dein Mixer funktioniert so gut, dass ein Freund von dir auch einen will. Allerdings findet er das Mischungsverhältnis von einem Cocktail nicht gut und würde gerne seinen Lieblingscocktail hinzu fügen. Da er selber keine Ahnung vom Programmieren hat, müsste er dir jede Änderung durchgeben, du müsstest den Quellcode anpassen und ihm schicken, worauf er ihn dann wieder aufspielt und merkt, dass die Mischung immer noch nicht ideal ist...

Befinden sich die Rezepte aber nicht im Quellcode sondern in einer separaten Datei (z.B. .CSV, .JSON, .TXT oder was auch immer), kann er diese in jedem Editor öffnen und seine Änderungen selbst vornehmen. Auch der Austausch von Rezepten zwischen mehreren Nutzern ist dann möglich.

[Kallinero]

Ok ok ich seh es ein,
es ist viel sinnvoller das ganze in Dateien zu verpacken. Ich habe auch schon herausgefunden das das ganze nicht so schwierig ist. Nur stellt sich mir jetzt die Fragen. Soll ich jetzt eine Funktion schreiben, die in einer Datei nach dem Cocktail sucht oder lege ich für jeden Cocktail eine Datei an die gesucht wird.

Ich dank euch übrigens sehr, ihr helft mir sehr weiter!

[BlackJack]

@Kallinero: *Dateien* sind ein weiterer, davon erst einmal unabhängiger Schritt. Die Funktion/Methode die ein Getränk mixt sollte davon nichts wissen müssen ob die Daten für das Rezept aus einer Datei mit allen Rezepten, aus einer Datei mit einzelnen Rezepten, aus einer Datenbank, oder sonst wo her kommt.

[Kallinero]

So, nach langem hin und her des programmierens, fange ich langsam an keine Fehler mehr zu finden. Also ignoriert zunächst den Cocktailfinder, das ist mein kläglicher Versuch ein Document zu durchsuchen. Ich schaffe es einfach nicht, dass meine if-elif-else-Schleife in mixen() das tut was sie tun soll. Es werden mir auch keine Fehler mehr rausgegeben. Ich hoffe ihr findet was, denn langsam werd ich irre.

Code: Alles auswählen

import sys
import RPi.GPIO as GPIO
import time

oSaft_ventil = 2				#Ventile zugeordnet
grenadine_ventil = 3
zitronensaft_ventil = 4
tequila_ventil = 5
wodka_ventil = 6
blueCoracao_ventil = 17
maracujasaft_ventil =18
ananassaft_ventil = 19

def main():

    GPIO.setmode(GPIO.BCM)   		#gleiche Bezeichnung wie rasp

    GPIO.setup(oSaft_ventil,GPIO.OUT)      	#Initiualisierung der GPIOs
    GPIO.setup(grenadine_ventil,GPIO.OUT)
    GPIO.setup(zitronensaft_ventil,GPIO.OUT)
    GPIO.setup(tequila_ventil,GPIO.OUT)
    GPIO.setup(wodka_ventil,GPIO.OUT)
    GPIO.setup(blueCoracao_ventil,GPIO.OUT)
    GPIO.setup(maracujasaft_ventil,GPIO.OUT)
    GPIO.setup(ananassaft_ventil,GPIO.OUT)

    GPIO.output(oSaft_ventil,True)      		#Alle Ventile schließen
    GPIO.output(grenadine_ventil,True)
    GPIO.output(zitronensaft_ventil,True)
    GPIO.output(tequila_ventil,True)
    GPIO.output(wodka_ventil,True)
    GPIO.output(blueCoracao_ventil,True)
    GPIO.output(maracujasaft_ventil,True)
    GPIO.output(ananassaft_ventil,True)



#Datein-Lesemethode:

def cocktailfinder():
    cocktailliste = open("cocktailliste.txt")
    gewaehlterCocktail = "ALice"
	
    for line in cocktailliste:
        gefundenerCocktail = line.rstrip()
			
        if gefundenerCocktail == gewaehlterCocktail:
            for line in range(16):
                zutat = line.rstrip() 
                if zutat == "oSaft":
                    oSaft = int(cocktailliste.read()[line+1])
                elif zutat == "geradine":
                    geradine = int(cocktailliste.read()[line+1])
                elif zutat == "zitronensaft":
                    zitronensaft = int(cocktailliste.read()[line+1])
                elif zutat == "tequila":
                    tequila = int(cocktailliste.read()[line+1])
                elif zutat == "wodka":
                    wodka = int(cocktailliste.read()[line+1])
                elif zutat == "blueCoracao":
                    blueCoracao = int(cocktailliste.read()[line+1])
                elif zutat == "maracujasaft":
                    maracujasaft =	int(cocktailliste.read()[line+1])
                else:
                    ananassaft = int(cocktailliste.read()[line+1])

    print("O-Saft = %d",oSaft)
    print("Geradine = %d",geradine)
    print("Zitronensaft = %d",zitronensaft)
    print("tequila = %d",tequila)
    print("wodka= %d",wodka)
    print("blueCoracao = %d",blueCoracao)
    print("maracujasaft = d%",maracujasaft)
    print("ananassaft = &d",ananassaft)

	
    cocktailliste.close()

cocktailfinder

#Methode zum mixen der Cocktails	
	
def mixen():
    
    oSaft = 5                #Beispiel
    grenadine = 0
    zitronensaft = 25
    tequila = 6
    wodka = 0
    blueCoracao = 0
    maracujasaft = 0
    ananassaft = 0

    #cocktailfinder(oSaft,geradine,zitronensaft,tquila,wodka,blueCaracao,maracujasaft,ananassaft)	 #Übergabe des Rezepts

    if oSaft != 0:					#Ventile öffenen
        GPIO.output(oSaft_ventil,False)
    elif geranadine != 0:
        GPIO.output(geradine_ventil,False)
    elif zitronensaft != 0:
        GPIO.output(zitronensaft_ventil,False)
    elif tequila != 0:
        GPIO.output(tequila_ventil,False)
    elif wodka != 0:
        GPIO.output(wodka_ventil,False)
    elif blueCoracao != 0:
        GPIO.output(blueCoracao_ventil,False)
    elif maracujasaft != 0:
        GPIO.output(maracujasaft_ventil,False)
    else:
        GPIO.output(ananassaft_ventil,False)

    for i in range(25):				#Ventile schließen
        if i == oSaft:
            GPIO.output(oSaft_ventil,True)
        elif i == grenadine:
            GPIO.output(geradine_ventil,True)
        elif i == zitronensaft:
            GPIO.output(zitronensaft_ventil,True)
        elif i == tequila:
            GPIO.output(tequila_ventil,True)
        elif i == wodka:
            GPIO.output(wodka_ventil,True)
        elif i == blueCoracao:
            GPIO.output(blueCoracao_ventil,True)
        elif i == maracujasaft:
            GPIO.output(maracujasaft_ventil,True)
        else:
            GPIO.output(ananassaft_ventil,True)
        time.sleep(1)


mixen

[BlackJack]

@Kallinero: http://if-schleife.de/

Du rufst keine der Funktionen auf die Du da definierst.

[Zizibee]

Ich schaffe es einfach nicht, dass meine if-elif-else-Schleife in mixen() das tut was sie tun soll. Es werden mir auch keine Fehler mehr rausgegeben. Ich hoffe ihr findet was, denn langsam werd ich irre.

Was macht denn die if-elif-else Bedingung in deinem Beispiel?
Sie prüft ob oSaft != 0 ist, das stimmt. Daher wird oSaft_ventil auf False gesetzt. Da die if-Bedingung erfüllt wurde werden alle elif und das else übersprungen. Direkt danach werden alle Ventile in der for-Schleife auf True gesetzt. Ich glaube nicht, dass du das wirklich so haben wolltest...

[BlackJack]

@Kallinero: Das Vorgehen ist so vielleicht auch nicht wirklich zielführend. Du schreibst 130-Zeilenprogramme die ein komplettes Rezept mit externer Hardware mixen sollen, die aber ziemlich offensichtlich werden lassen, dass Du mit den Sprachmitteln zur Steuerung des Programmflusses noch deutliche Probleme hast. Vielleicht solltest Du das etwas kleinschrittiger angehen. Programme entwickelt man. Also man schreibt nicht ein komplettes Programm runter und testet *dann* erst ob es läuft und ob es das tut was man möchte, sondern man schreibt eine Funktion nach der anderen, und *testet* jede Funktion ob sie auch das tut was man möchte, *bevor* man mit der nächsten weiter macht.

Und gerade am Anfang, mit für Anfänger noch kompliziert aussehenden Schleifen und Bedingungen, macht es Sinn auch die eine oder andere Funktion nicht erst zu testen wenn sie komplett fertig geschrieben ist, sondern ebenfalls einen Teil schreiben und dann prüfen ob der bis dahin auch das tut was man möchte.

Ich bin ja immer noch der Meinung Du solltest Dich mal losgelöst von diesem Programm mit den Python-Grundlagen beschäftigen. Also zum Beispiel das Tutorial in der Python-Dokumentation durcharbeiten. Danach hast Du dann eine solidere Grundlage und kennst die Dir zur Verfügung stehenden Werkzeuge wie Sprachmittel und Datenstrukturen besser.

[Kallinero]

So, ja nach lagem suchen hab ich auch den elif-Fehler entdeckt. Nach ein bisschen modifizieren hat alles funktioniert ... tadaa. Ich bin auch schon sehr weit gekommen mit dem Cocktailfinder, meiner Suchfunktion. Sie arbeitet eig auch schon so wie ich will. Ich kann mir ganze Rezepte suchen und ausgeben lassen, nur das einzige Problem ist, ich bekomme die beiden Funktionen Cocktailfinder() und mixen() nicht im Einklang. Selbst wenn ich aus ihnen eine Funktion mache und die Variablen nicht übergebe funktioniert das ganze nicht. Jetzt ist die Frage, ich fänd es natürlich sinnvoller wenn alles in zwei Funktionen funktioniert. Wie übergebe ich die Werte der einen Funktion der anderen ? Ich habe jetzt schon ein paar Sachen ausprobiert und gegooglt, erreiche aber nie das gewünschte Ziel.

Code: Alles auswählen

import sys
import RPi.GPIO as GPIO
import time


oSaft = 0				#Bedingung
grenadine = 0
zitronensaft = 0
tequila = 0
wodka = 0
blueCoracao = 0
maracujasaft = 0
ananassaft = 0

oSaft_ventil = 2				#Ventile zugeordnet
grenadine_ventil = 3
zitronensaft_ventil = 4
tequila_ventil = 5
wodka_ventil = 6
blueCoracao_ventil = 17
maracujasaft_ventil =18
ananassaft_ventil = 19

GPIO.setmode(GPIO.BCM)   		#gleiche Bezeichnung wie rasp

GPIO.setwarnings(False)

GPIO.setup(oSaft_ventil,GPIO.OUT)      	#Initiualisierung der GPIOs
GPIO.setup(grenadine_ventil,GPIO.OUT)
GPIO.setup(zitronensaft_ventil,GPIO.OUT)
GPIO.setup(tequila_ventil,GPIO.OUT)
GPIO.setup(wodka_ventil,GPIO.OUT)
GPIO.setup(blueCoracao_ventil,GPIO.OUT)
GPIO.setup(maracujasaft_ventil,GPIO.OUT)
GPIO.setup(ananassaft_ventil,GPIO.OUT)

GPIO.output(oSaft_ventil,True)      		#Alle Ventile schließen
GPIO.output(grenadine_ventil,True)
GPIO.output(zitronensaft_ventil,True)
GPIO.output(tequila_ventil,True)
GPIO.output(wodka_ventil,True)
GPIO.output(blueCoracao_ventil,True)
GPIO.output(maracujasaft_ventil,True)
GPIO.output(ananassaft_ventil,True)


#Datein-Lesemethode:

def cocktailfinder():

    oSaft = 0				#Bedingung
    grenadine = 0
    zitronensaft = 0
    tequila = 0
    wodka = 0
    blueCoracao = 0
    maracujasaft = 0
    ananassaft = 0

    zeile = 0

    gewaehlterCocktail = "Tequila Sunrise"
    
    cocktailliste = open("cocktailliste.txt","r")

    for line in cocktailliste:
        zeile = zeile + 1
        gefundenerCocktail = line.rstrip()
	
        if gefundenerCocktail == gewaehlterCocktail:
            print(gewaehlterCocktail)
            for line in cocktailliste:
                zeile = zeile + 1
                zutat = line.rstrip()
                         
                if zutat == "O-Saft":
                    for line in cocktailliste:
                        zeile = zeile + 1
                        oSaft = int(line.rstrip())
                        break
                if zutat == "Grenadine":
                    for line in cocktailliste:
                        zeile = zeile + 1
                        grenadine = int(line.rstrip())
                        break
                if zutat == "Zitronensaft":
                    for line in cocktailliste:
                        zeile = zeile + 1
                        zitronensaft = int(line.rstrip())
                        break
                if zutat == "Tequila":
                    for line in cocktailliste:
                        zeile = zeile + 1
                        tequila = int(line.rstrip())
                        break
                if zutat == "Wodka":
                    for line in cocktailliste:
                        zeile = zeile + 1
                        wodka = int(line.rstrip())
                        break
                if zutat == "Blue Coracao":
                    for line in cocktailliste:
                        zeile = zeile + 1
                        blueCoracao = int(line.rstrip())
                        break
                if zutat == "Maracujasaft":
                    for line in cocktailliste:
                        zeile = zeile + 1
                        maracujasaft = int(line.rstrip())
                        break
                if zutat == "Ananassaft":
                    for line in cocktailliste:
                        zeile = zeile + 1
                        ananassaft = int(line.rstrip())
                        break
                if zutat == "Ende":
                    break

    print(oSaft)
    print(grenadine)
    print(zitronensaft)
    print(tequila)
    print(wodka)
    print(blueCoracao)
    print(maracujasaft)
    print(ananassaft)
    
def mixen():
        
    if oSaft != 0:					#Ventile öffenen
        GPIO.output(oSaft_ventil,False)
    if grenadine != 0:
        GPIO.output(grenadine_ventil,False)
    if zitronensaft != 0:
        GPIO.output(zitronensaft_ventil,False)
    if tequila != 0:
        GPIO.output(tequila_ventil,False)
    if wodka != 0:
        GPIO.output(wodka_ventil,False)
    if blueCoracao != 0:
        GPIO.output(blueCoracao_ventil,False)
    if maracujasaft != 0:
        GPIO.output(maracujasaft_ventil,False)
    if ananassaft != 0:
        GPIO.output(ananassaft_ventil,False)
    
    for i in range(25):				#Ventile schließen
        if i == oSaft:
            GPIO.output(oSaft_ventil,True)
        if i == grenadine:
            GPIO.output(grenadine_ventil,True)
        if i == zitronensaft:
            GPIO.output(zitronensaft_ventil,True)
        if i == tequila:
            GPIO.output(tequila_ventil,True)
        if i == wodka:
            GPIO.output(wodka_ventil,True)
        if i == blueCoracao:
            GPIO.output(blueCoracao_ventil,True)
        if i == maracujasaft:
            GPIO.output(maracujasaft_ventil,True)
        if i == ananassaft:
            GPIO.output(ananassaft_ventil,True)

        time.sleep(.1)

def main():
    mixen()
main()

Für alle Interessierten meine Cocktailliste.txt

Code: Alles auswählen

Tequila Sunrise
O-Saft
16
Grenadine
3
Zitronensaft
2
Tequila
9

[Sirius3]

Statt etlicher Variablen für die verschiedenen Bestandteile, solltest Du passende Datenstrukturen verwenden, also Wörterbücher. Eines für die Pins, eines für die Mengen. Dann sind die Parameter und Rückgabewerte, die noch bei Deinen Funktionen fehlen, ganz einfach. cocktailfinder wird nie aufgerufen.

[Kebap]

Wie übergebe ich die Werte der einen Funktion der anderen ? Ich habe jetzt schon ein paar Sachen ausprobiert und gegooglt, erreiche aber nie das gewünschte Ziel.

Welche Sachen hast du denn ausprobiert?

Wieso googlst du solche Grundlagen, anstatt einfach Blackjacks Vorschlag zu folgen, und das Tutorial zu lesen?

[Kallinero]

So,
da mir ja alle dazu geraten haben das Tutorial zu lesen, habe ich noch mehr gemacht. Ich habe das Vorgeschlagene gelesen und noch weitere, ich hab mir auch noch ne Youtube-Reihe dazu reingezogen. Ich habe versucht alles zu behalten und nicht für mich typisch alles wieder über den Jordan zu schicken. Ich verstehe jetzt eure vorherige Kritik an meinem Code. Ich bin aber immer noch nicht ganz überzeugt meine integer Variablen (Rezept-Variablen) durch eine andere Datenstruktur ab zu ändern.

SO, nun seht den Quellcode, den ich jetzt poste, nicht als fertig oder fast "vorzeigbar" an, das ist nur ein weiterer Zwischenschritt zu meiner für mich perfekten Methode. Zur Zeit kämpfe ich damit ,dass ich wenn ich das Programm aufrufe nur einmal einen Cocktail mixen kann.

PS. Ich weiß das ich mir immer mehrere Probleme gleichzeitig schaffe, indem ich ein Problem nicht behandel sondern direkt ein "neues" schaffe, weil ich mit was neuem anfange, aber ich bin sehr schnell von so etwas genervt. Wenn es selbst beim 5 mal korrigieren immer noch Fehler gibt, macht mich das wütend und ich muss mit was neuem anfangen um zumindest ein bisschen ein Erfolgserlebnis zu haben.

Code: Alles auswählen

import sys
import RPi.GPIO as GPIO
from Tkinter import *
import time

#---------------------------------------------- Ventile zuordnen ----------------------------------------------

oSaft_ventil = 2				
grenadine_ventil = 3
zitronensaft_ventil = 4
tequila_ventil = 5
wodka_ventil = 6
blueCoracao_ventil = 17
maracujasaft_ventil =18
ananassaft_ventil = 19

#---------------------------------------------- Initiualisierung der GPIOs ----------------------------------------------

GPIO.setmode(GPIO.BCM)   		

GPIO.setup(oSaft_ventil,GPIO.OUT)      	
GPIO.setup(grenadine_ventil,GPIO.OUT)
GPIO.setup(zitronensaft_ventil,GPIO.OUT)
GPIO.setup(tequila_ventil,GPIO.OUT)
GPIO.setup(wodka_ventil,GPIO.OUT)
GPIO.setup(blueCoracao_ventil,GPIO.OUT)
GPIO.setup(maracujasaft_ventil,GPIO.OUT)
GPIO.setup(ananassaft_ventil,GPIO.OUT)

#---------------------------------------------- Ventile schließen ----------------------------------------------

GPIO.output(oSaft_ventil,True)      		
GPIO.output(grenadine_ventil,True)
GPIO.output(zitronensaft_ventil,True)
GPIO.output(tequila_ventil,True)
GPIO.output(wodka_ventil,True)
GPIO.output(blueCoracao_ventil,True)
GPIO.output(maracujasaft_ventil,True)
GPIO.output(ananassaft_ventil,True)

#---------------------------------------------- Cocktailfinder ----------------------------------------------

def mixen(gewaehlterCocktail):
        
    oSaft = 0				
    grenadine = 0
    zitronensaft = 0
    tequila = 0
    wodka = 0
    blueCoracao = 0
    maracujasaft = 0
    ananassaft = 0
    
    cocktailliste = open("cocktailliste.txt","r")

    for line in cocktailliste:
        gefundenerCocktail = line.rstrip()
	
        if gefundenerCocktail == gewaehlterCocktail:
            print(gewaehlterCocktail)
            for line in cocktailliste:
                zutat = line.rstrip()
                         
                if zutat == "O-Saft":
                    for line in cocktailliste:
                        oSaft = int(line.rstrip()) 
                        break
                if zutat == "Grenadine":
                    for line in cocktailliste:
                        grenadine = int(line.rstrip())
                        break
                if zutat == "Zitronensaft":
                    for line in cocktailliste:
                        zitronensaft = int(line.rstrip())
                        break
                if zutat == "Tequila":
                    for line in cocktailliste:
                        tequila = int(line.rstrip())
                        break
                if zutat == "Wodka":
                    for line in cocktailliste:
                        wodka = int(line.rstrip())
                        break
                if zutat == "Blue Coracao":
                    for line in cocktailliste:
                        blueCoracao = int(line.rstrip())
                        break
                if zutat == "Maracujasaft":
                    for line in cocktailliste:
                        maracujasaft = int(line.rstrip())
                        break
                if zutat == "Ananassaft":
                    for line in cocktailliste:
                        ananassaft = int(line.rstrip())
                        break
                if zutat == "Ende":
                    break

#---------------------------------------------- Mischfunktion ----------------------------------------------

#---------------------------------------------- Max-Finder ----------------------------------------------

    maximum = 0

    if maximum < oSaft:
        maximum = oSaft
    if maximum < grenadine:
        maximum = grenadine
    if maximum < zitronensaft:
        maximum = zitronensaft
    if maximum < tequila:
        maximum = tequila
    if maximum < wodka:
        maximum = wodka
    if maximum < blueCoracao:
        maximum = blueCoracao
    if maximum < maracujasaft:
        maximum = maracujasaft
    if maximum < ananassaft:
        maximum = ananassaft

#---------------------------------------------- Ventile öffnen ----------------------------------------------

    if oSaft != 0:					
        GPIO.output(oSaft_ventil,False)
    if grenadine != 0:
        GPIO.output(grenadine_ventil,False)
    if zitronensaft != 0:
        GPIO.output(zitronensaft_ventil,False)
    if tequila != 0:
        GPIO.output(tequila_ventil,False)
    if wodka != 0:
        GPIO.output(wodka_ventil,False)
    if blueCoracao != 0:
        GPIO.output(blueCoracao_ventil,False)
    if maracujasaft != 0:
        GPIO.output(maracujasaft_ventil,False)
    if ananassaft != 0:
        GPIO.output(ananassaft_ventil,False)

#----------------------------------------------Ventile schließen ----------------------------------------------
    
    for i in range(maximum):				
        if i == oSaft:
            GPIO.output(oSaft_ventil,True)
        if i == grenadine:
            GPIO.output(grenadine_ventil,True)
        if i == zitronensaft:
            GPIO.output(zitronensaft_ventil,True)
        if i == tequila:
            GPIO.output(tequila_ventil,True)
        if i == wodka:
            GPIO.output(wodka_ventil,True)
        if i == blueCoracao:
            GPIO.output(blueCoracao_ventil,True)
        if i == maracujasaft:
            GPIO.output(maracujasaft_ventil,True)
        if i == ananassaft:
            GPIO.output(ananassaft_ventil,True)            
        time.sleep(1)
        
    GPIO.cleanup()

#---------------------------------------------- Kontrolle kann geschlöscht werden! ----------------------------------------------

    print(" ")
    print("So viel Osaft ist drin: %d "%(oSaft))
    print("So viel Grenadine ist drin: %d "%(grenadine))
    print("So viel Zitronensaft ist drin: %d "%(zitronensaft))
    print("So viel Tequila ist drin: %d "%(tequila))
    print("So viel Wodka ist drin: %d "%(wodka))
    print("So viel Blue Coracao ist drin: %d "%(blueCoracao))
    print("So viel Maracujasaft ist drin: %d "%(maracujasaft))
    print("So viel Ananassaft ist drin: %d "%(ananassaft))

#---------------------------------------------- Layout ----------------------------------------------   

#---------------------------------------------- Funktionen ----------------------------------------------

#---------------------------------------------- Auswaehlen ----------------------------------------------    

def choose():
    print("auswaehlen")                                                                   
#---------------------------------------------- Mixen ----------------------------------------------

def mixit():                                                                    
    gewaehlterCocktail = liste.get("active")
    mixen(gewaehlterCocktail)

#---------------------------------------------- Fullscreen ----------------------------------------------

def close(event):
    top.attributes("-fullscreen", False)
                
top = Tk()
top.attributes("-fullscreen", True)
top.config(bg="white")
top.bind("<Escape>", close)

#---------------------------------------------- Label ----------------------------------------------

cocktail = Label(top)                               
cocktail.config(height = 30,width = 50, bg = "red")
cocktail.grid(row = 1 , column =2)

rezept = Label(top)
rezept.config(height = 25, width = 35, bg = "grey")
rezept.grid(row = 1 , column = 3)

#---------------------------------------------- Liste ----------------------------------------------

liste = Listbox(top, height = 17)                                         
liste.config(font=('Times New Roman',20))
liste.grid(row = 1, column = 4)

def wechselalk():
    liste.delete(0,50)
    liste.insert("end","All in One","Alice Deluxe","Baltic","Black Death","El Dorado","Emerald Dream","Exotic Blue","Festini","Florida Sunrise","Green Eyes","Green Poisen","Grüne Wiese","Happy Hour","Hawaiian Vodka","Knock Out","Mexicano","Pink Pussycat","Screwdriver","Simple Red","Springtime Cooler","Tequila Sunrise")

def wechselalkfrei():
    liste.delete(0,50)
    liste.insert("end","Alice","Ballerina","Batman Cocktail","Bora Bora","Golden Nugget","Pussy Foot","Yellowjacket","Thoothless Shark")

#---------------------------------------------- Frame ----------------------------------------------

frame1 = Frame(top)
frame1.grid(row = 0, column = 4)

#---------------------------------------------- Radiobutton ----------------------------------------------

anti = Radiobutton(frame1, text="Alkoholfrei",font=('Times New Roman',18), bg = "white", value=0,height = 1, command = wechselalkfrei)
voll = Radiobutton(frame1, text="Alkoholvoll",font=('Times New Roman',18), bg = "white", value=1,height = 1, command = wechselalk)
anti.grid(row = 0, sticky = "w")
voll.grid(row = 1, sticky = "w")

#---------------------------------------------- Scrollbar ----------------------------------------------

scroll = Scrollbar(top, orient = VERTICAL, width = 50)
liste["yscrollcommand"]=scroll.set
scroll["command"]=liste.yview
scroll.grid( row = 1, column = 5, sticky=N+S+E)

#---------------------------------------------- Knopf ----------------------------------------------

knopf = Button(text='Choose',height= 2,width = 10,font=('Times New Roman',20),command=choose)
knopf.grid(row = 1,column = 3, sticky=N+E)

mix = Button(text='Mix it',height= 2,width=10,font=('Times New Roman',18), command=mixit)
mix.grid(row = 1, column = 3, sticky = S+E)

top.mainloop()