Bewegung#

Einführung #

Der VEX AIM Programmierroboter nutzt einen holonomen Antriebsstrang, um sich vorwärts, rückwärts, links, rechts oder schräg zu bewegen und sich dabei auch selbstständig zu drehen. Bewegungsmethoden steuern die Art der Bewegung und Drehung des Roboters, seine Geschwindigkeit und die Erfassung seiner x- und y-Position.

Kreisförmiger Kompass von 0 bis 315 Grad umgibt ein dunkelgraues Display mit marineblauem Bildschirm. Die Vorderseite des Roboters zeigt auf 0 Grad des Kompasses.

Nachfolgend finden Sie eine Liste der verfügbaren Methoden:

Aktionen – Den Roboter bewegen und drehen.

move_at — Bewegt den Roboter unendlich lange in einem bestimmten Winkel.
move_for — Bewegt den Roboter in einem bestimmten Winkel über eine bestimmte Distanz.
move_with_vectors — Bewegt den Roboter unter Verwendung von vektorbasierten x-, y- und Rotationswerten.
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 — Dreht den Roboter in eine bestimmte Richtung.
stop_all_movement — Stoppt alle Bewegungen des Roboters.

Mutatoren – Legen Sie die Bewegungswerte des Roboters fest.

set_move_velocity — Sagt dem Roboter, wie schnell er sich bewegen soll.
set_turn_velocity — Sagt dem Roboter, wie schnell er sich drehen soll.
set_xy_position — Ändert die aktuelle x- und y-Position des Roboters auf neue Werte.

Getter – Geben den Roboterzustand und die Position zurück.

get_x_position — Gibt die aktuelle x-Koordinate des Roboters zurück.
get_y_position — Gibt die aktuelle y-Koordinate des Roboters zurück.
is_move_active — Gibt zurück, ob sich der Roboter bewegt.
is_turn_active — Gibt zurück, ob sich der Roboter dreht.
is_stopped — Gibt zurück, ob sich der Roboter weder bewegt noch dreht.

Aktionen #

move_at #

Der Befehl move_at bewegt den Roboter in einem bestimmten Winkel, der sich auf die aktuelle Position des Roboters bezieht. Der Roboter bewegt sich so lange, bis er eine andere Aktion erhält, z. B. eine Bewegung in einem anderen Winkel, eine Drehung oder einen Stopp.

Verwendung:

robot.move_at(angle, velocity, units)

Parameter	Beschreibung
`angle`	Der Winkel, in Grad, um den sich der Roboter bewegt. Dies kann eine ganze Zahl oder eine Dezimalzahl zwischen -360 und 360 sein.
`velocity`	Optional. Die Bewegungsgeschwindigkeit (0 % bis 100 % bei Verwendung `PERCENT`bzw. (0 bis 200 mm/s bei Verwendung `MMPS`. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein. Wird keine Geschwindigkeit angegeben, bewegt sich der Roboter mit der aktuellen Geschwindigkeit.
`units`	Optional. Die Geschwindigkeitseinheit: `PERCENT` (Standard) oder `MMPS` (Millimeter pro Sekunde).

# Move right, then move forward and stop.
robot.move_at(90)
wait(1,SECONDS)
robot.move_at(0)
wait(1,SECONDS)
robot.stop_all_movement()

# Move right slowly, move in reverse quickly and stop.
robot.move_at(90, 25)
wait(2, SECONDS)
robot.move_at(180, 100, PERCENT)
wait(1, SECONDS)
robot.stop_all_movement()

# Move diagonally to the right and stop.
robot.move_at(45.33)
wait(1,SECONDS)
robot.stop_all_movement()

move_for #

move_for bewegt den Roboter um einen bestimmten Winkel über eine bestimmte Distanz. Der Winkel ist relativ zur aktuellen Position des Roboters. Das Projekt wartet, bis der Roboter die Bewegung abgeschlossen hat, bevor die nächste Codezeile ausgeführt wird.

Verwendung:

robot.move_for(distance, angle, velocity, units, wait)

Parameter	Beschreibung
`distance`	Die vom Roboter zurückgelegte Strecke in Millimetern (mm). Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein.
`angle`	Der Winkel, in Grad, um den sich der Roboter bewegt. Dies kann eine ganze Zahl oder eine Dezimalzahl zwischen -360 und 360 sein.
`velocity`	Optional. Die Bewegungsgeschwindigkeit (0 % bis 100 % bei Verwendung `PERCENT`bzw. (0 bis 200 mm/s bei Verwendung `MMPS`. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein. Wird keine Geschwindigkeit angegeben, bewegt sich der Roboter mit der aktuellen Geschwindigkeit.
`units`	Optional. Die Geschwindigkeitseinheit: `PERCENT` (Standard) oder `MMPS` (Millimeter pro Sekunde).
`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.

# Move right, then move forward.
robot.move_for(50, 90)
robot.move_for(100, 0)

# Move in reverse slowly, then move forward quickly.
robot.move_for(100, 180, 25)
robot.move_for(100, 0, 100, PERCENT)

# Drive forward and blink all LEDs red.
robot.move_for(100, 0, wait=False)
robot.led.on(ALL_LEDS, RED)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, BLACK)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, RED)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, BLACK)

move_with_vectors #

Ein Vektor beschreibt die Geschwindigkeit und die Richtung einer Bewegung. Der Wert move_with_vectors (Bewegung mit Vektoren) bewegt den Roboter mithilfe einer Vektorbewegung. Dabei werden Vorwärts-, Rechts- und Rotationsgeschwindigkeit kombiniert, um eine flüssige Bewegung zu erzeugen. Der Roboter bewegt sich so lange mit diesem Vektor, bis er eine andere Anweisung erhält, z. B. eine Änderung des Winkels, eine Drehung oder das Anhalten.

Hinweis: Diese Methode setzt die Werte für Bewegungs- und Drehgeschwindigkeit direkt, daher verwendet sie nicht set_move_velocity oder set_turn_velocity.

Verwendung:

robot.move_with_vectors(forward, rightward, rotation)

Parameter	Beschreibung
`forward`	Die Geschwindigkeit des Roboters entlang der y-Achse, von -100 % bis 100 %. Negative Werte bewegen den Roboter rückwärts, positive Werte vorwärts.
`rightward`	Die Geschwindigkeit des Roboters entlang der x-Achse, von -100 % bis 100 %. Negative Werte bewegen den Roboter nach links, positive Werte nach rechts.
`rotation`	Die Drehgeschwindigkeit des Roboters, von -100 % bis 100 %. Negative Werte bewirken eine Drehung des Roboters gegen den Uhrzeigersinn, positive Werte eine Drehung im Uhrzeigersinn.

# Move at 15°
robot.move_with_vectors(48.3, 12.95, 0)
wait(2, SECONDS)
robot.stop_all_movement()

# Move at 45° while turning counterclockwise.
robot.move_with_vectors(50, 50, -30)
wait(2, SECONDS)
robot.stop_all_movement()

# Scaling movement using the controller joystick
while True:
    # Move forward (and backwards) slower than axis1 input
    forward   = controller.axis1.position() * 0.7
    
    # Move right (and left) faster than axis2 input
    rightward = controller.axis2.position() * 1.5    

    robot.move_with_vectors(forward, rightward, 0)

    wait(5, MSEC)

turn #

turn dreht ihn endlos nach links oder rechts. Der Roboter dreht sich so lange, bis er eine andere Aktion erhält, z. B. sich bewegen oder anhalten.

Verwendung:

robot.turn(direction, velocity, units)

Parameter	Beschreibung
`direction`	Die Richtung, in die sich der Roboter dreht: `LEFT` oder `RIGHT`.
`velocity`	Optional. Die Drehgeschwindigkeit (0 % bis 100 % bei Verwendung `PERCENT`bzw. (0 bis 150 Grad pro Sekunde bei Verwendung `DPS`. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein. Wird keine Geschwindigkeit angegeben, dreht sich der Roboter mit der aktuellen Drehgeschwindigkeit.
`units`	Optional. Die Geschwindigkeitseinheit: `DPS` (Grad pro Sekunde, Standard) oder `PERCENT`.

# Turn left, then stop.
robot.turn(LEFT)
wait(1, SECONDS)
robot.stop_all_movement()

# Turn left quickly, turn right slowly, then stop.
robot.turn(LEFT, 80)
wait(2, SECONDS)
robot.turn(RIGHT, 20, PERCENT)
wait(3, SECONDS)
robot.stop_all_movement()

turn_for #

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

Verwendung:

robot.turn_for(direction, angle, velocity, units, wait)

Parameter	Beschreibung
`direction`	Die Richtung, in die sich der Roboter dreht: `LEFT` oder `RIGHT`.
`angle`	Die Gradzahl, um die sich der Roboter dreht, im Bereich von -360 bis 360 Grad. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein.
`velocity`	Optional. Die Drehgeschwindigkeit (0 % bis 100 % bei Verwendung `PERCENT`bzw. (0 bis 150 Grad pro Sekunde bei Verwendung `DPS`. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein. Wird keine Geschwindigkeit angegeben, dreht sich der Roboter mit der aktuellen Drehgeschwindigkeit.
`units`	Optional. Die Geschwindigkeitseinheit: `DPS` (Grad pro Sekunde, Standard) oder `PERCENT`.
`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.

# Turn left, then turn around to the right.
robot.turn_for(LEFT, 90)
robot.turn_for(RIGHT, 180)

# Turn left quickly, then turn right slowly.
robot.turn_for(LEFT, 90, 100)
robot.turn_for(RIGHT, 180, 15, PERCENT)

# Turn right and blink all LEDs blue.
robot.turn_for(RIGHT, 180, wait=False)
robot.led.on(ALL_LEDS, BLUE)
wait(0.5, SECONDS)
robot.led.off(ALL_LEDS)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, BLUE)
wait(0.5, SECONDS)
robot.led.off(ALL_LEDS)

turn_to #

Die Ausrichtung des Roboters wird in Grad gemessen. turn_to dreht den Roboter in eine bestimmte Richtung. Der Roboter wählt dabei 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.

Verwendung:

robot.turn_to(heading, velocity, units, wait)

Parameter	Beschreibung
`heading`	Die Richtung, in die der Roboter zeigen sollte, von -360 bis 360 Grad.
`velocity`	Optional. Die Drehgeschwindigkeit (0 % bis 100 % bei Verwendung `PERCENT`bzw. (0 bis 150 Grad pro Sekunde bei Verwendung `DPS`. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein. Wird keine Geschwindigkeit angegeben, dreht sich der Roboter mit der aktuellen Drehgeschwindigkeit.
`units`	Optional. Die Geschwindigkeitseinheit: `DPS` (Grad pro Sekunde, Standard) oder `PERCENT`.
`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.

# Turn to face each cardinal directions.
robot.turn_to(90)
wait(2, SECONDS)
robot.turn_to(180)
wait(2, SECONDS)
robot.turn_to(270)
wait(2, SECONDS)
robot.turn_to(0)

# Turn to face backward slowly, then face forward quickly.
robot.turn_to(180, 25)
wait(1, SECONDS)
robot.turn_to(0, 90, PERCENT)

# Turn around quickly and blink all LEDs green.
robot.turn_to(180, 100, wait=False)
robot.led.on(ALL_LEDS, GREEN)
wait(0.5, SECONDS)
robot.led.off(ALL_LEDS)
wait(0.5, SECONDS)
robot.led.on(ALL_LEDS, GREEN)
wait(0.5, SECONDS)
robot.led.off(ALL_LEDS)

stop_all_movement #

stop_all_movement stoppt jegliche Bewegung des Roboters.

Verwendung:

robot.stop_all_movement()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Turn right, then stop moving
robot.turn(RIGHT)
wait(1, SECONDS)
robot.stop_all_movement()

Mutatoren #

set_move_velocity #

Der Wert set_move_velocity gibt dem Roboter die Bewegungsgeschwindigkeit vor. Ein höherer Prozentsatz beschleunigt den Roboter, ein niedrigerer verlangsamt ihn.

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

Eine Bewegungsgeschwindigkeit von 100 % entspricht 200 Millimetern pro Sekunde.

Verwendung:

robot.set_move_velocity(velocity, units)

Parameter	Beschreibung
`velocity`	Die Geschwindigkeit, mit der man sich von 0 % auf 100 % bewegt, wenn man `PERCENT`verwendet, oder von 0 auf 200 Millimeter pro Sekunde, wenn man `MMPS`verwendet. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein.
`units`	Optional. Die Geschwindigkeitseinheit: `PERCENT` (Standard) oder `MMPS` (Millimeter pro Sekunde).

# Move forward at the default velocity,
robot.set_move_velocity(50)
robot.move_for(100, 0)
wait(1, SECONDS)
# Move slower than the default velocity
robot.set_move_velocity(20)
robot.move_for(100, 0)
wait(1, SECONDS)
# Move faster than the default velocity
robot.set_move_velocity(100)
robot.move_for(100, 0)

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 (75 Grad pro Sekunde) dreht.

Verwendung:

robot.set_turn_velocity(velocity, units)

Parameter	Beschreibung
`velocity`	Die Geschwindigkeit, mit der von 0 % auf 100 % gedreht wird, wenn `PERCENT`verwendet wird, oder von 0 bis 150 Grad pro Sekunde, wenn `DPS`verwendet wird. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein.
`units`	Optional. Die Geschwindigkeitseinheit: `DPS` (Grad pro Sekunde, Standard) oder `PERCENT`.

# Turn around at default velocity
robot.set_turn_velocity(50)
robot.turn_for(RIGHT, 180)
wait(1, SECONDS)
# Turn around slower than the default velocity
robot.set_turn_velocity(20)
robot.turn_for(RIGHT, 180)
wait(1, SECONDS)
# Turn around faster than the default velocity
robot.set_turn_velocity(100)
robot.turn_for(RIGHT, 180)

set_xy_position #

set_xy_position ändert die aktuelle x- und y-Position des Roboters auf neue Werte.

Hat sich der Roboter beispielsweise von seinem Startpunkt entfernt, so wird durch Setzen von x und y auf 0 seine aktuelle Position zur neuen Position (0, 0). Anschließend kann der Roboter zukünftige Positionen anhand dieses neuen Wertes berechnen.

Verwendung:

robot.set_xy_position(x, y)

Parameter	Beschreibung
`x`	Der für den Roboter einzustellende x-Positionswert in mm. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein.
`y`	Der für den Roboter einzustellende y-Positionswert in mm. Dies kann eine ganze Zahl oder eine Dezimalzahl (Gleitkommazahl) sein.

# Set the robot's current position
# Move forward and print the new coordinate
robot.set_xy_position(100, 50)
robot.move_for(150, 0)
robot.screen.print("X:", robot.get_x_position())
robot.screen.next_row()
robot.screen.print("Y:", robot.get_y_position())

Getter #

get_x_position #

get_x_position gibt die aktuelle x-Koordinate des Roboters in Millimetern zurück.

Zu Beginn eines Projekts wird die x-Position des Roboters auf 0 gesetzt. Die x-Position ändert sich, wenn sich der Roboter nach links oder rechts bewegt und kann mit der Methode set_xy_position eingestellt werden.

Verwendung:

robot.get_x_position()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Print the start and end x-value 
# of the robot's position after moving
robot.screen.print("Start X:", robot.get_x_position())
robot.move_for(200, 90)
robot.screen.next_row()
robot.screen.print("End X:", robot.get_x_position())

get_y_position #

get_y_position gibt die aktuelle y-Koordinate des Roboters in Millimetern zurück.

Zu Beginn eines Projekts wird die y-Position des Roboters auf 0 gesetzt. Die y-Position ändert sich, wenn sich der Roboter vorwärts oder rückwärts bewegt und kann mit der Methode set_xy_position eingestellt werden.

Verwendung:

robot.get_y_position()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Print the start and end y-value 
# of the robot's position after moving
robot.screen.print("Start Y:", robot.get_y_position())
robot.move_for(200, 0)
robot.screen.next_row()
robot.screen.print("End Y:", robot.get_y_position())

is_move_active #

Die Funktion is_move_active gibt als booleschen Wert zurück, ob sich der Roboter bewegt is_move_active . 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.

Diese Methode funktioniert zusammen mit Motion-Methoden, die den Parameter wait haben, wie zum Beispiel move_for.

Verwendung:

robot.is_move_active()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Blink all the LEDs when the robot is moving.
robot.move_for(200, 0, wait=False)

while robot.is_move_active():
    robot.led.on(ALL_LEDS, ORANGE)
    wait(0.5, SECONDS)
    robot.led.on(ALL_LEDS, CYAN)
    wait(0.5, SECONDS)

robot.led.off(ALL_LEDS)

is_turn_active #

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

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

Diese Methode funktioniert zusammen mit Motion-Methoden, die den Parameter wait haben, wie zum Beispiel turn_for und turn_to.

Verwendung:

robot.is_turn_active()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Blink all the LEDs while the robot is turning
robot.turn_for(RIGHT, 180, wait=False) 

while robot.is_turn_active():
    robot.led.on(ALL_LEDS, GREEN)
    wait(0.5, SECONDS)
    robot.led.on(ALL_LEDS, CYAN)
    wait(0.5, SECONDS)

robot.led.off(ALL_LEDS)

is_stopped #

Der Wert is_stopped gibt als booleschen Wert an, ob sich der Roboter weder bewegt noch dreht. Dieser Wert kann verwendet werden, um den Zeitpunkt anderer Verhaltensweisen basierend auf der Bewegung des Roboters zu steuern.

True — Der Roboter bewegt sich nicht und dreht sich nicht.
False — Der Roboter bewegt sich oder dreht sich.

Verwendung:

robot.is_stopped()

Parameter	Beschreibung
	Diese Methode hat keine Parameter.

# Blink all the LEDs while the robot is moving or turning

def light_show():
    # Flash LEDs while the robot is moving or turning
    while not robot.is_stopped():
        robot.led.on(ALL_LEDS, GREEN)
        wait(.5, SECONDS)
        robot.led.on(ALL_LEDS, PURPLE)
        wait(.5, SECONDS)

    robot.led.off(ALL_LEDS)

robot.move_for(200, 0, wait=False)
light_show()

robot.turn_for(RIGHT, 180, wait=False)
light_show()