Antriebsstrang#

Einführung #

Der Antriebsstrang umfasst Räder und Motoren, die die Fahrt und das Lenken des Roboters steuern. Antriebsstränge finden sich beispielsweise in Konstruktionen wie der Code Base 2.0, dem Super Car oder in einem individuell angefertigten Roboter.

Die Antriebsstränge nutzen den Inertialsensor im Gehirn, um Kollisionen zu erkennen und dem Roboter präzise Bewegungen und Drehungen zu ermöglichen. Zu Beginn jedes Projekts kalibriert der Antriebsstrang den Inertialsensor automatisch. Halten Sie den Roboter während der Kalibrierung etwa 2 Sekunden lang still, damit er sich korrekt bewegen und drehen kann.

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.
drive_until — Bewegt den Roboter vorwärts, bis der Augensensor ein Objekt erkennt oder der Roboter einen Zusammenstoß erkennt.
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. Der Roboter wählt dabei den kürzesten Weg, um die Zielrichtung zu erreichen.
turn_to_rotation — Dreht den Roboter in eine bestimmte Rotation.
stop — Stoppt die Bewegung des Roboters.

Mutatoren – Einstellungen des Antriebsstrangs anpassen.

set_drive_velocity — Sagt dem Roboter, wie schnell er fahren soll.
set_turn_velocity — Sagt dem Roboter, wie schnell er sich drehen soll.
set_stopping — Gibt an, wie der Roboter seine Bewegung beendet: durch Bremsen, Ausrollen oder Anhalten.
set_timeout — Legt fest, wie lange der Roboter versucht, eine Bewegung abzuschließen.
set_heading — Ändert die aktuelle Fahrtrichtung des Roboters in eine neue Fahrtrichtung.
set_rotation — Ändert die aktuelle Rotation des Roboters in eine neue Rotation.

Getters – Bewegungsstatus prüfen.

get_heading — Gibt die aktuelle Richtung des Roboters von 0 bis 359 Grad zurück.
get_rotation — Gibt die aktuelle Rotation des Roboters zurück.
get_velocity — Gibt die Geschwindigkeit des Roboters als Prozentsatz von -100% bis 100% zurück.
get_yaw — Gibt den aktuellen Gierwinkel des Roboters zurück.
get_roll — Gibt den aktuellen Wurf des Roboters zurück.
get_pitch — Gibt die aktuelle Pitch-Winkel des Roboters zurück.
get_crashed — Gibt als booleschen Wert zurück, ob der Roboter einen Absturz erkannt hat.
is_stopped — Gibt als booleschen Wert zurück, ob der Roboter seine Bewegung beendet hat.

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`.

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

drive_for #

drive_for bewegt den Roboter vorwärts oder rückwärts über eine bestimmte Distanz.

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 oder eine Dezimalzahl sein.
`units`	Optional. Die Entfernungseinheit: `MM` (Millimeter, Standard) oder `INCHES`.
`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.

# Build Used: Code Base 2.0
def main():
    # Drive back and forth
    drivetrain.drive_for(FORWARD, 100, MM)
    drivetrain.drive_for(REVERSE, 4, INCHES)
    

# Start threads — Do not delete
start_thread(main)

drive_until #

drive_until bewegt den Roboter vorwärts, bis der Augensensor ein Objekt erkennt oder der Roboter einen Zusammenstoß feststellt.

Usage:
drivetrain.drive_until(condition, wait)

Parameter	Beschreibung
`condition`	Die Bedingung, die den Roboter stoppt: `OBJECT` oder `CRASH`.
`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.

# Build Used: Code Base 2.0
def main():
    # Turn right after a crash
    drivetrain.drive_until(CRASH)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

turn #

turn dreht ihn endlos nach links oder rechts. Der Roboter dreht sich so lange, bis ihm eine andere Aktion zugewiesen wird, z. B. von Fahren zu Anhalten.

Usage:
drivetrain.turn(direction)

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

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

# Start threads — Do not delete
start_thread(main)

turn_for #

turn_for dreht den Roboter um eine bestimmte Gradzahl nach links oder rechts. Die Drehung erfolgt relativ zur aktuellen Position des Roboters.

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

Parameter	Beschreibung
`direction`	Die Richtung, in die sich der Roboter dreht: `LEFT` oder `RIGHT`.
`angle`	Die Gradzahl, um die sich der Roboter dreht. Dies kann eine ganze Zahl oder eine Dezimalzahl sein.
`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.

# Build Used: Code Base 2.0
def main():
    # Turn right then left
    drivetrain.turn_for(RIGHT, 90)
    drivetrain.turn_for(LEFT, 90)

# Start threads — Do not delete
start_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.

Der Ausgangskurs beträgt 0 Grad.

Eine VEX GO Codebasis 2.0, die die Kursrichtungen anzeigt: 0 Grad vorwärts, 90 Grad rechts, 180 Grad rückwärts und 270 Grad links.

Usage:
drivetrain.turn_to_heading(angle, wait)

Parameter	Beschreibung
`angle`	Die Richtung, in die der Roboter zeigen soll, als ganze Zahl von -359 bis 359 Grad.
`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.

# Build Used: Code Base 2.0
def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_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 set_rotation eingestellt 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.

Eine VEX GO-Codebasis 2.0, die nach rechts und links rotierende Pfeile zeigt. Der linke Pfeil zeigt "Minus" und der rechte Pfeil zeigt "Plus".

Usage:
drivetrain.turn_to_rotation(angle, wait)

Parameter	Beschreibung
`angle`	Der Drehwinkel in Grad, um den sich der Roboter drehen wird. Dies kann eine ganze Zahl sein.
`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.

# Build Used: Code Base 2.0
def main():
    # Make one full turn to the right
    drivetrain.turn_to_rotation(360)
    # Make another full turn to the right
    drivetrain.turn_to_rotation(720)
    # Make one full turn to the left, returning to 360 degrees
    drivetrain.turn_to_rotation(360)
# Start threads — Do not delete
start_thread(main)

stop #

stop stoppt die Bewegung des Roboters.

Usage:
drivetrain.stop()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

Mutatoren #

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, erhöht aber die Präzision.

Usage:
drivetrain.set_drive_velocity(velocity)

Parameter	Beschreibung
`velocity`	Die Geschwindigkeit, mit der von 0 % bis 100 % gefahren werden soll.

# Build Used: Code Base 2.0
def main():
    # Drive at different velocities
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive slow
    drivetrain.set_drive_velocity(20)
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive fast
    drivetrain.set_drive_velocity(100)
    drivetrain.drive_for(FORWARD, 100, MM)

# Start threads — Do not delete
start_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 führt zu langsameren Drehungen, erhöht aber die Präzision.

Usage:
drivetrain.set_turn_velocity(velocity)

Parameter	Beschreibung
`velocity`	Die Geschwindigkeit, mit der von 0 % auf 100 % gedreht werden soll.

# Build Used: Code Base 2.0
def main():
    # Turn at different velocities
    drivetrain.turn_for(RIGHT, 180)
    wait(1, SECONDS)
    # Turn fast
    drivetrain.set_turn_velocity(100)
    drivetrain.turn_for(RIGHT, 180)

# Start threads — Do not delete
start_thread(main)

set_stopping #

set_stopping legt fest, wie der Roboter seine Bewegung beendet: durch Bremsen, Ausrollen oder Anhalten.

Usage:
drivetrain.set_stopping(brake)

Parameter	Beschreibung
`brake`	So stoppt der Roboter: `BRAKE` – Stoppt sofort. `COAST` – Verlangsamt bis zum Stillstand. `HOLD` – Stoppt sofort und hält die Radposition.

Parameter

Beschreibung

brake

So stoppt der Roboter:

BRAKE – Stoppt sofort.
COAST – Verlangsamt bis zum Stillstand.
HOLD – Stoppt sofort und hält die Radposition.

Wird diese Methode nicht verwendet, nutzt der Roboter beim Anhalten die Tasten BRAKE.

# Build Used: Code Base 2.0
def main():
    # Drive, then coast to a stop
    drivetrain.set_drive_velocity(100)
    drivetrain.set_stopping(COAST)
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_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 ganze Zahl oder eine Dezimalzahl sein.
`units`	Optional. Die Zeiteinheit: `SECONDS` (Standard) oder `MSEC` (Millisekunden).

# Build Used: Code Base 2.0
def main():
    # Drive as far as possible for 1 second before turning right
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

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(value)

Parameter	Beschreibung
`value`	Der für den Roboter einzustellende Kurswert in Grad. Dies kann eine ganze Zahl zwischen 0 und 359 sein.

# Build Used: Code Base 2.0
def main():
    # Face the new 0 degree heading
    drivetrain.set_heading(90)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_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(value)

Parameter	Beschreibung
`value`	Der für den Roboter einzustellende Rotationswert in Grad. Dies kann eine ganze Zahl sein.

# Build Used: Code Base 2.0
def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720)
    drivetrain.turn_to_rotation(0)

# Start threads — Do not delete
start_thread(main)

Getter #

get_heading #

Die Richtung, in die das Robotergehirn zeigt, wird in Grad gemessen. get_heading gibt diese Richtung von 0 bis 359 Grad zurück.

Die Ausgangsrichtung des Roboters beträgt 0 Grad.

Ein VEX GO Gehirn, das die Fahrtrichtungen anzeigt: 0 Grad vorwärts, 90 Grad rechts, 180 Grad rückwärts und 270 Grad links.

Usage:
drivetrain.get_heading()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Build Used: Code Base 2.0
def main():
    # Display the heading while turning
    monitor_sensor("drivetrain.get_heading")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_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 gesetzt. Der Befehl get_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.

Eine VEX GO-Codebasis 2.0, die nach rechts und links rotierende Pfeile zeigt. Der linke Pfeil zeigt "Minus" und der rechte Pfeil zeigt "Plus".

Usage:
drivetrain.get_rotation()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Build Used: Code Base 2.0
def main():
    # Display the rotation while turning
    monitor_sensor("drivetrain.get_rotation")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_velocity #

get_velocity gibt die Geschwindigkeit des Roboters als Prozentsatz von -100% bis 100% zurück.

Ein positiver Wert bedeutet, dass der Roboter vorwärts fährt. Ein negativer Wert bedeutet, dass der Roboter rückwärts fährt.

Usage:
drivetrain.get_velocity()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Build Used: Code Base 2.0
def main():
    # Display the velocity of the robot before and while moving
    console.print("Start: ")
    console.print(drivetrain.get_velocity())
    console.new_line()
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    console.print("Moving: ")
    console.print(drivetrain.get_velocity())
    drivetrain.stop()


# Start threads — Do not delete
start_thread(main)

get_yaw #

Der Gierwinkel (Yaw) gibt an, um wie viel sich der Roboter von seiner Ausgangsposition nach links oder rechts gedreht hat, gemessen in Grad. get_yaw gibt den aktuellen Gierwinkel des Roboters zurück get_yaw.

Rechtskurven erhöhen den Gierwert, Linkskurven verringern ihn.

Usage:
drivetrain.get_yaw()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the yaw while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_yaw")
    while True:
        if drivetrain.get_yaw() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_yaw() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_roll #

Die Rollachse beschreibt die Neigung des Roboters nach links oder rechts, gemessen in Grad. get_roll gibt den aktuellen Rollwert des Roboters zurück get_roll.

Wenn das Gehirn nach vorne gerichtet ist, erhöht eine Neigung nach links den Rollwert, und eine Neigung nach rechts verringert den Rollwert.

Usage:
drivetrain.get_roll()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the roll while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_roll")
    while True:
        if drivetrain.get_roll() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_roll() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_pitch #

Der Pitch-Wert gibt an, um wie viel sich der Roboter nach vorne oder hinten neigt, gemessen in Grad. get_pitch gibt den aktuellen Pitch-Wert des Roboters zurück get_pitch.

Bei nach vorne gerichtetem Gehirn erhöht eine Neigung nach vorne den Tonhöhenwert, eine Neigung nach hinten verringert ihn.

Usage:
drivetrain.get_pitch()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the pitch while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_pitch")
    while True:
        if drivetrain.get_pitch() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_pitch() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_crashed #

get_crashed gibt als booleschen Wert zurück, ob der Roboter einen Absturz erkannt hat.

True — Ein Absturz wurde festgestellt.
False — Es wurde kein Absturz festgestellt.

Usage:
drivetrain.get_crashed()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Build Used: Super Code Base 2.0
def main():
    # Drive until a crash
    drivetrain.drive(FORWARD)
    while not drivetrain.get_crashed():
        wait(50, MSEC)
    drivetrain.stop()
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

is_stopped #

Die Funktion is_stopped gibt als booleschen Wert zurück, ob der Roboter seine Bewegung beendet hat is_stopped . 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 Antriebsmethoden, die den Parameter wait haben: drive_for, drive_until, turn_for, turn_to_heading und turn_to_rotation.

Usage:
drivetrain.is_stopped()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Build Used: Code Base 2.0
def main():
    # Turn when the drivetrain is done moving forward
    drivetrain.drive_for(FORWARD, 100, MM, wait=False)
    wait(0.25, SECONDS)
    while True:
        if drivetrain.is_stopped():
            drivetrain.turn_for(RIGHT, 180)
            break
        else:
            console.print("Still moving...")
            wait(0.1, SECONDS)
            console.clear()

# Start threads — Do not delete
start_thread(main)