Eigene Cocktailmaschine

Du hast eine Idee für ein Projekt?
Antworten
Kallinero
User
Beiträge: 9
Registriert: Montag 8. Mai 2017, 14:44

Montag 8. Mai 2017, 15:16

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()
Zuletzt geändert von Anonymous am Dienstag 9. Mai 2017, 09:48, insgesamt 1-mal geändert.
Grund: Quelltext in Python-Codebox-Tags gesetzt.
Nach oben
BlackJack

Dienstag 9. Mai 2017, 10:26

@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.
Nach oben
Kallinero
User
Beiträge: 9
Registriert: Montag 8. Mai 2017, 14:44

Dienstag 9. Mai 2017, 11:33

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.
Nach oben
Kallinero
User
Beiträge: 9
Registriert: Montag 8. Mai 2017, 14:44

Dienstag 9. Mai 2017, 17:31

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)
Zuletzt geändert von Anonymous am Dienstag 9. Mai 2017, 17:47, insgesamt 1-mal geändert.
Grund: Quelltext in Python-Codebox-Tags gesetzt.
Nach oben
Sirius3
User
Beiträge: 8115
Registriert: Sonntag 21. Oktober 2012, 17:20

Dienstag 9. Mai 2017, 17:46

@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.
Nach oben
Kallinero
User
Beiträge: 9
Registriert: Montag 8. Mai 2017, 14:44

Mittwoch 10. Mai 2017, 21:41

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()
Zuletzt geändert von Anonymous am Mittwoch 10. Mai 2017, 21:49, insgesamt 1-mal geändert.
Grund: Quelltext in Python-Codebox-Tags gesetzt.
Nach oben
BlackJack

Mittwoch 10. Mai 2017, 22:44

@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.
Nach oben
Kallinero
User
Beiträge: 9
Registriert: Montag 8. Mai 2017, 14:44

Mittwoch 10. Mai 2017, 23:04

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.
Nach oben
BlackJack

Donnerstag 11. Mai 2017, 00:00

@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.
Nach oben
Zizibee
User
Beiträge: 166
Registriert: Donnerstag 12. April 2007, 08:36

Donnerstag 11. Mai 2017, 09:03

@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.
Nach oben
Kallinero
User
Beiträge: 9
Registriert: Montag 8. Mai 2017, 14:44

Donnerstag 11. Mai 2017, 13:04

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!
Nach oben
BlackJack

Donnerstag 11. Mai 2017, 13:33

@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.
Nach oben
Kallinero
User
Beiträge: 9
Registriert: Montag 8. Mai 2017, 14:44

Dienstag 16. Mai 2017, 16:29

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
Nach oben
BlackJack

Dienstag 16. Mai 2017, 18:50

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

Du rufst keine der Funktionen auf die Du da definierst.
Nach oben
Zizibee
User
Beiträge: 166
Registriert: Donnerstag 12. April 2007, 08:36

Mittwoch 17. Mai 2017, 08:29

Kallinero hat geschrieben: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...
Nach oben
Antworten

Zurück zu „Ideen“