Ruch#

Wstęp #

Robot VEX AIM Coding wykorzystuje holonomiczny układ napędowy do poruszania się do przodu, do tyłu, w lewo, w prawo lub pod kątem, a także do niezależnego skręcania. Metody ruchu kontrolują sposób poruszania się i skręcania robota, jego prędkość oraz śledzenie jego położenia X i Y.

Okrągła tarcza kompasu od 0 do 315 stopni otacza ciemnoszary wyświetlacz z granatowym ekranem. Przód robota jest skierowany w stronę 0 stopni na tarczy kompasu.

Poniżej znajduje się lista dostępnych metod:

Akcje — poruszanie i obracanie robotem.

move_at — Przesuwa robota pod określonym kątem w nieskończoność.
move_for — Przesuwa robota pod określonym kątem na określoną odległość.
move_with_vectors — Przesuwa robota, wykorzystując wartości x, y i obrotu oparte na wektorach.
turn — Obraca robota w lewo lub prawo na zawsze.
turn_for — Obraca robota w lewo lub prawo o określoną liczbę stopni.
turn_to — Obraca robota w kierunku określonego kierunku.
stop_all_movement — Zatrzymuje cały ruch robota.

Mutatory — ustawiają wartości ruchu robota.

set_move_velocity — Informuje robota, jak szybko ma się poruszać.
set_turn_velocity — Informuje robota, jak szybko ma skręcić.
set_xy_position — Zmienia bieżącą pozycję x i y robota na nowe wartości.

Gettery — zwracają stan i pozycję robota.

get_x_position — Zwraca aktualną współrzędną x robota.
get_y_position — Zwraca aktualną współrzędną y robota.
is_move_active — Zwraca informację, czy robot się porusza.
is_turn_active — Zwraca informację, czy robot się obraca.
is_stopped — Zwraca informację, czy robot nie porusza się ani nie obraca.

Akcje #

move_at #

move_at porusza robota w nieskończoność pod określonym kątem. Kąt jest względny do aktualnej pozycji robota. Robot będzie się poruszał, dopóki nie zostanie mu przydzielona inna czynność, taka jak ruch pod innym kątem, obrót lub zatrzymanie.

Stosowanie:

robot.move_at(angle, velocity, units)

Parametry	Opis
`angle`	Kąt, pod jakim porusza się robot, wyrażony w stopniach. Może to być liczba całkowita lub dziesiętna od -360 do 360.
`velocity`	Opcjonalnie. Prędkość ruchu od 0% do 100% przy użyciu `PERCENT`lub od 0 do 200 milimetrów na sekundę przy użyciu `MMPS`. Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa). Jeśli prędkość nie zostanie podana, robot porusza się z bieżącą prędkością ruchu.
`units`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie) lub `MMPS` (milimetry na sekundę).

# 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 przesuwa robota pod określonym kątem na określoną odległość. Kąt jest względny do aktualnej pozycji robota. Projekt będzie czekał, aż robot zakończy ruch, zanim uruchomi się kolejny wiersz kodu.

Stosowanie:

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

Parametry	Opis
`distance`	Odległość, na jaką pokonuje robot, w milimetrach (mm). Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa).
`angle`	Kąt, pod jakim porusza się robot, wyrażony w stopniach. Może to być liczba całkowita lub dziesiętna od -360 do 360.
`velocity`	Opcjonalnie. Prędkość ruchu od 0% do 100% przy użyciu `PERCENT`lub od 0 do 200 milimetrów na sekundę przy użyciu `MMPS`. Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa). Jeśli prędkość nie zostanie podana, robot porusza się z bieżącą prędkością ruchu.
`units`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie) lub `MMPS` (milimetry na sekundę).
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot zakończy ruch, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

# 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 #

Wektor to sposób opisujący, jak szybko coś się porusza i w jakim kierunku. move_with_vectors porusza robota za pomocą ruchu wektorowego. Robot łączy wartości prędkości do przodu, w prawo i obrotu, aby zapewnić płynny ruch. Robot będzie kontynuował ruch za pomocą tego wektora, dopóki nie otrzyma innej akcji, takiej jak ruch pod innym kątem, obrót lub zatrzymanie.

Uwaga: Ta metoda bezpośrednio ustawia wartości prędkości ruchu i obrotu, dlatego nie używa set_move_velocity ani set_turn_velocity.

Stosowanie:

robot.move_with_vectors(forward, rightward, rotation)

Parametry	Opis
`forward`	Prędkość robota wzdłuż osi Y, od -100% do 100%. Wartości ujemne przesuwają robota do tyłu, a dodatnie do przodu.
`rightward`	Prędkość robota wzdłuż osi X od -100% do 100%. Wartości ujemne przesuwają robota w lewo, a dodatnie w prawo.
`rotation`	Prędkość obrotowa robota od -100% do 100%. Wartości ujemne obracają robota przeciwnie do ruchu wskazówek zegara, a wartości dodatnie zgodnie z ruchem wskazówek zegara.

# 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 obraca robota w lewo lub w prawo w nieskończoność. Robot będzie się obracał, dopóki nie otrzyma innej akcji, takiej jak ruch lub zatrzymanie.

Stosowanie:

robot.turn(direction, velocity, units)

Parametry	Opis
`direction`	Kierunek, w którym obraca się robot: `LEFT` lub `RIGHT`.
`velocity`	Opcjonalnie. Prędkość obrotu od 0% do 100% przy użyciu `PERCENT`lub od 0 do 150 stopni na sekundę przy użyciu `DPS`. Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa). Jeśli prędkość nie zostanie podana, robot obraca się z aktualną prędkością obrotu.
`units`	Opcjonalnie. Jednostka prędkości: `DPS` (stopnie na sekundę, domyślnie) lub `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 #

turn_for obraca robota w lewo lub w prawo o określoną liczbę stopni. Obrót jest względny w stosunku do aktualnego kierunku, w którym zwrócony jest robot. Projekt będzie czekał, aż robot zakończy obrót, zanim uruchomi się kolejny wiersz kodu.

Stosowanie:

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

Parametry	Opis
`direction`	Kierunek, w którym obraca się robot: `LEFT` lub `RIGHT`.
`angle`	Liczba stopni, o jaką obraca się robot, od -360 do 360 stopni. Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa).
`velocity`	Opcjonalnie. Prędkość obrotu od 0% do 100% przy użyciu `PERCENT`lub od 0 do 150 stopni na sekundę przy użyciu `DPS`. Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa). Jeśli prędkość nie zostanie podana, robot obraca się z aktualną prędkością obrotu.
`units`	Opcjonalnie. Jednostka prędkości: `DPS` (stopnie na sekundę, domyślnie) lub `PERCENT`.
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot skończy się obracać, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

# 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 #

Kierunek to kierunek, w którym zwrócony jest robot, mierzony w stopniach. turn_to obraca robota w określonym kierunku. Robot obróci się w najkrótszym kierunku, aby osiągnąć docelowy kierunek.

Początkowy kierunek robota wynosi 0 stopni.

Projekt będzie czekał, aż robot zakończy obracanie się, zanim zostanie uruchomiony kolejny wiersz kodu.

Stosowanie:

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

Parametry	Opis
`heading`	Kierunek, w którym powinien być zwrócony robot, od -360 do 360 stopni.
`velocity`	Opcjonalnie. Prędkość obrotu od 0% do 100% przy użyciu `PERCENT`lub od 0 do 150 stopni na sekundę przy użyciu `DPS`. Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa). Jeśli prędkość nie zostanie podana, robot obraca się z aktualną prędkością obrotu.
`units`	Opcjonalnie. Jednostka prędkości: `DPS` (stopnie na sekundę, domyślnie) lub `PERCENT`.
`wait`	Opcjonalnie. `wait=True` (domyślnie) powoduje, że projekt czeka, aż robot skończy się obracać, zanim zostanie wykonany kolejny wiersz kodu. `wait=False` powoduje, że następny wiersz kodu zostanie wykonany natychmiast.

# 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 zatrzymuje cały ruch robota.

Stosowanie:

robot.stop_all_movement()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

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

Mutatory #

set_move_velocity #

set_move_velocity określa prędkość ruchu robota. Wyższy procent powoduje, że robot porusza się szybciej, a niższy – wolniej.

Każdy projekt rozpoczyna się od tego, że robot domyślnie porusza się z prędkością równą 50%.

Prędkość ruchu wynosząca 100% odpowiada 200 milimetrom na sekundę.

Stosowanie:

robot.set_move_velocity(velocity, units)

Parametry	Opis
`velocity`	Prędkość, z jaką można się poruszać, od 0% do 100% przy użyciu `PERCENT`lub od 0 do 200 milimetrów na sekundę przy użyciu `MMPS`. Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa).
`units`	Opcjonalnie. Jednostka prędkości: `PERCENT` (domyślnie) lub `MMPS` (milimetry na sekundę).

# 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 #

set_turn_velocity określa, jak szybko robot ma się skręcić. Wyższy procent powoduje, że robot skręca szybciej, a niższy – że skręca wolniej.

Każdy projekt rozpoczyna się od ustawienia robota tak, aby domyślnie obracał się z prędkością równą 50% prędkości (75 stopni na sekundę).

Stosowanie:

robot.set_turn_velocity(velocity, units)

Parametry	Opis
`velocity`	Prędkość obrotu od 0% do 100% przy użyciu opcji `PERCENT`lub od 0 do 150 stopni na sekundę przy użyciu opcji `DPS`Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa).
`units`	Opcjonalnie. Jednostka prędkości: `DPS` (stopnie na sekundę, domyślnie) lub `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 zmienia bieżącą pozycję x i y robota na nowe wartości.

Na przykład, jeśli robot oddalił się od punktu początkowego, ustawienie x na 0 i y na 0 spowoduje, że bieżąca lokalizacja robota stanie się nową pozycją 0, 0. Następnie robot może śledzić przyszłe pozycje na podstawie tej nowej wartości.

Stosowanie:

robot.set_xy_position(x, y)

Parametry	Opis
`x`	Wartość pozycji x do ustawienia dla robota w mm. Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa).
`y`	Wartość pozycji y do ustawienia dla robota w mm. Może to być liczba całkowita lub dziesiętna (zmiennoprzecinkowa).

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

Getters #

get_x_position #

get_x_position zwraca aktualną współrzędną x robota w milimetrach.

Na początku projektu położenie x robota jest ustawione na 0. Położenie x zmienia się, gdy robot porusza się w lewo lub w prawo i można je ustawić za pomocą metody set_xy_position.

Stosowanie:

robot.get_x_position()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

# 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 zwraca aktualną współrzędną y robota w milimetrach.

Na początku projektu położenie y robota jest ustawione na 0. Położenie y zmienia się w miarę ruchu robota do przodu lub do tyłu i można je ustawić za pomocą metody set_xy_position.

Stosowanie:

robot.get_y_position()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

# 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 #

is_move_active zwraca wartość logiczną, czy robot się porusza. Można jej użyć do kontrolowania czasu innych zachowań na podstawie ruchu robota.

True — Robot się porusza.
False — Robot się nie porusza.

Ta metoda działa w połączeniu z metodami Motion, które mają parametr wait wait , na przykład move_for.

Stosowanie:

robot.is_move_active()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

# 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 #

is_turn_active zwraca wartość logiczną, czy robot się obraca. Można jej użyć do sterowania czasem innych zachowań na podstawie ruchu robota.

True — Robot się obraca.
False — Robot się nie obraca.

Ta metoda działa w połączeniu z metodami Motion, które mają parametr wait wait , takimi jak turn_for i turn_to.

Stosowanie:

robot.is_turn_active()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

# 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 #

is_stopped zwraca wartość logiczną, czy robot się nie porusza ani nie obraca. Można jej użyć do sterowania czasem innych zachowań na podstawie ruchu robota.

True — Robot nie porusza się i nie obraca.
False — Robot porusza się lub obraca.

Stosowanie:

robot.is_stopped()

Parametry	Opis
	Ta metoda nie ma żadnych parametrów.

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