Antriebsstrang#

Einführung #

Der Antriebsstrang steuert die Fahr- und Drehbewegungen des VR-Roboters. Er ermöglicht Vorwärts- und Rückwärtsfahrten, Links- und Rechtskurven, Drehungen in verschiedene Richtungen und die Nachführung der Rotation.

Es gibt viele Möglichkeiten, den Antriebsstrang zu codieren. Nachfolgend finden Sie eine Liste aller Antriebsstrangmethoden:

Aktionen – Den Roboter bewegen und drehen.

drive — Bewegt den Roboter unendlich vorwärts oder rückwärts.
drive_for — Bewegt den Roboter vorwärts oder rückwärts über eine bestimmte Distanz.
turn — Dreht den Roboter endlos nach links oder rechts.
turn_for — Dreht den Roboter um eine bestimmte Anzahl von Grad nach links oder rechts.
turn_to_heading — Dreht den Roboter in eine bestimmte Richtung zwischen -359 und 359 Grad.
turn_to_rotation — Dreht den Roboter in eine bestimmte Rotation.
stop — Stoppt die Bewegung des Roboters.

Mutatoren – Einstellungen des Antriebsstrangs anpassen.

set_heading — Ändert die aktuelle Fahrtrichtung des Roboters in eine neue Fahrtrichtung.
set_rotation — Ändert die aktuelle Rotation des Roboters in eine neue Rotation.
set_timeout — Legt fest, wie lange der Roboter versucht, eine Bewegung abzuschließen.
set_drive_velocity — Sagt dem Roboter, wie schnell er fahren soll.
set_turn_velocity — Sagt dem Roboter, wie schnell er sich drehen soll.

Antriebsstrangstatus prüfen

heading — Gibt die aktuelle Richtung des Roboters von 0 bis 359,99 Grad zurück.
rotation — Gibt die aktuelle Rotation des Roboters zurück.
is_done — Gibt als booleschen Wert zurück, ob der Roboter seine Bewegung beendet hat.
is_moving — Gibt als booleschen Wert zurück, ob sich der Roboter bewegt.

Aktionen #

drive #

drive endlos. Der Roboter bewegt sich so lange, bis ihm eine andere Aktion zugewiesen wird, z. B. Drehen oder Anhalten.

Usage:
drivetrain.drive(direction)

Parameter	Beschreibung
`direction`	Die Bewegungsrichtung des Roboters: `FORWARD` oder `REVERSE`.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

drive_for #

drive_for bewegt den Roboter eine bestimmte Strecke vorwärts oder rückwärts. Das Projekt wartet, bis der Roboter die Bewegung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.

Usage:
drivetrain.drive_for(direction, distance, units, wait)

Parameter	Beschreibung
`direction`	Die Bewegungsrichtung des Roboters: `FORWARD` oder `REVERSE`.
`distance`	Die vom Roboter zurückgelegte Strecke. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Entfernungseinheit: `INCHES` (Standard) oder `MM`.
`wait`	Optional. `wait=True` (Standard) Das Projekt wartet, bis der Roboter seine Bewegung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# VR threads — Do not delete
vr_thread(main)

turn #

turn links oder rechts, und zwar endlos. Der Roboter dreht sich so lange, bis er eine andere Aktion erhält, z. B. Fahren oder Anhalten.

Usage:
drivetrain.turn(direction)

Parameter	Beschreibung
`direction`	Die Richtung, in die sich der Roboter dreht: `LEFT` oder `RIGHT`.

def main():
    # Turn right and left, then stop
    drivetrain.turn(RIGHT)
    wait(2, SECONDS)
    drivetrain.turn(LEFT)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

turn_for #

Der Befehl turn_for dreht den Roboter um eine bestimmte Gradzahl nach links oder rechts. Die Drehung erfolgt relativ zur aktuellen Position des Roboters. Das Projekt wartet, bis der Roboter die Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.

Usage:
drivetrain.turn_for(direction, angle, units, wait)

Parameter	Beschreibung
`direction`	Die Richtung, in die sich der Roboter dreht: `LEFT` oder `RIGHT`.
`angle`	Die Anzahl der Grad, um die sich der Roboter dreht. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).
`wait`	Optional. `wait=True` (Standard) Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Turn the robot right and left
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_for(LEFT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

turn_to_heading #

Die Ausrichtung des Roboters wird in Grad gemessen. Der Wert turn_to_heading bewirkt, dass der Roboter in eine bestimmte Richtung zwischen -359 und 359 Grad ausgerichtet wird. Dabei wählt er den kürzesten Weg, um die Zielausrichtung zu erreichen.

Die Ausgangsrichtung des Roboters beträgt 0 Grad.

Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.

Usage:
drivetrain.turn_to_heading(angle, units, wait)

Parameter	Beschreibung
`angle`	Die Richtung, in die der Roboter zeigen soll, in Grad. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float`) zwischen -359 und 359 sein.
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).
`wait`	Optional. `wait=True` (Standard) Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

turn_to_rotation #

turn_to_rotation dreht den Roboter in eine bestimmte Rotation.

Die Rotation gibt an, um welchen Winkel sich der Roboter gedreht hat, gemessen in Grad. Zu Beginn eines Projekts ist der Rotationswert auf 0 Grad eingestellt. Die Rotation kann auch mit der Methode set_rotation festgelegt werden.

Die Rotationswerte sind absolut. Das bedeutet, die Drehrichtung hängt von der aktuellen Rotation des Roboters ab. Eine Rechtsdrehung erhöht die Rotation, eine Linksdrehung verringert sie.

Wenn der Roboter beispielsweise bei 0 Grad startet und Sie ihn um 720 Grad drehen, dreht er sich zweimal nach rechts. Drehen Sie ihn anschließend um 360 Grad, dreht er sich einmal nach links, da 360 kleiner als 720 ist.

Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.

Usage:
drivetrain.turn_to_rotation(angle, units, wait)

Parameter	Beschreibung
`angle`	Der Rotationswert in Grad, um den sich der Roboter drehen wird. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).
`wait`	Optional. `wait=True` (Standard) Das Projekt wartet, bis der Roboter seine Drehung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird. `wait=False` Die nächste Codezeile wird sofort ausgeführt.

def main():
    # Turn left, then spin in a circle
    # clockwise and face right
    drivetrain.turn_to_rotation(-90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_rotation(450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stop #

stop stoppt die Bewegung des Roboters.

Usage:
drivetrain.stop()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

Mutatoren #

set_heading #

Die Ausrichtung des Roboters wird in Grad gemessen. Der Befehl set_heading ändert die aktuelle Ausrichtung des Roboters auf einen neuen Wert.

Wenn sich der Roboter beispielsweise nach rechts gedreht hat, wird durch Einstellen der Ausrichtung auf 0 Grad diese Position nach rechts zum neuen 0-Grad-Wert. Anschließend kann der Roboter basierend auf dieser neuen Ausrichtung andere Positionen anfahren.

Usage:
drivetrain.set_heading(heading, units)

Parameter	Beschreibung
`heading`	Der für den Roboter einzustellende Kurswert in Grad. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Überschrifteneinheit: `DEGREES` (Standard).

def main():
    # Face the new 0 degrees
    drivetrain.set_heading(90, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_rotation #

Die Rotation gibt an, um welchen Winkel sich der Roboter gedreht hat, gemessen in Grad. Zu Beginn eines Projekts ist der Rotationswert auf 0 Grad eingestellt. Der Befehl set_rotation ändert die aktuelle Rotation des Roboters auf einen neuen Wert.

Hat der Roboter beispielsweise zwei volle Drehungen nach rechts ausgeführt, beträgt sein Rotationswert 720 Grad. Durch Setzen der Rotation auf 0 Grad wird dieser Wert von 720 auf 0 Grad zurückgesetzt. Anschließend kann der Roboter Drehungen basierend auf diesem neuen Wert ausführen.

Usage:
drivetrain.set_rotation(rotation, units)

Parameter	Beschreibung
`rotation`	Der für den Roboter einzustellende Rotationswert in Grad. Dies kann eine ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).

def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

set_timeout wird festgelegt, wie lange der Roboter versucht, eine Bewegung abzuschließen. Gelingt ihm dies nicht, bricht er den Versuch ab und fährt mit der nächsten Codezeile fort. Dadurch wird verhindert, dass der Roboter bei einer Bewegung hängen bleibt.

Usage:
drivetrain.set_timeout(value, units)

Parameter	Beschreibung
`value`	Die Zeitspanne, in der der Roboter versuchen kann, eine Bewegung abzuschließen. Dies kann eine positive ganze Zahl `integer` ) oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Zeiteinheit: `SECONDS` (Standard) oder `MSEC` (Millisekunden).

def main():
    # Turn right after driving forward
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# VR threads — Do not delete
vr_thread(main)

set_drive_velocity #

Der Wert set_drive_velocity gibt dem Roboter die Fahrgeschwindigkeit vor. Ein höherer Prozentwert beschleunigt den Roboter, ein niedrigerer Prozentwert verlangsamt ihn.

Jedes Projekt beginnt standardmäßig damit, dass der Roboter mit 50 % Geschwindigkeit fährt.

Hinweis: Eine höhere Geschwindigkeit lässt den Roboter schneller fahren, kann aber die Präzision verringern. Eine niedrigere Geschwindigkeit lässt den Roboter langsamer fahren, kann aber die Präzision erhöhen.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Parameter	Beschreibung
`velocity`	Die Geschwindigkeit, mit der gefahren werden soll, von 0 % bis 100 %. Dies kann eine ganze Zahl `integer` oder eine Dezimalzahl (`float` ) sein.
`units`	Optional. Die Geschwindigkeitseinheit: `PERCENT` (Standard).

def main():
    # Drive forward at different velocities
    # Default velocity
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive slower
    drivetrain.set_drive_velocity(20, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive faster
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_thread(main)

set_turn_velocity #

Der Wert set_turn_velocity gibt dem Roboter die Drehgeschwindigkeit vor. Ein höherer Prozentwert beschleunigt die Drehung, ein niedrigerer Prozentwert verlangsamt sie.

Jedes Projekt beginnt standardmäßig damit, dass sich der Roboter mit 50 % Geschwindigkeit dreht.

Hinweis: Eine höhere Geschwindigkeit führt zu schnelleren Drehungen des Roboters, kann aber die Präzision verringern. Eine niedrigere Geschwindigkeit verlangsamt die Drehung, kann aber die Präzision erhöhen.

Usage:
drivetrain.set_turn_velocity(velocity, units)

Parameter	Beschreibung
`velocity`	The velocity to turn with from 0% to 100%. This can be an `integer` or decimal (`float`).
`units`	Optional. Die Geschwindigkeitseinheit: `PERCENT` (Standard).

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getter #

heading #

Die Ausrichtung (in Grad) gibt die Blickrichtung des Roboters an. Der Befehl heading liefert die aktuelle Ausrichtung des Roboters zwischen 0 und 359,99 Grad.

Die Ausgangsrichtung des Roboters beträgt 0 Grad.

Usage:
drivetrain.heading(units)

Parameter	Beschreibung
`units`	Optional. Die Überschrifteneinheit: `DEGREES` (Standard).

def main():
    # Display the heading after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.print("Heading: ")
    brain.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

rotation #

Die Rotation gibt an, um wie viel sich der Roboter gedreht hat, gemessen in Grad. Zu Beginn eines Projekts ist der Rotationswert auf 0 Grad gesetzt. Die Eingabe rotation gibt die aktuelle Rotation des Roboters zurück.

Eine Rechtsdrehung erhöht die Rotation, eine Linksdrehung verringert sie. Beispielsweise ergibt eine zweifache Rechtsdrehung eine Rotation von 720 Grad.

Usage:
drivetrain.rotation(units)

Parameter	Beschreibung
`units`	Optional. Die Rotationseinheit: `DEGREES` (Standard).

def main():
    # Display the rotation after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.print("Rotation: ")
    brain.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

is_done #

Die Funktion is_done gibt als booleschen Wert zurück, ob der Roboter seine Bewegung beendet hat is_done . Dieser Wert kann verwendet werden, um den Zeitpunkt anderer Verhaltensweisen basierend auf der Bewegung des Roboters zu steuern.

True — Der Roboter hat seine Bewegung beendet.
False — Der Roboter bewegt sich noch.

Diese Methode funktioniert zusammen mit den folgenden Drivetrain-Methoden, die den Parameter wait haben: drive_for, turn_for, turn_to_heading und turn_to_rotation.

Usage:
drivetrain.is_done()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

is_moving #

Die Funktion is_moving gibt als booleschen Wert zurück, ob sich der Roboter bewegt is_moving . Dieser Wert kann verwendet werden, um den Zeitpunkt anderer Verhaltensweisen basierend auf der Bewegung des Roboters zu steuern.

True — Der Roboter bewegt sich.
False — Der Roboter bewegt sich nicht.

Usage:
drivetrain.is_moving()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.