Jython HomeDruckenJava-Online

Fahren und stoppen

Der Roboter verfügt über 2 Motoren, die entweder einzeln (Beispiel 1) oder beide zusammen als Fahrwerk (Beispiel 2) verwendet werden können.

Beispiel 1: Roboter mit zwei Motoren
Der Roboter wird zuerst softwaremässig modelliert: robot = Robot() erzeugt ein Roboterobjekt, mot1 = Motor(MOTOR_LEFT) erzeugt den linken Motor. Mit mot1.forward() wird der linke Motor in die Vorwärtsbewegung versetzt. Tools.delay(2000) bewirkt, dass der Roboter während 2000 Millisekunden in der Vorwärtsbewegung bleibt, bevor mit robot.exit() beide Motoren gestoppt werden..

# Motor1.py

from raspibrick import *
# from raspisim import *

robot = Robot()
mot1 = Motor(MOTOR_LEFT)
mot2 = Motor(MOTOR_RIGHT)
mot1.forward()
mot2.forward()
Tools.delay(2000)
robot.exit()
Programmcode markieren (Ctrl+C kopieren)

Erklärungen zum Programmcode:

mot1 = Motor(MOTOR_LEFT): Erzeugt ein Objekt des linken Motors
mot2 = Motor(MOTOR_RIGHT): Erzeugt ein Objekt des rechten Motors
mot1.forward(): ruft die Funktion forward() des Motors mot1 auf. Der Motor startet und bleibt in diesem Zustand, bis er mit mot1.stop() oder robot.exit() angehalten oder mit mot1.backward() rückwärts zum Laufen gebracht wird
robot.exit(): beendet das Programm und gibt alle Ressourcen frei (LEDs, Display, Motoren abschalten). Im Remote-Modus wird die Verbindung zum Computer unterbrochen
#from raspisim import *: für die Robotersimulation muss diese Zeile aktiviert und die Importzeile für den realen Roboter deaktiviert werden


Beispiel 2:
Roboter mit Fahrwerk (Gear)
In der Regel braucht man beide Motoren gleichzeitig, um Roboter-Bewegungen zu programmieren. Darum ist es praktisch, anstelle der einzelnen Motoren ein Fahrwerk (Gear) mit 2 synchronisierten Motoren zu verwenden. Das Programm wird noch einfacher, wenn man die sogenannt blockierende Funktion forward(2000), die als Parameter die Zeit in Millisekunden, verwendet. Im Gegensatz zu der nicht blockierenden Funktion forward() läuft das Programm nicht weiter, bis die 2000 ms abgelaufen sind. Dann stoppen die Motoren.  Die Programme links und rechts bewirken das gleiche, sie verwenden links die blockierende und rechts die nicht blockierende Funktion:

# Motor2.py

from raspibrick import *
# from raspisim import *

robot = Robot()
gear = Gear()
gear.forward(2000)
robot.exit()
 
# Motor3.py

from raspibrick import *
# from raspisim import *

robot = Robot()
gear = Gear()
gear.forward()
Tools.delay(2000)
robot.exit()
Programmcode markieren (Ctrl+C kopieren)
 
Programmcode markieren (Ctrl+C kopieren)

 

Erklärungen zum Programmcode:

gear = Gear(): Erzeugt ein Fahrwerk mit 2 synchronisierten Motoren
gear.forward(2000): Blockierende Funktion. Das Fahrwerk bleibt 2000 ms in der Vorwärtsbewegung und das Programm wird in dieser Zeit blockiert. Nach Ablauf der Zeit werden die Motoren gestoppt
gear.forward(): Nicht blockierende Funktion. Das Fahrwerk wird in Vorwärtsbewegung versetzt. Die Funktion kommt sofort zurück und der Roboter kann auf weitere Befehle reagieren (z. Bsp. Sensorwerte registrieren)

 


Aufgaben Serie 1:

1)

Der Roboter soll 4000 Millisekunden vorwärts fahren, dann 2000 Millisekunden warten und dann 2000 Millisekunden rückwärts fahren. Für Rückwärtsfahren kannst du die Funktion backward() oder backward(2000) verwenden.

Führe das Programm im Remote- , autonomen- und im Simulationsmodus aus.


2)

Mit der Funktion gear.setSpeed(speed), wobei speed eine Zahl zwischen 0 und 100 ist, kannst du die Geschwindigkeit des Roboters ändern. Danach muss du aber die Funktion gear.forward() erneut aufgerufen.

Der Roboter soll zuerst 2000 ms langsam, dann 2000 ms schneller und dann wieder 2000 ms langsam fahren.


3)

Verwende den Roboter mit zwei Motoren gemäss Beispiel 1. Lasse den linken Motor mit speed = 70 und den rechten Motor mit speed = 30 laufen. Untersuche was geschieht, wenn du den linken Motor vorwärts und den linken Motor rückwärts laufen lässt.