Fernsteuerung mit Flask Problem

Django, Flask, Bottle, WSGI, CGI…
ice2711
User
Beiträge: 3
Registriert: Montag 29. Mai 2017, 09:02

Fernsteuerung mit Flask Problem

Beitragvon ice2711 » Montag 29. Mai 2017, 09:20

Hallo,
Ich habe mir ein Fahrzeug gebaut das ich gern über ein Smartphone steuern wollte. Im Fahrzeug ist ein Raspberry verbaut das ein WLAN-AP aufbaut damit ich mich mit dem Smartphone verbinden kann und hier eine HTML-Seite zur Steuerung aufrufen kann. Zum einen wollte ich über Schaltflächen Steuerungsbefehle manuell weitergeben, das funktioniert auch alles problemlos. Als nächstes wollte ich eine automatische Steuerung realisieren bei der das Fehrzeug über zwei Ultraschallsensoren Hinternisse erkennt und automatisch ausweicht. Die automatische Steuerung funktioniert auch soweit gut. Aber ich wollte gern über die HTML-Seite über das Smartphone die automatische Steuerung ein und ausschalten, das funktioniert leider nicht. Wahrscheinlich liegt es daran dass in main_automatik eine Schleife intergriert ist. Gibt es eine Möglichkeit diese Schleife irgendwie über die HTML-Seite zu unterbrechen? Oder hat jemand vielleicht eine andere Idee? Ich hoffe ich konnte mein Problem einigermaßen verständlich erklären. Für jede Hilfe bin ich sehr dankbar.
Hier mein Python-Skript:
  1. # Import Module
  2. import time
  3. import RPi.GPIO as GPIO
  4. from flask import Flask, request, redirect, render_template
  5. from multiprocessing import Process
  6.  
  7. # Variablen definieren
  8. app = Flask(__name__)
  9. global varhit
  10.  
  11. # Pins definieren
  12. GPIOgruen = 18 # LED gruen
  13. GPIOgelb = 23 # LED gelb
  14. GPIOrot = 24 # LED rot
  15. GPIOecho_re = 25 # Echo Pin am Ultraschallsensor rechts
  16. GPIOtrig_re = 12 # Trigger Pin am Ultraschallsensor rechts
  17. GPIOecho_li = 20 # Echo Pin am Ultraschallsensor links
  18. GPIOtrig_li = 16 # Trigger Pin am Ultraschallsensor links
  19. GPIOmotor1en1 = 4 # Motor 1 enable
  20. GPIOmotor1in1 = 17 # Motor 1 input1
  21. GPIOmotor1in2 = 27 # Motor 1 input2
  22. GPIOmotor2en2 = 5 # Motor 2 enable
  23. GPIOmotor2in3 = 6 # Motor 2 input3
  24. GPIOmotor2in4 = 13 # Motor 2 input4
  25.  
  26. # GPIO Modus festlegen
  27. GPIO.setmode(GPIO.BCM) # Modus BCM festgelegt
  28. GPIO.setwarnings(False) # GPIO Warnungen deaktiviert
  29.  
  30. # Pins IN und OUT festlegen
  31. GPIO.setup(GPIOgruen, GPIO.OUT)
  32. GPIO.setup(GPIOgelb, GPIO.OUT)
  33. GPIO.setup(GPIOrot, GPIO.OUT)
  34. GPIO.setup(GPIOecho_re, GPIO.IN)
  35. GPIO.setup(GPIOtrig_re, GPIO.OUT)
  36. GPIO.setup(GPIOecho_li, GPIO.IN)
  37. GPIO.setup(GPIOtrig_li, GPIO.OUT)
  38. GPIO.setup(GPIOmotor1en1, GPIO.OUT)
  39. GPIO.setup(GPIOmotor1in1, GPIO.OUT)
  40. GPIO.setup(GPIOmotor1in2, GPIO.OUT)
  41. GPIO.setup(GPIOmotor2en2, GPIO.OUT)
  42. GPIO.setup(GPIOmotor2in3, GPIO.OUT)
  43. GPIO.setup(GPIOmotor2in4, GPIO.OUT)
  44.  
  45. # Pins zuruecksetzen
  46. GPIO.output(GPIOgruen, False)
  47. GPIO.output(GPIOgelb, False)
  48. GPIO.output(GPIOrot, False)
  49. GPIO.output(GPIOtrig_re, False)
  50. GPIO.output(GPIOtrig_li, False)
  51. GPIO.output(GPIOmotor1en1, False)
  52. GPIO.output(GPIOmotor1in1, False)
  53. GPIO.output(GPIOmotor1in2, False)
  54. GPIO.output(GPIOmotor2en2, False)
  55. GPIO.output(GPIOmotor2in3, False)
  56. GPIO.output(GPIOmotor2in4, False)
  57.  
  58. def led_start():
  59.     GPIO.output(GPIOrot, True)
  60.     time.sleep (1.0)
  61.     GPIO.output(GPIOgelb, True)
  62.     time.sleep (1.0)
  63.     GPIO.output(GPIOgruen, True)
  64.     time.sleep (1.0)
  65.     GPIO.output(GPIOgelb, False)
  66.     GPIO.output(GPIOrot, False)
  67.  
  68. def led_gruen():
  69.     GPIO.output(GPIOrot, False)
  70.     GPIO.output(GPIOgelb, False)
  71.     GPIO.output(GPIOgruen, True)
  72.  
  73. def led_gelb():
  74.     GPIO.output(GPIOrot, False)
  75.     GPIO.output(GPIOgelb, True)
  76.     GPIO.output(GPIOgruen, False)
  77.  
  78. def led_rot():
  79.     GPIO.output(GPIOrot, True)
  80.     GPIO.output(GPIOgelb, False)
  81.     GPIO.output(GPIOgruen, False)
  82.  
  83. def measure_distance_re():
  84.     GPIO.output(GPIOtrig_re, True) # High Signal auf Trigger geben
  85.     time.sleep(0.00001)
  86.     GPIO.output(GPIOtrig_re, False) # Low Signal auf Trigger geben
  87.     start_time = time.time() # Initialisiere Zeit
  88.     while GPIO.input(GPIOecho_re) == 0: # Solange Echo low ist
  89.         start_time = time.time() # Zeit wird in Variable start_time geschrieben
  90.     while GPIO.input(GPIOecho_re) == 1: # Solange Echo high ist
  91.         stop_time = time.time() # Zeit wird in Variable stop_time geschrieben
  92.     # Entfernung berechnen
  93.     time_elapsed = stop_time - start_time # start_time wird von stop_time abgezogen
  94.     distance_re = (time_elapsed * 34300) / 2 # Berechnung der Distanz in cm
  95.     return distance_re # Gibt das Ergebnis zurueck
  96.  
  97. def measure_distance_li():
  98.     GPIO.output(GPIOtrig_li, True) # High Signal auf Trigger geben
  99.     time.sleep(0.00001)
  100.     GPIO.output(GPIOtrig_li, False) # Low Signal auf Trigger geben
  101.     start_time = time.time() # Initialisiere Zeit
  102.     while GPIO.input(GPIOecho_li) == 0: # Solange Echo low ist
  103.         start_time = time.time() # Zeit wird in Variable start_time geschrieben
  104.     while GPIO.input(GPIOecho_li) == 1: # Solange Echo high ist
  105.         stop_time = time.time() # Zeit wird in Variable stop_time geschrieben
  106.     # Entfernung berechnen
  107.     time_elapsed = stop_time - start_time # start_time wird von stop_time abgezogen
  108.     distance_li = (time_elapsed * 34300) / 2 # Berechnung der Distanz in cm
  109.     return distance_li # Gibt das Ergebnis zurueck
  110.  
  111. def move_stop():
  112.     # Motor1
  113.     GPIO.output(GPIOmotor1en1, False)
  114.     GPIO.output(GPIOmotor1in1, False)
  115.     GPIO.output(GPIOmotor1in2, False)
  116.     # Motor2
  117.     GPIO.output(GPIOmotor2en2, False)
  118.     GPIO.output(GPIOmotor2in3, False)
  119.     GPIO.output(GPIOmotor2in4, False)
  120.  
  121. def move_forward():
  122.     # Motor1
  123.     GPIO.output(GPIOmotor1en1, True)
  124.     GPIO.output(GPIOmotor1in1, True)
  125.     GPIO.output(GPIOmotor1in2, False)
  126.     # Motor2
  127.     GPIO.output(GPIOmotor2en2, True)
  128.     GPIO.output(GPIOmotor2in3, True)
  129.     GPIO.output(GPIOmotor2in4, False)
  130.  
  131. def move_backward():
  132.     # Motor1
  133.     GPIO.output(GPIOmotor1en1, True)
  134.     GPIO.output(GPIOmotor1in1, False)
  135.     GPIO.output(GPIOmotor1in2, True)
  136.     # Motor2
  137.     GPIO.output(GPIOmotor2en2, True)
  138.     GPIO.output(GPIOmotor2in3, False)
  139.     GPIO.output(GPIOmotor2in4, True)
  140.  
  141. def move_left():
  142.     # Motor1
  143.     GPIO.output(GPIOmotor1en1, True)
  144.     GPIO.output(GPIOmotor1in1, False)
  145.     GPIO.output(GPIOmotor1in2, True)
  146.     # Motor2
  147.     GPIO.output(GPIOmotor2en2, True)
  148.     GPIO.output(GPIOmotor2in3, True)
  149.     GPIO.output(GPIOmotor2in4, False)
  150.  
  151. def move_right():
  152.     # Motor1
  153.     GPIO.output(GPIOmotor1en1, True)
  154.     GPIO.output(GPIOmotor1in1, True)
  155.     GPIO.output(GPIOmotor1in2, False)
  156.     # Motor2
  157.     GPIO.output(GPIOmotor2en2, True)
  158.     GPIO.output(GPIOmotor2in3, False)
  159.     GPIO.output(GPIOmotor2in4, True)
  160.  
  161. def turn_left():
  162.     led_rot()
  163.     move_stop()
  164.     time.sleep(0.5)
  165.     move_backward()
  166.     time.sleep(2.0)
  167.     move_stop()
  168.     time.sleep(0.5)
  169.     move_left()
  170.     time.sleep(1.2)
  171.     move_stop()
  172.     time.sleep(0.5)
  173.  
  174. def turn_right():
  175.     led_rot()
  176.     move_stop()
  177.     time.sleep(0.5)
  178.     move_backward()
  179.     time.sleep(2.0)
  180.     move_stop()
  181.     time.sleep(0.5)
  182.     move_right()
  183.     time.sleep(1.2)
  184.     move_stop()
  185.     time.sleep(0.5)
  186.    
  187. def main_automatik(): # Funktion automatische Steuerung
  188.     try:
  189.         while True:
  190.             distance_re = measure_distance_re() # Fuehrt die Funktion measure_distance_re aus und uebernimmt Ergebnis
  191.             print "Entfernung rechts = %.2f cm" % distance_re
  192.             distance_li = measure_distance_li() # Fuehrt die Funktion measure_distance_li aus und uebernimmt Ergebnis
  193.             print "Entfernung links = %.2f cm" % distance_li
  194.             time.sleep(0.2)
  195.             if distance_re < 30.00 or distance_li < 30.00:
  196.                 if distance_re < 30.00:
  197.                     turn_left()
  198.                 if distance_li < 30.00:
  199.                     turn_right()
  200.             elif distance_re < 40.00 or distance_li < 40.00:
  201.                 led_gelb()
  202.             else:
  203.                 led_gruen()
  204.                 move_forward()
  205.     except KeyboardInterrupt: # Unterbricht bei Eingabe von Strg + c
  206.         print "Messung gestoppt"
  207.         GPIO.cleanup()
  208.  
  209.  
  210. @app.route('/')
  211. def index():
  212.     return render_template('index.html')
  213.  
  214. @app.route('/controlit', methods = ['POST'])
  215. def main_manuell(): # Funktion manuelle Steuerung
  216.     button_hit = request.form['buttonPress']
  217.     global varhit
  218.     varhit = button_hit
  219.     if button_hit == 'Vorwaerts':
  220.         print "Vorward"
  221.         move_stop()
  222.         time.sleep(0.5)
  223.         move_forward()
  224.     if button_hit == 'Zurueck':
  225.         print "Back"
  226.         move_stop()
  227.         time.sleep(0.5)
  228.         move_backward()
  229.     if button_hit == 'Links':
  230.         print "Left"
  231.         move_stop()
  232.         move_left()
  233.         time.sleep(0.5)
  234.         move_stop()
  235.     if button_hit == 'Rechts':
  236.         print "Right"
  237.         move_stop()
  238.         move_right()
  239.         time.sleep(0.5)
  240.         move_stop()
  241.     if button_hit == 'Stop':
  242.         print "Stop"
  243.         move_stop()
  244.     #if button_hit == 'Automatik':
  245.         #main_automatik
  246.     return redirect('/')
  247.        
  248. if __name__ == '__main__':
  249.     led_start()
  250.     app.run(host='0.0.0.0', port=5000, debug = True)
  251.     main_manuell()
Zuletzt geändert von BlackJack am Montag 29. Mai 2017, 09:35, insgesamt 1-mal geändert.
Grund: Quelltext in Python-Codebox-Tags gesetzt.
Sirius3
User
Beiträge: 5936
Registriert: Sonntag 21. Oktober 2012, 17:20

Re: Fernsteuerung mit Flask Problem

Beitragvon Sirius3 » Montag 29. Mai 2017, 10:57

@ice2711: kurze Antwort, du brauchst einen Thread in dem der Webserver läuft und eine Hauptschleife für die Steuerung Deines Fahrzeugs. Damit ist wichtig, dass nur in der Hauptschleife alle Pins angesteuert werden, der Webserver ist nur dazu da, bestimmte Befehle an die Hauptschleife zu senden. Das Senden findet am besten über eine Queue statt. "global" zu benutzen ist nie eine gute Idee und auf oberster Ebene sogar noch nutzlos. Die Motorensteuerung würde ich über eine passende Datenstruktur lösen und nicht durch Funktionsaufrufe. Damit bist Du dann flexibler, die einzelnen Bewegungen zusammenzuschalten. GPIO-Warnings auf False zu setzen ist immer eine schlechte Idee, weil die Warnungen Dir ja sagen, dass Du etwas falsch machst; dann solltest Du die Ursache beheben und sie nicht einfach ignorieren. Das cleanup in main_automatik ist dort an der falschen Stelle. Ein cleanup sollte immer am Ende des Programms stattfinden und nicht in einer Funktion und nicht nur, wenn man das Programm mit Ctrl+C abbricht.
Benutzeravatar
BlackJack
Moderator
Beiträge: 32499
Registriert: Dienstag 25. Januar 2005, 23:29
Wohnort: Berlin
Kontaktdaten:

Re: Fernsteuerung mit Flask Problem

Beitragvon BlackJack » Montag 29. Mai 2017, 11:10

@ice2711: Man müsste die Programmlogik von der Benutzerinteraktion trennen und die Programmlogik zum Beispiel per Thread nebenläufig ausführen. Mit all den Problemen die nebenläufige Programmierung so mit sich bringt. Also beispielsweise das Du die Interaktion der Threads thread-safe hinbekommen musst. Einfachste Variante ist Kommunikation zwischen den Threads mittels Queues.

Anmerkungen zum Quelltext:

`multiprocessing.Process` wird importiert, aber nicht verwendet. Wäre sowieso nicht die beste Wahl hier, denn man braucht ja nicht wirklich 100% parallele Ausfürhrung um meherere Kerne auszunutzen, sondern nur nebenläufige Ausführung von den verschiedenen Programmteilen, damit die sich nicht gegenseitig blockieren.

``global`` hat auf Modulebene keine Effekt, macht dort also keinen Sinn. Und in einem sauberen Programm haben globale Variablen sowieso nichts zu suchen. Weg damit. `varhit` wird zudem ja auch gar nicht wirklich benutzt.

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

Kommentare sollten dem Leser einen Mehrwert über den Code liefern und nicht einfach nur das wiederholen was dort offensichtlich schon als Code steht. Also ``# Import Module`` vor den Modulimporten ist sinnlos. Wer das ohne den Kommentar nicht versteht, dem wird auch der Kommentar nicht weiterhelfen. Faustregel: Kommentare beschreiben *warum* der Code das macht was er macht, denn *was* er macht, beschreibt der Code selbst bereits. Wenn das warum nicht klar ist, und man das im Code auch nicht besser ausdrücken kann, *dann* kann ein Kommentar hilfreich sein. Man sollte aber immer erst einmal schauen ob man den Code nicht verständlicher schreiben kann. Oft hilft eine passende Namenswahl für Werte und Funktionen weiter.

Wenn man beispielsweise Konstanten für Pins definiert, dann kann man das mit den Pins in einen Kommentar schreiben, oder man wählt die Namen so, dass man diesen Kommentar nicht braucht. Konstanten werden übrigens per Konvention KOMPLETT_IN_GROSSBUCHSTABEN geschrieben. Siehen auch den Style Guide for Python Code.

Der Aufruf von `main_manuell()` nach `app.run()` macht keinen Sinn. `app.run()` kehrt nicht zurück bis man das Programm beispielsweise mit Strg+C abbricht.

Statt die Warnungen mit `GPIO.setwarnings()` auszuschalten, sollte man die Probleme beseitigen die zu Warnungen führen. Meistens ist das sowieso nur, dass am Programmende nicht ordentlich aufgeräumt wird und deshalb beim nächsten Programmstart eine Warnung deswegen ausgegeben wird. Man will *auf jeden Fall* `GPIO.cleanup()` aufrufen. Das sollte als sehr weit oben in der Aufrufhierarchie und in einem ``finally``-Zweig stehen. Die Behandlung von Strg+C sollte auch auf oberster Ebene der Aufrufhierarchie stehen, sonst wird am Ende nicht alles abgebrochen was man damit abbrechen möchte.

Viele Funktionen enthalten nahezu den gleichen Code der sich nur durch ein paar Werte unterscheidet. Solche Codewiederholungen verletzen das DRY-Prinzip — Don't Repeat Yourself. Wenn man einen Fehler in solchen Code beheben muss, oder etwas ändern möchte, muss man das in jeder Kopie des Codes tun, und auch in jeder Kopie auf die gleiche Art und Weise. Das macht nicht nur unnötig mehr Arbeit, dabei besteht auch die Gefahr das man Fehler macht und die Kopien am Ende auseinanderlaufen.

Das Messen des Abstands ist der ”schwerste” Fall, weil hier wirklich viel Kode kopiert wurde. Da sollte man die Daten die sich bei den beiden Kopien unterscheiden heraus ziehen und beim Aufruf als Argumente übergeben.

Zwischenstand (ungetestet):
  1. #!/usr/bin/env python
  2. # coding: utf8
  3. from __future__ import absolute_import, division, print_function
  4. import time
  5. from RPi import GPIO
  6. from flask import Flask, request, redirect, render_template
  7.  
  8. app = Flask(__name__)
  9.  
  10. GREEN_LED_PIN = 18
  11. YELLOW_LED_PIN = 23
  12. RED_LED_PIN = 24
  13. RIGHT_ECHO_PIN = 25
  14. RIGHT_TRIGGER_PIN = 12
  15. LEFT_ECHO_PIN = 20
  16. LEFT_TRIGGER_PIN = 16
  17. MOTOR_A_ENABLE_PIN = 4
  18. MOTOR_A_INPUT_1_PIN = 17
  19. MOTOR_A_INPUT_2_PIN = 27
  20. MOTOR_B_ENABLE_PIN = 5
  21. MOTOR_B_INPUT_1_PIN = 6
  22. MOTOR_B_INPUT_2_PIN = 13
  23.  
  24.  
  25. def led_start():
  26.     GPIO.output(RED_LED_PIN, True)
  27.     time.sleep(1.0)
  28.     GPIO.output(YELLOW_LED_PIN, True)
  29.     time.sleep(1.0)
  30.     GPIO.output(GREEN_LED_PIN, True)
  31.     time.sleep(1.0)
  32.     GPIO.output(YELLOW_LED_PIN, False)
  33.     GPIO.output(RED_LED_PIN, False)
  34.  
  35.  
  36. def led_gruen():
  37.     GPIO.output(RED_LED_PIN, False)
  38.     GPIO.output(YELLOW_LED_PIN, False)
  39.     GPIO.output(GREEN_LED_PIN, True)
  40.  
  41.  
  42. def led_gelb():
  43.     GPIO.output(RED_LED_PIN, False)
  44.     GPIO.output(YELLOW_LED_PIN, True)
  45.     GPIO.output(GREEN_LED_PIN, False)
  46.  
  47.  
  48. def led_rot():
  49.     GPIO.output(RED_LED_PIN, True)
  50.     GPIO.output(YELLOW_LED_PIN, False)
  51.     GPIO.output(GREEN_LED_PIN, False)
  52.  
  53.  
  54. def measure_distance(trigger_pin, echo_pin):
  55.     GPIO.output(trigger_pin, True)
  56.     time.sleep(0.00001)
  57.     GPIO.output(trigger_pin, False)
  58.     start_time = time.time()
  59.     while not GPIO.input(echo_pin):
  60.         start_time = time.time()
  61.     while GPIO.input(echo_pin):
  62.         stop_time = time.time()
  63.     elapsed_time = stop_time - start_time
  64.     return (elapsed_time * 34300) / 2  # Berechnung der Distanz in cm
  65.  
  66.  
  67. def move_stop():
  68.     GPIO.output(MOTOR_A_ENABLE_PIN, False)
  69.     GPIO.output(MOTOR_A_INPUT_1_PIN, False)
  70.     GPIO.output(MOTOR_A_INPUT_2_PIN, False)
  71.  
  72.     GPIO.output(MOTOR_B_ENABLE_PIN, False)
  73.     GPIO.output(MOTOR_B_INPUT_1_PIN, False)
  74.     GPIO.output(MOTOR_B_INPUT_2_PIN, False)
  75.  
  76.  
  77. def move_forward():
  78.     GPIO.output(MOTOR_A_ENABLE_PIN, True)
  79.     GPIO.output(MOTOR_A_INPUT_1_PIN, True)
  80.     GPIO.output(MOTOR_A_INPUT_2_PIN, False)
  81.  
  82.     GPIO.output(MOTOR_B_ENABLE_PIN, True)
  83.     GPIO.output(MOTOR_B_INPUT_1_PIN, True)
  84.     GPIO.output(MOTOR_B_INPUT_2_PIN, False)
  85.  
  86.  
  87. def move_backward():
  88.     GPIO.output(MOTOR_A_ENABLE_PIN, True)
  89.     GPIO.output(MOTOR_A_INPUT_1_PIN, False)
  90.     GPIO.output(MOTOR_A_INPUT_2_PIN, True)
  91.  
  92.     GPIO.output(MOTOR_B_ENABLE_PIN, True)
  93.     GPIO.output(MOTOR_B_INPUT_1_PIN, False)
  94.     GPIO.output(MOTOR_B_INPUT_2_PIN, True)
  95.  
  96.  
  97. def move_left():
  98.     GPIO.output(MOTOR_A_ENABLE_PIN, True)
  99.     GPIO.output(MOTOR_A_INPUT_1_PIN, False)
  100.     GPIO.output(MOTOR_A_INPUT_2_PIN, True)
  101.  
  102.     GPIO.output(MOTOR_B_ENABLE_PIN, True)
  103.     GPIO.output(MOTOR_B_INPUT_1_PIN, True)
  104.     GPIO.output(MOTOR_B_INPUT_2_PIN, False)
  105.  
  106.  
  107. def move_right():
  108.     GPIO.output(MOTOR_A_ENABLE_PIN, True)
  109.     GPIO.output(MOTOR_A_INPUT_1_PIN, True)
  110.     GPIO.output(MOTOR_A_INPUT_2_PIN, False)
  111.  
  112.     GPIO.output(MOTOR_B_ENABLE_PIN, True)
  113.     GPIO.output(MOTOR_B_INPUT_1_PIN, False)
  114.     GPIO.output(MOTOR_B_INPUT_2_PIN, True)
  115.  
  116.  
  117. def turn_left():
  118.     led_rot()
  119.     move_stop()
  120.     time.sleep(0.5)
  121.     move_backward()
  122.     time.sleep(2.0)
  123.     move_stop()
  124.     time.sleep(0.5)
  125.     move_left()
  126.     time.sleep(1.2)
  127.     move_stop()
  128.     time.sleep(0.5)
  129.  
  130.  
  131. def turn_right():
  132.     led_rot()
  133.     move_stop()
  134.     time.sleep(0.5)
  135.     move_backward()
  136.     time.sleep(2.0)
  137.     move_stop()
  138.     time.sleep(0.5)
  139.     move_right()
  140.     time.sleep(1.2)
  141.     move_stop()
  142.     time.sleep(0.5)
  143.  
  144.  
  145. def main_automatik():
  146.     while True:
  147.         right_distance = measure_distance(RIGHT_TRIGGER_PIN, RIGHT_ECHO_PIN)
  148.         print('Entfernung rechts = {0:.2f} cm'.format(right_distance))
  149.         left_distance = measure_distance(LEFT_TRIGGER_PIN, LEFT_ECHO_PIN)
  150.         print('Entfernung links = {0:.2f} cm'.format(left_distance))
  151.         time.sleep(0.2)
  152.         if right_distance < 30.00 or left_distance < 30.00:
  153.             if right_distance < 30.00:
  154.                 turn_left()
  155.             if left_distance < 30.00:
  156.                 turn_right()
  157.         elif right_distance < 40.00 or left_distance < 40.00:
  158.             led_gelb()
  159.         else:
  160.             led_gruen()
  161.             move_forward()
  162.  
  163.  
  164. @app.route('/')
  165. def index():
  166.     return render_template('index.html')
  167.  
  168.  
  169. @app.route('/controlit', methods=['POST'])
  170. def main_manuell():
  171.     button_hit = request.form['buttonPress']
  172.     if button_hit == 'Vorwaerts':
  173.         print('Forward')
  174.         move_stop()
  175.         time.sleep(0.5)
  176.         move_forward()
  177.     if button_hit == 'Zurueck':
  178.         print('Back')
  179.         move_stop()
  180.         time.sleep(0.5)
  181.         move_backward()
  182.     if button_hit == 'Links':
  183.         print('Left')
  184.         move_stop()
  185.         move_left()
  186.         time.sleep(0.5)
  187.         move_stop()
  188.     if button_hit == 'Rechts':
  189.         print('Right')
  190.         move_stop()
  191.         move_right()
  192.         time.sleep(0.5)
  193.         move_stop()
  194.     if button_hit == 'Stop':
  195.         print('Stop')
  196.         move_stop()
  197.     return redirect('/')
  198.  
  199.  
  200. def main():
  201.     try:
  202.         GPIO.setmode(GPIO.BCM)
  203.  
  204.         GPIO.setup(
  205.             [GREEN_LED_PIN, YELLOW_LED_PIN, RED_LED_PIN],
  206.             GPIO.OUT,
  207.             initial=False,
  208.         )
  209.         GPIO.setup(RIGHT_ECHO_PIN, GPIO.IN)
  210.         GPIO.setup(RIGHT_TRIGGER_PIN, GPIO.OUT, initial=False)
  211.         GPIO.setup(LEFT_ECHO_PIN, GPIO.IN)
  212.         GPIO.setup(LEFT_TRIGGER_PIN, GPIO.OUT, initial=False)
  213.         GPIO.setup(
  214.             [
  215.                 MOTOR_A_ENABLE_PIN,
  216.                 MOTOR_A_INPUT_1_PIN,
  217.                 MOTOR_A_INPUT_2_PIN,
  218.                 MOTOR_B_ENABLE_PIN,
  219.                 MOTOR_B_INPUT_1_PIN,
  220.                 MOTOR_B_INPUT_2_PIN,
  221.             ],
  222.             GPIO.OUT,
  223.             initial=False,
  224.         )
  225.  
  226.         led_start()
  227.         app.run(host='0.0.0.0', port=5000, debug=True)
  228.     except KeyboardInterrupt:  # Behandelt die Eingabe von Strg+C
  229.         print('Programm gestoppt')
  230.     finally:
  231.         GPIO.cleanup()
  232.  
  233.  
  234. if __name__ == '__main__':
  235.     main()

Du solltest auch anfangen Dich mit Verbunddatentypen (`collections.namedtuple()` und Klassen) auseinander zu setzen und zum Beispiel Pins die zusammengehören in solchen Objekten zusammenfassen. Das macht das Programm leichter nachvollziehbar.
“There are only two industries that refer to their customers as users.” — Edward Tufte
ice2711
User
Beiträge: 3
Registriert: Montag 29. Mai 2017, 09:02

Re: Fernsteuerung mit Flask Problem

Beitragvon ice2711 » Montag 29. Mai 2017, 13:42

Wow, erstmal vielen Dank an Sirius3 und BlackJack für die schnellen und ausführlichen Antworten. Wobei ich ehrlich gesagt nicht alles 100%ig verstanden habe. Werde da erstmal ein paar Dinge nachlesen müssen. Die unnötigen Überbleibsel im Code kann ich damit erklären dass ich verschiedene Dinge schon versucht aber dann nicht alles wieder restlos zurück genommen habe.
ice2711
User
Beiträge: 3
Registriert: Montag 29. Mai 2017, 09:02

Re: Fernsteuerung mit Flask Problem

Beitragvon ice2711 » Montag 19. Juni 2017, 22:03

Nochmal Danke für eure Hilfe. Ich konnte das Problem jetzt lösen. :D

Zurück zu „Webframeworks“

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder