Globale Namen definieren ???

[Zappelmann]

So guten Morgen,


Ich möchte nur mal eine Programmiertechnische Frage geklärt wissen. Wo ich gestern keine Lösung atok zur Verfügung hatte.

Ich habe das Script gestern nochmal komplett neu aufgesetzt und sämtliche Programablaufmodule jetzt als 'def' Funktion gesetzt. Unter anderem auch den Messvorgang.
Jedoch wenn ich dann im Programmablauf in der while True: Schleife dann die Funktion Messung_vorn_perma(): aufrufe dann macht der zwar sein Messvorgang und gibt mir das Ergebnis auf dem Bildschirm auch aus. Aber wenn ich dahinter eine if Abfrage setze, die den distance Wert aus dem Messmodul der aktuellen Messung abfragen soll, dann bekomm ich eine Error Meldung das der globale name 'distance' nicht definiert wurde. Und somit übergibt der dann den Messwert nicht an die if Abfrage. Jetzt hab ich mir beholfen indem ich das Modul halt doch wieder direkt mit in den Programablauf komplett mit reingesetzt habe anstatt nur den def Namen des Messmoduls selber. Jedoch ist das nicht die gewünschte Lösung, warum ich mir überhaupt die Mühe mache das gesamte Script neuaufzusetzen.

Code: Alles auswählen

def Messung_vorn_perma():
#Messung Start
    print "Messung_vorn_perma_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
          pass
    start = time.time()
    while GPIO.input(16)==1:
          pass
    stop = time.time()
    elapsed = stop-start
    distance = elapsed * 17500
    print "Abstand_vorn: %.1f cm" % distance
    print "Messung_vorn_perma_ende
#Messung Ende

while True:
    Messung_vorn_perma()
    if distance < 20:        #Und hier bekommt der dann die Meldung das Distance nicht als Globaler Name definiert wurde. Jedoch wenn ich den Namen definiere bringt mir dsa nichts da der mir das Messergebniss nicht mit übergibt.
	Stop_anhalten()

ich hab wie schon erwähnt dann das Messmodul direkt mit in die Schleife gepackt und dann funktioniert auch die Übergabe des Messwertes.
Hat da jemand eine Idee wie die Definierung mit einer sauberen Übergabe geschrieben werden kann, ohne gleich das komplette Modul, in die whiles True Schleife reinzukopieren. Das ganze soll natürlich der Übersichtlichkeit dienen, damit der Programmablauf kurz gehalten wird und ich schneller nur an einer Stelle mal ne Code Anpassung durchführen kann.


MFG

Zappelmann

[EyDu]

Hallo und willkommen im Forum!

Werte betreten Funktionen durch Parameter und verlassen sie durch Rückgabewerte. Du musst also einfach nur die Distanz zurückgeben und unten verwenden.

Bei der Gelegenheit: Außer Konstanten, Importen, Klassen und Funktionen sollte nichts auf modulebene stehen. Sont kann man das Modul noch schlecht importieren, da der Code immer sofort ausgeführt wird. Der ganze Code ab Zeile 23 sollte in eine Funktion gepackt werden. Überlicherweise verwendet man dafür das folgende Idiom:

Code: Alles auswählen

def main():
    ...


if __name__ == "__main__":
   main()

Damit wird sichergestellt, dass dein Code nur das ausgeführt wird, wenn du das Programm direkt startest. Bei einem Import wird die main-Funktion nicht gestartet.

atok

Mich hat es da gerade ein wenig gegruselt

[/me]

Damit wird sichergestellt, dass dein Code nur das ausgeführt wird, wenn du das Programm direkt startest. Bei einem Import wird die main-Funktion nicht gestartet.

Ich würde dann auch noch die print-Statements aus der Funktion Messung_vorn_perma herausnehmen. Verarbeitungslogik mit Eingabe/Ausgabe zu mischen ist im Rahmen einer flexiblen Struktur keine gute Idee.

[BlackJack]

Dann könnte man noch den Syntaxfehler beheben, und die Initialisierung aus der Messung heraus nehmen, und die magischen Zahlen zu Konstanten machen und an die Funktion auch als Argumente übergeben, und sich mal den Style Guide for Python Code anschauen.

[Zappelmann]

Ok Jungs,

zum ersten freut es mich das Ihr hier gleich direkt so zahlreich auf meine Anfrage antwortet.
kurz ein paar Worte zu meiner Person.

Ich hab von Python Programmierung null Plan. Eigentlich generel nicht vom Programmieren, aber das ist erstmal egal.
Jedoch hab ich mir diesen Code mühsam zusammengebaut. und bisher funzt das scheinbar was ich da zusammengebaut habe.
dies ist natürlich nur ein Schnipsel aus dem gesamten Code.
ich werde mal das gesamte Script hier eben linken. Denn mit einigen Eurer Aussagen kann ich atm nicht wirklich was anfangen.
Das ich natürlich noch vieles über Python lernen muss ist mir klar, aber das geht natürlich auch nicht über Nacht. Wobei ich mich jetzt seit ca. 3 Wochen mit Python beschäftige komme ich nur langsam voran. Und Bücher lesen na ja es vermittelt zwar einiges an Wissen aber die Praxis ist meistens doch etwas komplexer.

So damit ihr überhaupt wisst worum es sich bei dem Codeschnippsel handelt.
hier kurz ein paar Worte dazu.

Ich arbeite gerade an einem kleinem Roboter Projekt https://www.youtube.com/watch?v=hN7qRw3E0Gk.
Der Raspberry Pi ist das Gehirn und ich hab ein paar Motoren / Servos / und ein Ultraschallmodul für eine Abstandsmessung.
Das Ziel des Projektes ist ein autonomen Roboter zu bauen der nirgendwo anstößt und Hindernissen selber ausweichen kann.

Der Schnippsel selber war nur eine Messfunktion. von dem HC-SR04 US-Modull

so ich setzt mal mein aktuellen Code hier rein und dann bleibt also immer noch die Frage einer globalen definition der variable distance für die übergabe an die if Abfrage.
Mir wäre es recht mir da einfach entweder als nachvollziehbares Beispiel zu posten oder das script dahingehend anzupassen.

Die Prints im übrigen waren absichtlich gwollt um einie grafische ausgabe über den Puttyterm auf meinem PC zu bekommen um zu sehen was der gerade so macht wenn der unterwegs ist.
Um Fehler festzustellen ob ich mit meiner Programmierung gerade falsch liege oder ob der Ablauf sauber umgesetzt wird wi ich mir das vorstelle. Desweiteren soll dies später auch als Logfile dienen.
Nochmal ich bin leider kein Profi im Programmieren. Jedoch sehr lernfähig wenn ich etwas gut erklärt bekomme oder es durch eigene Analyse sauber nachvollziehen kann.

Code: Alles auswählen

#!/usr/bin/python

from time import sleep
import time
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)
print "Ultraschallmessung mit HC-SR04"

#A routine to control a pair of pins

def ControlAPairOfPins(FirstPin,FirstState,SecondPin,SecondState):
  if FirstState == "1":
    GPIO.output(int(FirstPin),True)
  else:
    GPIO.output(int(FirstPin),False)
  if SecondState == "1":
    GPIO.output(int(SecondPin),True)
  else:
    GPIO.output(int(SecondPin),False)
  return

def dist_vorn_perma():
    dist_vorn_perma = elapsed * 17000
'''
def dist_links_perma():
    dist_links_perma = elapsed * 17000

def dist_rechts_perma():
    dist_rechts_perma = elapsed * 17000

def distance():
    distance = elapsed * 17000
                                                                     #das war hier mein Ansatz was die globale namens definition angeht. jedoch liege ich hier programmiertechnisch scheinbar total daneben. 
                                                                     #deswegen benötige ich von Euch PROFIS mal ein sauberes Beispiel damit sämtliche distance Werte später bei der richtigen if Abfrage übergeben 
                                                                     #werden können und ich dadurch die schleife klein sauber und übersichtlich halten kann.
                                                                     #ansonten funktioniert der Code bisher im groben und ganzen. Der Feinschliff ist natürlich schon seit ein paar Tagen in Arbeit. 
                                                                  
def dist_links():
    dist_links = elapsed * 17000

def dist_rechts():
    dist_rechts = elapsed * 17000

'''
def Stop_anhalten_permanent():
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(19,GPIO.OUT)
    GPIO.setup(7,GPIO.OUT)
    GPIO.setup(22,GPIO.OUT)
    GPIO.setup(11,GPIO.OUT)
    ControlAPairOfPins("19","0","7","0")
    ControlAPairOfPins("22","0","11","0")
    print "Stop_vorwaertz"

def Vorwaertz_fahren():
    #Geradeaus Start
    print "vorwaertz_fahren"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(19,GPIO.OUT)
    GPIO.setup(7,GPIO.OUT)
    GPIO.setup(22,GPIO.OUT)
    GPIO.setup(11,GPIO.OUT)
    ControlAPairOfPins("19","1","7","0")
    ControlAPairOfPins("22","1","11","1")
    print "Geradeaus_vorwaerts"
    #time.sleep(True)
    #Geradeaus Ende
	
def Geradeaus_vorwaertz_start():
    #Geradeaus Start
    print "Geradeaus_vorwaertz_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(19,GPIO.OUT)
    GPIO.setup(7,GPIO.OUT)
    GPIO.setup(22,GPIO.OUT)
    GPIO.setup(11,GPIO.OUT)
    ControlAPairOfPins("19","1","7","0")
    ControlAPairOfPins("22","1","11","1")
    print "Geradeaus_vorwaerts"
    # Geradeaus Ende
	
def Links_fahren():
    #Drehung links Start
    print "Drehung_nach_links_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(19,GPIO.OUT)
    GPIO.setup(7,GPIO.OUT)
    GPIO.setup(22,GPIO.OUT)
    GPIO.setup(11,GPIO.OUT)
    ControlAPairOfPins("19","1","7","0")
    ControlAPairOfPins("22","0","11","1")
    time.sleep(0.5)
    print "Drehung_nach_links_ende"
    #Drehung links Ende
	
def Rechts_fahren():
    #Drehung rechts Start
    print "Drehung_nach_rechts_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(19,GPIO.OUT)
    GPIO.setup(7,GPIO.OUT)
    GPIO.setup(22,GPIO.OUT)
    GPIO.setup(11,GPIO.OUT)
    ControlAPairOfPins("19","1","7","1")
    ControlAPairOfPins("22","1","11","1")
    print "Drehung_nach_rechts"
    time.sleep(0.5)
    print "Drehung_nach_rechts_ende"
    #Drehung rechts Ende

def Rueckwaertz_fahren():
    #Drehung zurueck Start
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(19,GPIO.OUT)
    GPIO.setup(7,GPIO.OUT)
    GPIO.setup(22,GPIO.OUT)
    GPIO.setup(11,GPIO.OUT)
    ControlAPairOfPins("19","1","7","1")
    ControlAPairOfPins("22","1","11","1")
    print "Fahre zurueck"
    time.sleep(1.5)
    print "zurueck_ende"
    #Drehung rueckwaertz Ende
		
def Servo_permanent_vorn():
    #Servo anfang mitte Start
    print "Robo_Cycle"
    print "Servo_mitte_start"
    GPIO.setup(26,GPIO.OUT)
    p = GPIO.PWM(26,0.1)
    p.start(5.5)
    p.ChangeDutyCycle(5.5)
    time.sleep(True)
    p.stop(5.5)
    print "Servo_mitte_ende"
    #Servo anfang mitte Ende

def Servo_permanent_links():
    #Drehung nach links Start
    print "Servo_links_permanent_start"
    GPIO.setup(26,GPIO.OUT)
    p = GPIO.PWM(26,50)
    p.start(5.5)
    p.ChangeDutyCycle(8.5)
    time.sleep(0.2)
    p.stop(8.5)
    print "Servo_links_permanent_ende"
    #Drehung nach links Ende

def Servo_permanent_rechts():
    #Drehung nach rechts Start
    print "Servo_rechts_permanent_start"
    GPIO.setup(26,GPIO.OUT)
    p = GPIO.PWM(26,50)
    p.start(8.5)
    p.ChangeDutyCycle(3.5)
    time.sleep(0.2)
    p.stop(3.5)
    print "Servo_rechts_permanent_ende"
    #Drehung nach rechts Ende

def Servo_permanent_mitte():
    #Drehung Mitte Start
    print "Servo_mitte_permanent_start"
    GPIO.setup(26,GPIO.OUT)
    p = GPIO.PWM(26,50)
    p.start(3.5)
    p.ChangeDutyCycle(5.5)
    time.sleep(0.2)
    p.stop(5.5)
    print "Servo_mitte_permanent_ende"
    #Drehung Mitte Ende

def Servo_anfang_mitte():
    #Servo anfang mitte Start
    print "Robo_Cycle"
    print "Servo_mitte_start"
    GPIO.setup(26,GPIO.OUT)
    p = GPIO.PWM(26,0.1)
    p.start(5.5)
    p.ChangeDutyCycle(5.5)
    time.sleep(0.1)
    p.stop(5.5)
    print "Servo_mitte_ende"
    #Servo anfang mitte Ende

def Servo_links():
    #Drehung nach links Start
    print "Servo_links_start"
    GPIO.setup(26,GPIO.OUT)
    p = GPIO.PWM(26,50)
    p.start(5.5)
    p.ChangeDutyCycle(10.5)
    time.sleep(0.3)
    p.stop(10.5)
    print "Servo_links_ende"
    #Drehung nach links Ende

def Servo_rechts():
    #Drehung nach rechts Start
    print "Servo_rechts_start"
    GPIO.setup(26,GPIO.OUT)
    p = GPIO.PWM(26,50)
    p.start(10.5)
    p.ChangeDutyCycle(1)
    time.sleep(0.3)
    p.stop(1)
    print "Servo_rechts_ende"
    #Drehung nach rechts Ende

def Servo_mitte():
    #Drehung Mitte Start
    print "Servo_mitte_start"
    GPIO.setup(26,GPIO.OUT)
    p = GPIO.PWM(26,50)
    p.start(1)
    p.ChangeDutyCycle(5.5)
    time.sleep(0.2)
    p.stop(5.5)
    print "Servo_mitte_ende"
    #Drehung Mitte Ende

def Messung_permanent_vorn():
    #Messung Start
    print "Messung_vorn_permanent_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
          pass
    start = time.time()
    while GPIO.input(16)==1:
          pass
    stop = time.time()
    elapsed = stop-start
    dist_vorn_perma = elapsed * 17500
    print "Abstand_vorn: %.1f cm" % dist_vorn_perma
    #Messung Ende

def Messung_permanent_links():
    #Messung links Start
    print "Messung_links_permanent_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
      pass
    start = time.time()
    while GPIO.input(16)==1:
      pass
    stop = time.time()
    elapsed = stop-start
    dist_links_perma = elapsed * 17000
    print "Abstand_links: %.1f cm" % dist_links_perma
    print "Messung_links_permanent_ende"
    #Messung links Ende

def Messung_permanent_rechts():
    #Messung rechts Start
    print "Messung_rechts_permanent_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
      pass
    start = time.time()
    while GPIO.input(16)==1:
      pass
    stop = time.time()
    elapsed = stop-start
    dist_rechts_perma = elapsed * 17000
    print "Abstand_rechts: %.1f cm" % dist_rechts_perma
    print "Messung_rechts_permanent_ende"
    #Messung rechts Ende

def Messung_distance_vorn():
    #Messung Start
    print "Messung_vorn_permanent_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(0.5)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
          pass
    start = time.time()
    while GPIO.input(16)==1:
          pass
    stop = time.time()
    elapsed = stop-start
    distance = elapsed * 17500
    print "Abstand_vorn: %.1f cm" % distance
    #Messung Ende

def Messung_dist_links():
    #Messung links Start
    print "Messung_links_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
      pass
    start = time.time()
    while GPIO.input(16)==1:
      pass
    stop = time.time()
    elapsed = stop-start
    dist_links = elapsed * 17000
    print "Abstand_links: %.1f cm" % dist_links
    print "Messung_links_ende"
    #Messung links Ende

def Messung_dist_rechts():
    #Messung rechts Start
    print "Messung_rechts_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
      pass
    start = time.time()
    while GPIO.input(16)==1:
      pass
    stop = time.time()
    elapsed = stop-start
    dist_rechts = elapsed * 17000
    print "Abstand_rechts: %.1f cm" % dist_rechts
    print "Messung_rechts_ende"
    #Messung rechts Ende
	


while True:
    Servo_anfang_mitte()
    Vorwaertz_fahren()
    #Messung Start
    print "Messung_vorn_permanent_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
          pass
    start = time.time()
    while GPIO.input(16)==1:
          pass
    stop = time.time()
    elapsed = stop-start
    dist_vorn_perma = elapsed * 17500
    print "Abstand_vorn: %.1f cm" % dist_vorn_perma
    #Messung Ende
    if dist_vorn_perma < 30:
        Stop_anhalten_permanent()
        Rueckwaertz_fahren()
        print "STOP_VORN"
        Servo_links()
        #Messung links Start
        print "Messung_links_start"
        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(12,GPIO.OUT)
        GPIO.setup(16,GPIO.IN)
        GPIO.output(12, False)
        time.sleep(1)
        GPIO.output(12, True)
        time.sleep(0.00001)
        start = time.time()
        GPIO.output(12, False)
        while GPIO.input(16)==0:
          pass
        start = time.time()
        while GPIO.input(16)==1:
          pass
        stop = time.time()
        elapsed = stop-start
        dist_links = elapsed * 17000
        print "Abstand_links: %.1f cm" % dist_links
        print "Messung_links_ende"
        #Messung links Ende
        Servo_rechts()
        #Messung rechts Start
        print "Messung_rechts_start"
        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(12,GPIO.OUT)
        GPIO.setup(16,GPIO.IN)
        GPIO.output(12, False)
        time.sleep(1)
        GPIO.output(12, True)
        time.sleep(0.00001)
        start = time.time()
        GPIO.output(12, False)
        while GPIO.input(16)==0:
          pass
        start = time.time()
        while GPIO.input(16)==1:
          pass
        stop = time.time()
        elapsed = stop-start
        dist_rechts = elapsed * 17000
        print "Abstand_rechts: %.1f cm" % dist_rechts
        print "Messung_rechts_ende"
        #Messung rechts Ende
        Servo_permanent_mitte()
        if dist_links > dist_rechts:
            Links_fahren()
        else:
            Rechts_fahren()
    else:
        Geradeaus_vorwaertz_start()
    Servo_permanent_links()
    #Messung links Start
    print "Messung_links_permanent_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
      pass
    start = time.time()
    while GPIO.input(16)==1:
      pass
    stop = time.time()
    elapsed = stop-start
    dist_links_perma = elapsed * 17000
    print "Abstand_links: %.1f cm" % dist_links_perma
    print "Messung_links_permanent_ende"
    #Messung links Ende
    if dist_links_perma < 30:
        Stop_anhalten_permanent()
        print "STOP_LINKS"
        Rueckwaertz_fahren()
        Servo_links()
        #Messung links Start
        print "Messung_links_start"
        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(12,GPIO.OUT)
        GPIO.setup(16,GPIO.IN)
        GPIO.output(12, False)
        time.sleep(1)
        GPIO.output(12, True)
        time.sleep(0.00001)
        start = time.time()
        GPIO.output(12, False)
        while GPIO.input(16)==0:
          pass
        start = time.time()
        while GPIO.input(16)==1:
          pass
        stop = time.time()
        elapsed = stop-start
        dist_links = elapsed * 17000
        print "Abstand_links: %.1f cm" % dist_links
        print "Messung_links_ende"
        #Messung links Ende
        Servo_rechts()
        #Messung rechts Start
        print "Messung_rechts_start"
        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(12,GPIO.OUT)
        GPIO.setup(16,GPIO.IN)
        GPIO.output(12, False)
        time.sleep(1)
        GPIO.output(12, True)
        time.sleep(0.00001)
        start = time.time()
        GPIO.output(12, False)
        while GPIO.input(16)==0:
          pass
        start = time.time()
        while GPIO.input(16)==1:
          pass
        stop = time.time()
        elapsed = stop-start
        dist_rechts = elapsed * 17000
        print "Abstand_rechts: %.1f cm" % dist_rechts
        print "Messung_rechts_ende"
        #Messung rechts Ende
        Servo_permanent_mitte()
        if dist_links > dist_rechts:
            Links_fahren()
        else:
            Rechts_fahren()
    else:
        Geradeaus_vorwaertz_start()
    Servo_permanent_rechts()
    #Messung rechts Start
    print "Messung_rechts_permanent_start"
    GPIO.setmode(GPIO.BOARD)
    GPIO.setup(12,GPIO.OUT)
    GPIO.setup(16,GPIO.IN)
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
      pass
    start = time.time()
    while GPIO.input(16)==1:
      pass
    stop = time.time()
    elapsed = stop-start
    dist_rechts_perma = elapsed * 17000
    print "Abstand_rechts: %.1f cm" % dist_rechts_perma
    print "Messung_rechts_permanent_ende"
    #Messung rechts Ende
    if dist_rechts_perma < 30:
        Stop_anhalten_permanent()
        print "STOP_RECHTS"
        Rueckwaertz_fahren()
        Servo_links()
        #Messung links Start
        print "Messung_links_start"
        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(12,GPIO.OUT)
        GPIO.setup(16,GPIO.IN)
        GPIO.output(12, False)
        time.sleep(1)
        GPIO.output(12, True)
        time.sleep(0.00001)
        start = time.time()
        GPIO.output(12, False)
        while GPIO.input(16)==0:
          pass
        start = time.time()
        while GPIO.input(16)==1:
          pass
        stop = time.time()
        elapsed = stop-start
        dist_links = elapsed * 17000
        print "Abstand_links: %.1f cm" % dist_links
        print "Messung_links_ende"
        #Messung links Ende
        Servo_rechts()
        #Messung rechts Start
        print "Messung_rechts_start"
        GPIO.setmode(GPIO.BOARD)
        GPIO.setup(12,GPIO.OUT)
        GPIO.setup(16,GPIO.IN)
        GPIO.output(12, False)
        time.sleep(1)
        GPIO.output(12, True)
        time.sleep(0.00001)
        start = time.time()
        GPIO.output(12, False)
        while GPIO.input(16)==0:
          pass
        start = time.time()
        while GPIO.input(16)==1:
          pass
        stop = time.time()
        elapsed = stop-start
        dist_rechts = elapsed * 17000
        print "Abstand_rechts: %.1f cm" % dist_rechts
        print "Messung_rechts_ende"
        #Messung rechts Ende
        Servo_permanent_mitte()
        if dist_links > dist_rechts:
            Links_fahren()
        else:
            Rechts_fahren()
    else:
        Geradeaus_vorwaertz_start()
#    Servo_permanent_mitte()

so gut jetzt seid Ihr dran. gebt mir bitte den entscheidenen Hinweis was es mit dieser globalen namensdefinierung aufsich hat. und wie das dann in meinem fall aussehen müsste. damit es zu keinem Error kommt.

Vielen Dank für Eure Mühe sich hiermit mal kurz beschäftigen zu müssen.

MFG

Zappelmann

[snafu]

@Zappelmann: Keine direkte Antwort auf deine Frage, aber die Stellen wo du mittels einer `while`-Schleife offenbar auf die Antwort der Schnittstelle wartest, könnte man etwas "schonender" schreiben, indem man im Schleifenkörper jeweils ein `time.sleep(0.01)` einbaut. Das ist in der Regel immer noch recht genau, aber verbraucht weniger Ressourcen.

[BlackJack]

@Zappelmann: Der Hinweis wurde eigentlich schon gegeben: Benutze Funktionen. Also tatsächlich Funktionen und nicht das ``def`` nur missbrauchen um einem Quelltextabschnitt einen ”anspringbaren” Namen zu geben. Funktionen sollten nichts verwenden (ausser Konstanten) was nicht als Argument übergeben wurde, und wenn die einen Wert als Ergebnis haben, dann wird der als Rückgabewert an den Aufrufer zurückgegeben. Das sollte in jedem Grundlagentutorial oder auch Buch erklärt sein.

Dann kannst Du sicher auch einiges an Wiederholungen aus dem Quelltext rauskürzen. Und ich denke mal die ganzen Initialisierungsaufrufe bezüglich GPIO sollte man auch nicht *jedes mal* in *jeder* Funktion machen. Sachen die sich nicht ändern, braucht man nur einmal machen.

Was hast Du Dir denn bei der `ControlAPairOfPins()` mit den Argumenten gedacht? Warum sind das Zeichenketten?

[Zappelmann]

So hier mal in kurzform wie der eigentliche Programm Code ablaufen soll.

Code: Alles auswählen

while True:
    Servo_anfang_mitte()
    Vorwaertz_fahren()
    Messung_permanent_vorn()
    if dist_vorn_perma < 30:
        Stop_anhalten_permanent()
        Rueckwaertz_fahren()
        print "STOP_VORN"
        Servo_links()
        Messung_dist_links()
        Servo_rechts()
        Messung_dist_rechts()
        Servo_permanent_mitte()
        if dist_links > dist_rechts:
            Links_fahren()
        else:
            Rechts_fahren()
    else:
        Geradeaus_vorwaertz_start()
    Servo_permanent_links()
    Messung_permanent_links()
    if dist_links_perma < 30:
        Stop_anhalten_permanent()
        print "STOP_LINKS"
        Rueckwaertz_fahren()
        Servo_links()
        Messung_dist_links()
        Servo_rechts()
        Messung_dist_rechts()		
		Servo_permanent_mitte()
        if dist_links > dist_rechts:
            Links_fahren()
        else:
            Rechts_fahren()
    else:
        Geradeaus_vorwaertz_start()
    Servo_permanent_rechts()
    Messung_permanent_rechts()
    if dist_rechts_perma < 30:
        Stop_anhalten_permanent()
        print "STOP_RECHTS"
        Rueckwaertz_fahren()
        Servo_links()
        Messung_dist_links()
        Servo_rechts()
        Messung_dist_rechts()
        Servo_permanent_mitte()
        if dist_links > dist_rechts:
            Links_fahren()
        else:
            Rechts_fahren()
    else:
        Geradeaus_vorwaertz_start()

[Zappelmann]

@Zappelmann: Keine direkte Antwort auf deine Frage, aber die Stellen wo du mittels einer `while`-Schleife offenbar auf die Antwort der Schnittstelle wartest, könnte man etwas "schonender" schreiben, indem man im Schleifenkörper jeweils ein `time.sleep(0.01)` einbaut. Das ist in der Regel immer noch recht genau, aber verbraucht weniger Ressourcen.

werde ich drüber nachdenken. meinst du nach jeder Abfrage ? oder wie meinst du das ? ich hab ja gerade mal den Schleife vollständig reingesetzt wie ich die gerne in kurzform haben will vielleicht kannst du das mal da einfügen wo du meinst und dann kurz erklären was du damit bezwecken willst.

danke für deine Antwort.

[Zappelmann]

@Zappelmann: Der Hinweis wurde eigentlich schon gegeben: Benutze Funktionen. Also tatsächlich Funktionen und nicht das ``def`` nur missbrauchen um einem Quelltextabschnitt einen ”anspringbaren” Namen zu geben. Funktionen sollten nichts verwenden (ausser Konstanten) was nicht als Argument übergeben wurde, und wenn die einen Wert als Ergebnis haben, dann wird der als Rückgabewert an den Aufrufer zurückgegeben. Das sollte in jedem Grundlagentutorial oder auch Buch erklärt sein.

Dann kannst Du sicher auch einiges an Wiederholungen aus dem Quelltext rauskürzen. Und ich denke mal die ganzen Initialisierungsaufrufe bezüglich GPIO sollte man auch nicht *jedes mal* in *jeder* Funktion machen. Sachen die sich nicht ändern, braucht man nur einmal machen.

Was hast Du Dir denn bei der `ControlAPairOfPins()` mit den Argumenten gedacht? Warum sind das Zeichenketten?

Mach doch mal bitte ein kleines nachvollziehbares Beispiel wie du das meinst. bitte mit Kommentaren versehen damit ich das verstehen kann was du versuchst mir zu vermitteln.

Weil der soll damit 2 GPIO Pins jeweils mit True und False ansprechen soll. Um damit den Zustand für den jeweiligen Motor für die jeweilige Drehrichtung zu setzen.
Dahinter sitzt noch ein Motorshield treiber mit einem IC L293DNE Motortreiber, der das ganze über die vier GPIO nachher steuert.

Code: Alles auswählen

    ControlAPairOfPins("19","0","7","0") # Die Motor Pins für den shieldtreiber am raspi werden dadruch angesprochen= "GPIO19","False","GPIO7","False" in dem fall hier alls auf aus also stop alle motoren

    ControlAPairOfPins("22","0","11","0") = "GPIO22","False","GPIO11","Flase" 

[BlackJack]

@Zappelmann: Pack Deinen Code mal komplett beiseite und lerne wie Funktionen aufgebaut sind und was man damit machen kann. Das übst Du ein bisschen an verschiedenen Beispielen, und mit dem Wissen bewaffnet kannst Du dann zu Deinem Roboter-Quelltext zurückkehren.

Das, beziehungsweise die Beispiele nach denen Du hier wiederholt fragst, stehen in jedem Tutorial oder Einsteigerbuch, denn Funktionen sind etwas ganz grundlegendes. Dir so etwas hier reinzutippen bedeutet etwas aus einem Tutorial abzutippen, oder sich selber auszudenken was woanders schon hundertfach inklusive Erklärung steht. Und es nährt ein wenig den Verdacht du verbastelst nur irgendwelche Beispiele von anderen statt selber zu Programmieren.

[/me]

so gut jetzt seid Ihr dran. gebt mir bitte den entscheidenen Hinweis was es mit dieser globalen namensdefinierung aufsich hat. und wie das dann in meinem fall aussehen müsste. damit es zu keinem Error kommt.

Nehmen wir mal folgenden Code:

Code: Alles auswählen

foo = 23
bar = 42
result = 0

def add_numbers():
    result = foo + bar

add_numbers()
print(result)

Du würdest als Ausgabe vermutlich 65 erwarten. Ausgegeben wird aber 0. Warum? Das result in der Funktion ist ein anderes, als das result auf der oberen Ebene. Jetzt kann man Herumpfuschen und das result in der Funktion als global deklarieren. Das will man aber gar nicht tun, da man damit im Lauf der Zeit völlig die Kontrolle über den Zugriff auf seine Werte verliert. Stattdessen gibt man den Wert einfach zurück.

Code: Alles auswählen

foo = 23
bar = 42

def add_numbers():
    return foo + bar

result = add_numbers()
print(result)

Was ist jetzt, wenn ich das ganze mit einem anderen Wert für foo aufrufen möchte? In dem Fall müsste ich das globale foo ändern und hätte dann gegebenenfalls Seiteneffekte in anderen Funktionen die auch diesen globalen Wert verwenden. Aus diesem Grund übergibt man in einer Funktion verwendete Werte als Parameter.

Code: Alles auswählen

foo = 23
bar = 42

def add_numbers(first_value, second_value):
    return first_value + second_value

result = add_numbers(foo, bar)
print(result)

Damit haben wir eine deutlich flexiblere Funktion die nicht mehr von hoffentlich korrekt gesetzten globalen Werten abhängt. Man könnte daraus sogar ein Modul machen und diese Funktion dann in anderen Skripten verwenden. Störend ist dann nur noch, dass bei einem Import des Moduls auch noch der andere Code auf der globalen Ebene ausgeführt wird. Daher stellt man sicher, dass Code nur dann ausgeführt wird, wenn das Skript direkt aufgerufen wird. Ist das der Fall, dann wird der magische Bezeichner __name__ auf den Wert "__main__" gesetzt. Das kann man prima ausnutzen.

Code: Alles auswählen

def add_numbers(first_value, second_value):
    return first_value + second_value

def main():
    foo = 23
    bar = 42
    result = add_numbers(foo, bar)
    print(result)

if __name__ == '__main__':
    main()

Wenn du das jetzt aufrufst bekommst du als Ausgabe deine 65.

Wäre dieser Code jetzt in einer Datei namens calculations.py untergebracht, dann könntest du aus einer anderen Datei heraus die Funktion add_numbers verwenden.

Code: Alles auswählen

import calculations

def get_median(value1, value2):
    return calculations.add_numbers(value1, value2) / 2

def main():
    print(get_median(10, 20))

if __name__ == '__main__':
    main()

Damit haben wir unter Einbeziehung des bestehenden Codes neue Funktionalität geschaffen.

[Zappelmann]

So erstmal danke für diese ausführliche Erklärung.

Ich werde das heute Abend anwenden und etwas testen. Wenn ich es dann richtig begriffen habe melde ich mich wieder bei Euch.
Und Sorry wenn ich hier ein wenig planlos ins Forum gestolppert bin.

Und es nährt ein wenig den Verdacht du verbastelst nur irgendwelche Beispiele von anderen statt selber zu Programmieren.

Um deine Skepsis ein wenig zu besänftigen,
Vor ca. 1 Monat habe ich mir den Raspberry Pi zugelegt, da es für mich als Modellbastler eine willkommene Abwechslung ist, statt immer nur an irgendwelchen Modellen LED Schaltungen zu realisieren (ohne Computer oder Software). Programmieren hat mich bis dato nie wirklich interessiert. Jedoch habe ich den Raspi als Entwicklungsboard mit sehr viel Potential angesehen und hab mich direkt daran gemacht, ein paar Sachen damit auszuprobieren. z.B. mit nem I2C IC MCP23017 LED´s zu steuern. Dies war relativ einfach da es auch sehr gut dokumentiert ist. Nun, der Lerneffekt hat in dem Moment auch schon angefangen und ich hab recht schnell das Interesse an der Python Sprache gefunden und versuche mich daher auch damit auseinander zu setzen. Damit ich aber nicht nur Stumpf irgendwelche Tutorials abtippse die für mich keinen Sinn ergeben und ich dabei nicht die komplexität des Programmierens lernen würde, musste halt ein Projekt her, dass mich in dieser Hinsicht etwas mehr fordert. Da viel mir wieder ein das ich vor einigen Jahren schon mal das Interesse hatte einen Roboter zu bauen. Jedoch gab es zu der Zeit wenig Möglichkeiten die Technik in einem verständlichen Rahmen in dieser Größe einzusetzen. Raspi = Chipkartengroß. Nachdem ich ein wenig Recherche geführt habe bin ich auf ein paar interesante Videos gestoßen, die mir einen Einstieg in die Materie vermitteln konnten. Somit hab ich mein damaliges Interesse wieder neu entflammt und damit begonnen Material für so ein kleinen fahrbaren Roboter zu besorgen. Hardwaretechnisch kann ich mit sowas eigentlich recht gut umgehen also war das Material schnell bestellt und auch bald sinnvoll zusammengebaut um dem Gerät später einiges abzuverlangen was ich mir vorstellte, was er mal alles können soll. Was mir also jetzt fehlte war das Wissen wie man sowas Softwaretechnisch dann auch umsetzt. Nach viel Recherche und einigen Forumseinträgen hat mir jemand eine Beispielvorlage gesendet um überhaupt mal zu sehen wie sowas programmiertechnisch aufgebaut ist. Dies habe ich tagelang analysiert und habe viel gelesen. Hab mit dem Code herum experimentiert und dann angefangen auf der Basis dieser Vorlage ein eigenes Script zu schreiben.
Da vieles auf anhieb nicht so funktionierte wie ich dachte dass es gehen sollte, hab ich noch mehr gelesen und dabei festgestellt das in vielen Codes wo es um die GPIO´s des Raspberrys geht immer wieder (mitlerweile leichtverständlich) die selben Codezeilen auftauchten. Nach und nach begriff ich wie die Zusammenhänge dabei waren was es mit den Libarys aufsich hat usw...
Na ja ich fing also an das ganze etwas ernster zu nehmen und setzte mich hin und schrieb ein Code der natürlich auf der Basis von vielen Beispielen herauskam und fing dabei an zu lernen wie was funktioniert. Wie eine Schleife arbeitet usw... teilweise immer noch confussed für mich.^^ Na ja aber bis gestern hatte ich einfach nur wild herumgescriptet. Bis mir jemand den Tip gab die Module der übersichtshalber mal einzeln zu definieren und dann in eine Schleife zu packen. Dies tat ich dann bis tief in die Nacht und siehe da das Ergebnis war übersichtlicher als vorher und die Zusammenhänge in der Schleife waren einfacher für mich zu verstehen als vorher. Jedoch bin ich dann halt auf diese Globale Namens Definition gestoßen als der halt beim ersten Aufruf des Scriptes ein Error produzierte, womit ich bis jetzt nichts anfangen konnte. Ich hab heute wieder in nem Buch gelesen aber bin noch nicht so richtig schlau daraus geworden. Daher kam mir halt der Gedanke hier bei den Profis nachzufragen wie das funzt.....

So die einen meinen der bastelt doch eh nur irgendwelche Schnippsel ohne SINN und VERSTAND zusammen die anderen werden aber hoffentlich auch sagen ja ok der versucht sich mit der Materie zu gut wie möglich auseinander zu setzen und hat auch nen Lerneffekt dabei um für spätere Projekte gewisse Erfahrungen gesammelt zu haben wie man in Python programmiert.

Ich für mein Teil suche immer wieder neue Herausforderungen und lern etwas dabei was ich später immer wieder einsetzen kann weil ich es dann auch begriffen habe, als wie nur irgendwas zusammen zu kopieren wie einige andere es wohl machen.


Ich werde das von /me angefertigte kleine Beispiel jetzt mal genauer mir anschauen und ein wenig damit herumexperimentieren um zu erfahren wie man es einsetzt. Und ich denke mal das ich das bis zum anfang der nächsten Woche gerafft haben sollte und dann hoffentlich weis wie man globale Namen in Funktionen definiert oder setzt.

in diesem Sinn wünsche ich Euch noch einen ruhigen Abend.

Ach ja noch eine Kleinigkeit am Rande als ich heute nach Hause kam hab ich weiter an dem Script für meinen kleinen Robofreund gearbeitet und kann jetzt sagen das er jetzt ziemlich gut funktioniert, in dem was ich mit dem Script bisher erreichen wollte.
Im Moment geht es sich darum den Code klein, geordnet und übersichtlich zu bekommen.

Ich werde später mal ein paar Video machen um mal die einzelnen Forschritte zu dokumentieren. Denn dann kann man den Lerneffekt auch mal nachvollziehen den ich dabei gewonnen hatte. Raspi = Entwicklerboard nicht kopierboard^^


MFG

Zappelmann

Danke "/me" für deine Hilfe melde mich wieder......

[EyDu]

Ich für mein Teil suche immer wieder neue Herausforderungen und lern etwas dabei was ich später immer wieder einsetzen kann weil ich es dann auch begriffen habe, als wie nur irgendwas zusammen zu kopieren wie einige andere es wohl machen.

Das ist im Prinzip auch richtig so, aber du solltest nicht einen Schritt vor dem anderen machen. Du bist an einem Punkt angelangt, bei dem du dich intenstiv mit Python beschäftigen musst. D.h. du musst systematisch Tutorials durcharbeiten und dich mit der Standardbibliothek beschäftigen. Das mag am Anfang zwar nervig sein, aber das was du gerade betreibst ist furchtbar ineffizient. Es ist jetzt schon offensichtlich, dass dir eben (noch) absolute Grundlagen fehlen. Wenn du das nicht systematisch angehst, dann wirst du früher oder später an deiner Aufgabe vollkommen frustrieren, da du unnötig viel Code schreibst und dir die (unnötige) Komplexität vollkommen über den Kopf wächst. Du wirst nicht mehr durch deinen eigenen Code durchsteigen und helfen will/kann dir auch keiner mehr, weil der Code zu viel zu schlecht und voll von den selben alten Fehlern ist.

Wenn du etwas programmieren willst, dann musst du dich auch mit dessen Grundlagen beschäftigen, sonst wird das nichts. Die Grenzen sind leider schon sehr früh erreicht, ohne vernünftige Einarbeitung wirst du nicht über die Komplexität von Beispielprogrammen hinauskommen.

Ich werde das von /me angefertigte kleine Beispiel jetzt mal genauer mir anschauen und ein wenig damit herumexperimentieren um zu erfahren wie man es einsetzt. Und ich denke mal das ich das bis zum anfang der nächsten Woche gerafft haben sollte und dann hoffentlich weis wie man globale Namen in Funktionen definiert oder setzt.

Genau das hat /me dir gerade nicht gezeigt. Er hat ein Beispiel gegeben, wie man das Problem vernünftig löst. Vergiss einfach das konzept von globalen Variablen, die sind nur in extrem wenigen Fällen sinnvoll.

Ich werde später mal ein paar Video machen um mal die einzelnen Forschritte zu dokumentieren.

Finde ich gut, das wäre interessant!

[/me]

Und ich denke mal das ich das bis zum anfang der nächsten Woche gerafft haben sollte und dann hoffentlich weis wie man globale Namen in Funktionen definiert oder setzt.

Nein, nein, nein. Es geht darum eben keine globalen Variablen zu verwenden.

Du brauchst dringend Grundlagen, sonst ist ein Erklären von sinnvollen Konzepten quasi nicht möglich. Das offizielle Tutorial kennst du?

[Hyperion]

@me: Dein Beispiel ist wirklich gelungen!

(Hätte man ein Wiki, sollte man das da rein packen )

[Zappelmann]

nein bisher kannte ich die Seite nicht aber ich werde mich da mal durchwühlen
also das Beispiel ok hab gerafft das es dabei nicht um die globalen Variablen geht aber wenn ich das richtig verstanden habe soll ich Module bzw. Funktionen auslagern in andere Dateien und diese dann gezielt im Programmablauf einbinden ?

ist das richtig ? bzw ist es in python üblich das man mehrere Dateien für ein Programm in der Größe erstellt ? ich mein im grunde genommen ist es ja ein kleines Script.

ich werde dann mal mich diese Woche mit der Seite beschäftigen.

danke für den Tipp

MFG

Zappelmann

[BlackJack]

@Zappelmann: Module sind in Python Dateien. Beziehunsgweise umgekehrt: Was in einem Modulobjekt steckt, wird normalerweise durch eine Python-Quelltextdatei definiert.

Es geht hier jetzt erst einmal nur um Funktionen. Der bereits vorhandene Code sollte sich damit vereinfachen lassen in dem man nicht sehr ähnlichen Quelltext immer wieder hinschreibt, sondern Funktionen schreibt die die Unterschiede als Argumente übergeben bekommen.

[Zappelmann]

So nachdem ich mir einige Grundlagen Tutorials reingezogen habe, ich hab genau das gefunden was ich gesucht hatte.
Das hättet ihr aber auch direkt schreiben können das es so einfach ist ^^. Aber gut ich hab Euch verstanden das mir Grundlagen fehlen und ich diese für eine sinnvolle und sauber Programmierung unerlässlich sind. Jedoch hab ich das Script um 50% einkürzen können. Ich weis das ist jetzt noch immer nicht nach Euren Vorstellungen nach guten sauberen Code aber gebt mir noch ein wenig Zeit oder auch ein paar Hinweise wo man es dann noch weiter reduzieren kann. Auf manche Sachen kann ich bisher nicht versichten wie z.B. die Servo Stellungen und die Messungen da diese alle unterschiedlich sind und auch entsprechend benötigt werden. Ich bin mir sicher das Ihr der Meinung seid das es noch einfacher zu schreiben ist. So hier nochmal der bisher überarbeitete Code.


wie alles anfing: https://www.youtube.com/watch?v=oAjxtVcyods
langsam wird er autonom: https://www.youtube.com/watch?v=hN7qRw3E0Gk

Weitere Videos sind in Bearbeitung und werden in Kürze folgen.

Ich bin natürlich weiterhin für konstruktive Kritik offen.

Code: Alles auswählen

#!/usr/bin/python

from time import sleep
import time
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(19,GPIO.OUT)
GPIO.setup(7,GPIO.OUT)
GPIO.setup(22,GPIO.OUT)
GPIO.setup(11,GPIO.OUT)
GPIO.setup(26,GPIO.OUT)
GPIO.setup(12,GPIO.OUT)
GPIO.setup(16,GPIO.IN)

print "Ultraschallmessung mit HC-SR04"

#A routine to control a pair of pins

def ControlAPairOfPins(FirstPin,FirstState,SecondPin,SecondState):
  if FirstState == "1":
    GPIO.output(int(FirstPin),True)
  else:
    GPIO.output(int(FirstPin),False)
  if SecondState == "1":
    GPIO.output(int(SecondPin),True)
  else:
    GPIO.output(int(SecondPin),False)
  return

def Stop():
    ControlAPairOfPins("19","0","7","0")
    ControlAPairOfPins("22","0","11","0")

def Stop_anhalten_permanent():
    ControlAPairOfPins("19","0","7","0")
    ControlAPairOfPins("22","0","11","0")

def Vorwaerts_fahren():
    ControlAPairOfPins("19","1","7","0")
    ControlAPairOfPins("22","1","11","1")
	
def Geradeaus_vorwaerts_start():
    ControlAPairOfPins("19","1","7","0")
    ControlAPairOfPins("22","1","11","1")
	
def Links_fahren():
    ControlAPairOfPins("19","1","7","0")
    ControlAPairOfPins("22","0","11","1")
    time.sleep(1.5)
	
def Rechts_fahren():
    ControlAPairOfPins("19","1","7","1")
    ControlAPairOfPins("22","1","11","1")
    time.sleep(1.5)

def Rueckwaerts_fahren():
    ControlAPairOfPins("19","1","7","1")
    ControlAPairOfPins("22","0","11","1")
    time.sleep(1.0)

def Rueckwaerts_fahren_l():
    ControlAPairOfPins("19","1","7","1")
    ControlAPairOfPins("22","0","11","1")
    time.sleep(0.5)

def Rueckwaerts_fahren_r():
    ControlAPairOfPins("19","1","7","1")
    ControlAPairOfPins("22","0","11","1")
    time.sleep(0.5)
		
def Servo_permanent_vorn():
    p = GPIO.PWM(26,50)
    p.start(5.5)
    p.ChangeDutyCycle(5.5)
    time.sleep(True)
    p.stop(5.5)

def Servo_permanent_links():
    p = GPIO.PWM(26,50)
    p.start(5.5)
    p.ChangeDutyCycle(8.5)
    time.sleep(0.2)
    p.stop(8.5)

def Servo_permanent_rechts():
    p = GPIO.PWM(26,50)
    p.start(8.5)
    p.ChangeDutyCycle(3.5)
    time.sleep(0.2)
    p.stop(3.5)

def Servo_permanent_mitte():
    p = GPIO.PWM(26,50)
    p.start(3.5)
    p.ChangeDutyCycle(5.5)
    time.sleep(0.2)
    p.stop(5.5)

def Servo_anfang_mitte():
    p = GPIO.PWM(26,50)
    p.start(5.5)
    p.ChangeDutyCycle(5.5)
    time.sleep(0.1)
    p.stop(5.5)

def Servo_links():
    p = GPIO.PWM(26,50)
    p.start(5.5)
    p.ChangeDutyCycle(10.5)
    time.sleep(0.3)
    p.stop(10.5)

def Servo_rechts():
    p = GPIO.PWM(26,50)
    p.start(10.5)
    p.ChangeDutyCycle(1)
    time.sleep(0.3)
    p.stop(1)

def Servo_mitte():
    p = GPIO.PWM(26,50)
    p.start(1)
    p.ChangeDutyCycle(5.5)
    time.sleep(0.2)
    p.stop(5.5)

def Messung_permanent_vorn():
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
        pass
    start = time.time()
    while GPIO.input(16)==1:
        pass
    stop = time.time()
    elapsed = stop-start
    global dist_vorn_perma
    dist_vorn_perma = elapsed * 17500
    print "Abstand_vorn: %.1f cm" % dist_vorn_perma

def Messung_permanent_links():
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
        pass
    start = time.time()
    while GPIO.input(16)==1:
        pass
    stop = time.time()
    elapsed = stop-start
    global dist_links_perma
    dist_links_perma = elapsed * 17000
    print "Abstand_links: %.1f cm" % dist_links_perma

def Messung_permanent_rechts():
    GPIO.output(12, False)
    time.sleep(0.1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
        pass
    start = time.time()
    while GPIO.input(16)==1:
        pass
    stop = time.time()
    elapsed = stop-start
    global dist_rechts_perma
    dist_rechts_perma = elapsed * 17000
    print "Abstand_rechts: %.1f cm" % dist_rechts_perma

def Messung_distance_vorn():
    GPIO.output(12, False)
    time.sleep(0.5)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
        pass
    start = time.time()
    while GPIO.input(16)==1:
        pass
    stop = time.time()
    elapsed = stop-start
    global distance
    distance = elapsed * 17500
    print "Abstand_vorn: %.1f cm" % distance

def Messung_dist_links():
    GPIO.output(12, False)
    time.sleep(1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
        pass
    start = time.time()
    while GPIO.input(16)==1:
        pass
    stop = time.time()
    elapsed = stop-start
    global dist_links
    dist_links = elapsed * 17000
    print "Abstand_links: %.1f cm" % dist_links

def Messung_dist_rechts():
    GPIO.output(12, False)
    time.sleep(1)
    GPIO.output(12, True)
    time.sleep(0.00001)
    start = time.time()
    GPIO.output(12, False)
    while GPIO.input(16)==0:
        pass
    start = time.time()
    while GPIO.input(16)==1:
        pass
    stop = time.time()
    elapsed = stop-start
    global dist_rechts              #Das es so einfach ist hätte man aber auch schreiben können!^^
    dist_rechts = elapsed * 17000
    print "Abstand_rechts: %.1f cm" % dist_rechts

	
while True:
    Servo_anfang_mitte()
    Vorwaerts_fahren()
    Messung_permanent_vorn()
    if dist_vorn_perma < 25:
        Stop_anhalten_permanent()
        print "STOP_VORN"
        Rueckwaerts_fahren()
        Stop()
        Servo_links()
        Messung_dist_links()
        Servo_rechts()
        Messung_dist_rechts()
        Servo_permanent_mitte()
        if dist_links > dist_rechts:
            Rueckwaerts_fahren_l()
            Links_fahren()
        else:
            Rueckwaerts_fahren_r()
            Rechts_fahren()
    else:
        Geradeaus_vorwaerts_start()
    Servo_permanent_links()
    Messung_permanent_links()
    if dist_links_perma < 12:
        Stop_anhalten_permanent()
        print "STOP_LINKS"
        Rueckwaerts_fahren()
        Stop()
        Servo_rechts()
        Messung_dist_rechts()        
        Servo_links()
        Messung_dist_links()
        Servo_permanent_mitte()
        if dist_rechts > dist_links:
            Rueckwaerts_fahren_l()
            Links_fahren()
        else:
            Rueckwaerts_fahren_r()
            Rechts_fahren()
    else:
        Geradeaus_vorwaerts_start()
    Servo_permanent_rechts()
    Messung_permanent_rechts()
    if dist_rechts_perma < 12:
        Stop_anhalten_permanent()
        print "STOP_RECHTS"
        Rueckwaerts_fahren()
        Stop()
        Servo_links()		
        Messung_dist_links()
        Servo_rechts()
        Messung_dist_rechts()
        Servo_permanent_mitte()
        if dist_links > dist_rechts:
            Rueckwaerts_fahren_l()
            Links_fahren()
        else:
            Rueckwaerts_fahren_r()
            Rechts_fahren()
    else:
        Geradeaus_vorwaerts_start()

MFG

Zappelmann

[Zappelmann]

Ach ja da fällt mit gerade etwas ein was mich die ganzen Tage schon beschäftigt hat. Ich weis das man ein GPIO als Input definieren kann. Ich würde gern 2 Taster einsetzen. Einem zum starten der Software und einem zum stoppen der Software. Vielleicht könnt Ihr mir dazu ein Hinweis geben, wo man sowas am besten einfügt.
Im Grunde genommen möchte ich damit erreichen das der beim druck auf einem Taster das Programm an jeder Stelle sofort anhält und sämtliche GPIO Aktivitäten einstellt. Und beim Starten das das Programm natürlich von vorn abläuft.

Ich hoffe das Ihr mir da ein Tipp geben könnt.

In der Zwischenzeit werde ich weiter die Tutorialseiten wälzen um mein Wissen zu vertiefen.

MFG

Zappelmann