from gpiozero import LED, Button
import RPi.GPIO as GPIO
from gpiozero import LED, Button
import threading
getpass
# Pin-Nummerierung auf dem Board verwenden
GPIO.setmode(GPIO.BCM)
# Pin-Nummern definieren
pwm_gpio = 18
pwm_gpio1 = 21
# Frequenz des PWM-Signals
frequency = 50
# GPIO-Pins konfigurieren
GPIO.setup(pwm_gpio, GPIO.OUT)
GPIO.setup(pwm_gpio1, GPIO.OUT)
# PWM-Objekte erstellen
pwm = GPIO.PWM(pwm_gpio, frequency)
pwm1 = GPIO.PWM(pwm_gpio1, frequency)
# LED und Button erstellen
led = LED(17)
button = Button(16)
# Funktion zur Umrechnung von Winkel in Prozent
def angle_to_percent(angle):
if angle > 180 or angle < 0:
return False
start = 4
end = 12.5
ratio = (end - start) / 180 # Verhältnis von Winkel zu Prozent berechnen
angle_as_percent = angle * ratio
return start + angle_as_percent
# Funktion zur Steuerung des Safe Locks
def onButtonPressed():
password = getpass.getpass("Bitte Passwort eingeben: ")
if password == "123456789":
zeit = int(input("Wie lange soll der Safe geöffnet bleiben? (in Sekunden): "))
led.on()
print("Button gedrückt, LED eingeschaltet")
pwm1.start(angle_to_percent(90))
threading.Timer(2, pwm.start, args=[angle_to_percent(180)]).start()
threading.Timer(zeit, stop_lock).start()
elif password == "easter_egg_123456789":
led.on()
print("Button gedrückt, LED eingeschaltet")
pwm1.start(angle_to_percent(90))
threading.Timer(2, pwm.start, args=[angle_to_percent(180)]).start()
threading.Timer(0.5, blink_led, args=[3]).start()
else:
print("Falsches Passwort eingegeben")
# Funktion zum Stoppen des Safe Locks
def stop_lock():
print("Safe Lock gestoppt")
led.off()
pwm.start(angle_to_percent(70))
# Funktion zum Blinken der LED
def blink_led(num_blinks):
for i in range(num_blinks):
led.on()
threading.Timer(0.5, led.off).start()
# Button-Event-Handler festlegen
button.when_pressed = onButtonPressed
# Schleife starten
try:
while True:
pass
except KeyboardInterrupt:
# Aufräumen
GPIO.cleanup()
import RPi.GPIO as io
io.setmode(io.BCM)
# Mit der Variable DC_MAX wird die maximale Drehgeschwindigkeit der
# Motoren festgelegt. DC steht dabei für DutyCicle.
# Die Geschwindigkeit wird initial auf den Wert 70 festgelegt welcher einer
# Leistung der H-Bruecke von 70% also einer Drosselung entspricht.
# Diese Minderung der Leistung am Anfang hilft mit der Steuerung des Roboter-
# Autos besser zurechtzukommen. Soll das Roboter-Auto schneller
# fahren, kann hier der Wert von 70 % auf maximal 100 % gesetzt werden.
DC_MAX = 100
# Mit dem folgenden Aufruf werden Warnungen deaktiviert, die die
# Klasse RPi.GPIO eventuell ausgibt.
io.setwarnings(False)
# Im folgenden Programmabschnitt wird die logische Verkabelung des
# Raspberry Pi im Programm abgebildet. Dazu werden den vom Motortreiber
# bekannten Pins die GPIO-Adressen zugewiesen.
# --- START KONFIGURATION GPIO-Adressen ---
ENA = 18
IN1 = 6
IN2 = 13
IN3 = 19
IN4 = 26
ENB = 12
# --- ENDE KONFIGURATION GPIO-Adressen ---
# Der Variable leftmotor_in1_pin wird die Variable IN1 zugeordnet.
# Der Variable leftmotor_in2_pin wird die Variable IN2 zugeordnet.
leftmotor_in1_pin = IN1
leftmotor_in2_pin = IN2
# Beide Variablen leftmotor_in1_pin und leftmotor_in2_pin werden als
# Ausgaenge "OUT" definiert. Mit den beiden Variablen wird die
# Drehrichtung der Motoren gesteuert.
io.setup(leftmotor_in1_pin, io.OUT)
io.setup(leftmotor_in2_pin, io.OUT)
# Der Variable rightmotor_in1_pin wird die Variable IN1 zugeordnet.
# Der Variable rightmotor_in2_pin wird die Variable IN2 zugeordnet.
rightmotor_in1_pin = IN3
rightmotor_in2_pin = IN4
# Beide Variablen rightmotor_in1_pin und rightmotor_in2_pin werden
# als Ausgaenge "OUT" definiert. Mit den beiden Variablen wird die
# Drehrichtung der Motoren gesteuert.
io.setup(rightmotor_in1_pin, io.OUT)
io.setup(rightmotor_in2_pin, io.OUT)
# Die GPIO-Pins des Raspberry Pi werden initial auf False gesetzt.
# So ist sichergestellt, dass kein HIGH-Signal anliegt und dass der
# Motortreiber nicht unbeabsichtigt aktiviert wird.
io.output(leftmotor_in1_pin, False)
io.output(leftmotor_in2_pin, False)
io.output(rightmotor_in1_pin, False)
io.output(rightmotor_in2_pin, False)
# Der Variable leftmotorpwm_pin wird die Variable ENA zugeordnet.
# Der Variable rightmotorpwm_pin wird die Variable ENB zugeordnet.
leftmotorpwm_pin = ENA
rightmotorpwm_pin = ENB
# Die Variablen leftmotorpwm_pin und rightmotorpwm_pin werden
# als Ausgaenge "OUT" definiert. Mit den beiden Variablen wird die
# Drehgeschwindigkeit der Motoren über ein PWM-Signal gesteuert.
io.setup(leftmotorpwm_pin, io.OUT)
io.setup(rightmotorpwm_pin, io.OUT)
# Die Variablen leftmotorpwm_pin und rightmotorpwm_pin werden
# zusätzlich zu ihrer Eigenschaft als Ausgaenge als "PWM"-Ausgaenge
# definiert. Mit io.PWM(GPIO-Nummer, Frequenz) wird für einen bestimmten GPIO
# die Frequenz angegeben. In diesem Beispiel wird 100 Herz als Frequenz
# festgelegt. Manche Motortreiber benötigen aber z. B. 500 Herz. Hier muessen
# wenn das Roboter-Auto nicht losfaehrt mit der Herzzahl etwas
# experimentieren.
leftmotorpwm = io.PWM(leftmotorpwm_pin,100)
rightmotorpwm = io.PWM(rightmotorpwm_pin,100)
# Die linken Motoren stehen still, da das PWM-Signal mit
# ChangeDutyCycle(0) auf 0 gesetzt wurde.
leftmotorpwm.start(0)
leftmotorpwm.ChangeDutyCycle(0)
# Die rechten Motoren stehen still, da das PWM-Signal mit
# ChangeDutyCycle(0) auf 0 gesetzt wurde.
rightmotorpwm.start(0)
rightmotorpwm.ChangeDutyCycle(0)
# Die Funktion setMotorMode(motor, mode) legt die Drehrichtung der
# Motoren fest. Die Funktion verfügt über zwei Eingabevariablen.
# motor -> Diese Variable legt fest, ob der linke oder rechte
# Motor ausgewaehlt wird.
# mode -> Diese Variable legt fest, welcher Modus gewaehlt ist
# Beispiel:
# setMotorMode(leftmotor, forward) Die linken Motoren sind gewaehlt
# und drehen vorwaerts.
# setMotorMode(rightmotor, reverse) Die rechten Motoren sind ausgewaehlt
# und drehen rueckwaerts.
# setMotorMode(rightmotor, stopp) Der rechte Motor ist ausgewaehlt
# und wird gestoppt.
def setMotorMode(motor, mode):
if motor == "leftmotor":
if mode == "reverse":
io.output(leftmotor_in1_pin, True)
io.output(leftmotor_in2_pin, False)
elif mode == "forward":
io.output(leftmotor_in1_pin, False)
io.output(leftmotor_in2_pin, True)
else:
io.output(leftmotor_in1_pin, False)
io.output(leftmotor_in2_pin, False)
elif motor == "rightmotor":
if mode == "reverse":
io.output(rightmotor_in1_pin, False)
io.output(rightmotor_in2_pin, True)
elif mode == "forward":
io.output(rightmotor_in1_pin, True)
io.output(rightmotor_in2_pin, False)
else:
io.output(rightmotor_in1_pin, False)
io.output(rightmotor_in2_pin, False)
else:
io.output(leftmotor_in1_pin, False)
io.output(leftmotor_in2_pin, False)
io.output(rightmotor_in1_pin, False)
io.output(rightmotor_in2_pin, False)
# Die Funktion setMotorLeft(power) setzt die Geschwindigkeit der
# linken Motoren. Die Geschwindigkeit wird als Wert zwischen -1
# und 1 uebergeben. Bei einem negativen Wert sollen sich die Motoren
# rueckwaerts drehen, ansonsten vorwaerts.
# Anschliessend werden aus den uebergebenen Werten die notwendigen
# Prozentwerte fuer das PWM-Signal berechnet.
# Beispiel:
# Die Geschwindigkeit kann mit +1 (max) und -1 (min) gesetzt werden.
# Das Beispiel erklaert, wie die Geschwindigkeit berechnet wird.
# SetMotorLeft(0) -> der linke Motor dreht mit 0 %, ist also gestoppt
# SetMotorLeft(0.75) -> der linke Motor dreht mit 75 % vorwaerts
# SetMotorLeft(-0.5) -> der linke Motor dreht mit 50 % rueckwaerts
# SetMotorLeft(1) -> der linke Motor dreht mit 100 % vorwaerts
def setMotorLeft(power):
int(power)
if power < 0:
# Rueckwaertsmodus fuer den linken Motor
setMotorMode("leftmotor", "reverse")
pwm = -int(DC_MAX * power)
if pwm > DC_MAX:
pwm = DC_MAX
elif power > 0:
# Vorwaertsmodus fuer den linken Motor
setMotorMode("leftmotor", "forward")
pwm = int(DC_MAX * power)
if pwm > DC_MAX:
pwm = DC_MAX
else:
# Stoppmodus fuer den linken Motor
setMotorMode("leftmotor", "stopp")
pwm = 0
leftmotorpwm.ChangeDutyCycle(pwm)
# Die Funktion setMotorRight(power) setzt die Geschwindigkeit der
# rechten Motoren. Die Geschwindigkeit wird als Wert zwischen -1
# und 1 uebergeben. Bei einem negativen Wert sollen sich die Motoren
# rueckwaerts drehen, ansonsten vorwaerts.
# Anschliessend werden aus den uebergebenen Werten die notwendigen
# Prozentwerte fuer das PWM-Signal berechnet.
# Beispiel:
# Die Geschwindigkeit kann mit +1 (max) und -1 (min) gesetzt werden.
# Das Beispiel erklaert, wie die Geschwindigkeit berechnet wird.
# setMotorRight(0) -> der linke Motor dreht mit 0 %, ist also gestoppt
# setMotorRight(0.75) -> der linke Motor dreht mit 75 % vorwaerts
# setMotorRight(-0.5) -> der linke Motor dreht mit 50 % rueckwaerts
# setMotorRight(1) -> der linke Motor dreht mit 100 % vorwaerts
def setMotorRight(power):
int(power)
if power < 0:
# Rueckwaertsmodus fuer den rechten Motor
setMotorMode("rightmotor", "reverse")
pwm = -int(DC_MAX * power)
if pwm > DC_MAX:
pwm = DC_MAX
elif power > 0:
# Vorwaertsmodus fuer den rechten Motor
setMotorMode("rightmotor", "forward")
pwm = int(DC_MAX * power)
if pwm > DC_MAX:
pwm = DC_MAX
else:
# Stoppmodus fuer den rechten Motor
setMotorMode("rightmotor", "stopp")
pwm = 0
rightmotorpwm.ChangeDutyCycle(pwm)
# Die Funktion exit() setzt die Ausgaenge, die den Motortreiber
# steuern, auf False. So befindet sich der Motortreiber nach dem
# Aufruf derFunktion in einem gesicherten Zustand und die Motoren
# sind gestoppt.
def exit():
io.output(leftmotor_in1_pin, False)
io.output(leftmotor_in2_pin, False)
io.output(rightmotor_in1_pin, False)
io.output(rightmotor_in2_pin, False)
io.cleanup()
# Ende des Programms
import sys, tty, termios, os, readchar
# Das Programm L298NHBridge.py wird als Modul geladen. Es stellt
# die Funktionen fuer die Steuerung der H-Bruecke zur Verfuegung.
import L298NHBridge as HBridge
# Das Programm L298NHBridgePCA9685 wird als Modul geladen. Es stellt
# die Funktionen fuer die Steuerung der H-Bruecke ueber einen PCA9685
# Servo Kontroller zur Verfuegung.
#import L298NHBridgePCA9685 as HBridge
# Variablendefinition für die Geschwindigkeit der linken und rechten
# Motoren des Roboter-Autos.
speedleft = 0
speedright = 0
# Das Menue fuer den Anwender, wenn er das Programm ausfuehrt.
# Das Menue erklaert, mit welchen Tasten das Auto gesteuert wird.
print("w/s: beschleunigen")
print("a/d: lenken")
print("q: stoppt die Motoren")
print("x: Programm beenden")
# Die Funktion getch() nimmt die Tastatureingabe des Anwenders
# entgegen. Die gedrueckten Buchstaben werden eingelesen. Sie werden
# benoetigt, um die Richtung und Geschwindigkeit des Roboter-Autos
# festlegen zu koennen.
def getch():
ch = readchar.readchar()
return ch
# Die Funktion printscreen() gibt, wenn sie aufgerufen wird, immer das
# aktuelle Menue aus sowie die Geschwindigkeit der linken und rechten
# Motoren.
def printscreen():
# der Befehl os.system('clear') leert den Bildschirminhalt vor
# jeder Aktualisierung der Anzeige. So bleibt das Menue stehen
# und die Bildschirmanzeige im Terminal-Fenster steht still.
os.system('clear')
print("w/s: vorwaerts / rueckwaerts beschleunigen")
print("a/d: links / rechts lenken")
print("q: stoppt die Motoren")
print("x: Programm beenden")
print("========== Geschwindigkeitsanzeige ==========")
print("Geschwindigkeit linker Motor: ", speedleft)
print("Geschwindigkeit rechter Motor: ", speedright)
# Diese Endlosschleife wird erst dann beendet, wenn der Anwender
# die Taste X drueckt. Solange das Programm laeuft, wird ueber diese
# Schleife die Eingabe der Tastatur eingelesen.
while True:
# Mit dem Aufruf der Funktion getch() wird die Tastatureingabe
# des Anwenders eingelesen. Die Funktion getch() liest den
# gedrueckten Buchstabe ein und uebergibt ihn an die
# Variable char. So kann mit der Variable char weiter-
# gearbeitet werden.
char = getch()
# Das Roboter-Auto faehrt vorwaerts, wenn der Anwender die
# Taste "w" drueckt.
if(char == "w"):
# Das Roboter-Auto beschleunigt in Schritten von 10 %
# bei jedem Tastendruck des Buchstaben "w" bis maximal
# 100 %. Dann faehrt es maximal schnell vorwaerts.
speedleft = speedleft + 0.5
speedright = speedright + 0.5
if speedleft > 1:
speedleft = 1
if speedright > 1:
speedright = 1
# Dem Programm L298NHBridge, das zu Beginn
# importiert wurde, wird die Geschwindigkeit fuer
# die linken und rechten Motoren uebergeben.
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
# Das Roboter-Auto faehrt rueckwaerts, wenn die Taste "s"
# gedrueckt wird.
if(char == "s"):
# Das Roboter-Auto bremst in Schritten von 10 %
# bei jedem Tastendruck des Buchstaben "s" bis maximal
# -100 %. Dann faehrt es maximal schnell rueckwaerts.
speedleft = speedleft - 0.5
speedright = speedright - 0.5
if speedleft < -1:
speedleft = -1
if speedright < -1:
speedright = -1
# Dem Programm L298NHBridge, das zu Beginn
# importiert wurde, wird die Geschwindigkeit fuer
# die linken und rechten Motoren uebergeben.
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
# Mit dem Druecken der Taste "q" werden die Motoren angehalten.
if(char == "q"):
speedleft = 0
speedright = 0
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
# Mit der Taste "d" lenkt das Auto nach rechts, bis die max/min.
# Geschwindigkeit der linken und rechten Motoren erreicht ist.
if(char == "d"):
speedright = speedright + 0.5
speedleft = speedleft - 0.5
if speedright < -1:
speedright = -1
if speedleft > 1:
speedleft = 1
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
# Mit der Taste "a" lenkt das Auto nach links, bis die max/min.
# Geschwindigkeit der linken und rechten Motoren erreicht ist.
if(char == "a"):
speedleft = speedleft + 0.5
speedright = speedright - 0.5
if speedleft < -1:
speedleft = -1
if speedright > 1:
speedright = 1
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
# Mit der Taste "x" wird die Endlosschleife beendet
# und das Programm ebenfalls beendet. Zum Schluss wird
# noch die Funktion exit() aufgerufen, die die Motoren stoppt.
if(char == "x"):
HBridge.setMotorLeft(0)
HBridge.setMotorRight(0)
HBridge.exit()
print("Programm Ende")
break
# Die Variable char wird pro Schleifendurchlauf geleert.
# Das ist notwendig, um weitere Eingaben sauber zu übernehmen.
char = ""
# Ende des Programms
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
import time
trigPin = 22
echoPin = 24
MAX_DISTANCE = 600 # define the maximum measuring distance, unit: cm
timeOut = MAX_DISTANCE*60 # calculate timeout according to the maximum measuring distance
def angle_to_percent (angle) :
if angle > 180 or angle < 0 :
return False
start = 4
end = 12.5
ratio = (end - start)/180 #Calcul ratio from angle to percent
angle_as_percent = angle * ratio
return start + angle_as_percent
GPIO.setwarnings(False) #Disable warnings
#Use pin 25 for PWM signal
pwm_gpio = 25
frequence = 50
GPIO.setup(pwm_gpio, GPIO.OUT)
pwm = GPIO.PWM(pwm_gpio, frequence)
def pulseIn(pin,level,timeOut): # obtain pulse time of a pin under timeOut
t0 = time.time()
while(GPIO.input(pin) != level):
if((time.time() - t0) > timeOut*0.000001):
return 0;
t0 = time.time()
while(GPIO.input(pin) == level):
if((time.time() - t0) > timeOut*0.000001):
return 0;
pulseTime = (time.time() - t0)*1000000
return pulseTime
def getSonar(): # get the measurement results of ultrasonic module,with unit: cm
GPIO.output(trigPin,GPIO.HIGH) # make trigPin output 10us HIGH level
time.sleep(0.00001) # 10us
GPIO.output(trigPin,GPIO.LOW) # make trigPin output LOW level
pingTime = pulseIn(echoPin,GPIO.HIGH,timeOut) # read plus time of echoPin
distance = pingTime * 340.0 / 2.0 / 10000.0 # calculate distance with sound speed 340m/s
return distance
def getSonar1(): # get the measurement results of ultrasonic module,with unit: cm
GPIO.output(trigPin,GPIO.HIGH) # make trigPin output 10us HIGH level
time.sleep(0.00001) # 10us
GPIO.output(trigPin,GPIO.LOW) # make trigPin output LOW level
pingTime = pulseIn(echoPin,GPIO.HIGH,timeOut) # read plus time of echoPin
distance1 = pingTime * 340.0 / 2.0 / 10000.0 # calculate distance1 with sound speed 340m/s
return distance1
def getSonar2(): # get the measurement results of ultrasonic module,with unit: cm
GPIO.output(trigPin,GPIO.HIGH) # make trigPin output 10us HIGH level
time.sleep(0.00001) # 10us
GPIO.output(trigPin,GPIO.LOW) # make trigPin output LOW level
= pulseIn(echoPin,GPIO.HIGH,timeOut) # read plus time of echoPin
distance2 = pingTime * 340.0 / 2.0 / 10000.0 # calculate distance1 with sound speed 340m/s
return distance2
def setup():
GPIO.setmode(GPIO.BCM) # use PHYSICAL GPIO Numbering
GPIO.setup(trigPin, GPIO.OUT) # set trigPin to OUTPUT mode
GPIO.setup(echoPin, GPIO.IN) # set echoPin to INPUT mode
#Set function to calculate percent from angle
# Es werden verschiedene Python-Klassen importiert, deren Funktionen
# fuer die Programmverarbeitung benoetigt werden.
import sys, tty, termios, os, readchar
# Das Programm L298NHBridge.py wird als Modul geladen. Es stellt
# die Funktionen fuer die Steuerung der H-Bruecke zur Verfuegung.
import L298NHBridge as HBridge
# Das Programm L298NHBridgePCA9685 wird als Modul geladen. Es stellt
# die Funktionen fuer die Steuerung der H-Bruecke ueber einen PCA9685
# Servo Kontroller zur Verfuegung.
#import L298NHBridgePCA9685 as HBridge
# Variablendefinition für die Geschwindigkeit der linken und rechten
# Motoren des Roboter-Autos.
speedleft = 0
speedright = 0
# Das Menue fuer den Anwender, wenn er das Programm ausfuehrt.
# Das Menue erklaert, mit welchen Tasten das Auto gesteuert wird.
print("w/s: beschleunigen")
print("a/d: lenken")
print("q: stoppt die Motoren")
print("x: Programm beenden")
# Die Funktion getch() nimmt die Tastatureingabe des Anwenders
# entgegen. Die gedrueckten Buchstaben werden eingelesen. Sie werden
# benoetigt, um die Richtung und Geschwindigkeit des Roboter-Autos
# festlegen zu koennen.
def getch():
ch = readchar.readchar()
return ch
# Die Funktion printscreen() gibt, wenn sie aufgerufen wird, immer das
# aktuelle Menue aus sowie die Geschwindigkeit der linken und rechten
# Motoren.
def printscreen():
# der Befehl os.system('clear') leert den Bildschirminhalt vor
# jeder Aktualisierung der Anzeige. So bleibt das Menue stehen
# und die Bildschirmanzeige im Terminal-Fenster steht still.
os.system('clear')
print("w/s: vorwaerts / rueckwaerts beschleunigen")
print("a/d: links / rechts lenken")
print("q: stoppt die Motoren")
print("x: Programm beenden")
print("========== Geschwindigkeitsanzeige ==========")
print("Geschwindigkeit linker Motor: ", speedleft)
print("Geschwindigkeit rechter Motor: ", speedright)
def strate_servo():
pwm.start(angle_to_percent(90))
def Right_servo():
pwm.start(angle_to_percent(180))
def Left_servo():
pwm.start(angle_to_percent(10))
def strate():
distance = getSonar() # get distance
print ("The distance of strate is : %.2f cm"%(distance))
if distance <= 29:
ende()
check()
def Right():
distance1 = getSonar1() # get distance
print ("The distance of right is : %.2f cm"%(distance1))
def Left():
distance2 = getSonar2() # get distance
print ("The distance of left is : %.2f cm"%(distance2))
# Diese Endlosschleife wird erst dann beendet, wenn der Anwender
# die Taste X drueckt. Solange das Programm laeuft, wird ueber diese
# Schleife die Eingabe der Tastatur eingelesen.
def forward():
speedleft = 0.2
speedright = 0.5
if speedleft > 0.2:
speedleft = 0.2
if speedright > 0.5:
speedright = 0.5
# Dem Programm L298NHBridge, das zu Beginn
# importiert wurde, wird die Geschwindigkeit fuer
# die linken und rechten Motoren uebergeben.
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
# Das Roboter-Auto faehrt rueckwaerts, wenn die Taste "s"
# gedrueckt wird.
def backward():
speedleft = -1
speedright = -1
if speedleft < -1:
speedleft = -1
if speedright < -1:
speedright = -1
# Dem Programm L298NHBridge, das zu Beginn
# importiert wurde, wird die Geschwindigkeit fuer
# die linken und rechten Motoren uebergeben.
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
# Mit der Taste "d" lenkt das Auto nach rechts, bis die max/min.
# Geschwindigkeit der linken und rechten Motoren erreicht ist.
def rightr():
speedright = +1
speedleft = -1
if speedright < -1:
speedright = -1
if speedleft > 1:
speedleft = 1
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
# Mit der Taste "a" lenkt das Auto nach links, bis die max/min.
# Geschwindigkeit der linken und rechten Motoren erreicht ist.
def leftl():
speedleft = + 1
speedright = - 1
if speedleft < -1:
speedleft = -1
if speedright > 1:
speedright = 1
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
def check():
distance1 = getSonar1()
distance2 = getSonar2()
Right_servo()
Right()
time.sleep(0.5)
Left_servo()
time.sleep(1.5)
Left()
time.sleep(0.1)
strate_servo()
if distance1 or distance2 < 10:
backward()
if distance1 < distance2:
leftl()
time.sleep(1)
strate()
loop()
if distance1 > distance2:
rightr()
time.sleep(1)
strate()
loop()
def ende():
speedleft = 0
speedright = 0
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
def loop():
distance = getSonar() # get distance
forward()
strate_servo()
while distance > 30:
strate()
if __name__ == '__main__': # Program entrance
print ('Program is starting...')
setup()
try:
loop()
except KeyboardInterrupt: # Press ctrl-c to end the program.
GPIO.cleanup() # release GPIO resource
speedleft = 0
speedright = 0
HBridge.setMotorLeft(speedleft)
HBridge.setMotorRight(speedright)
printscreen()
# Ende des Programms