Rörelse#

Introduktion #

VEX AIM-kodningsroboten använder en holonomisk drivlina för att röra sig framåt, bakåt, åt vänster, höger eller i en vinkel, samtidigt som den kan vrida sig oberoende. Rörelsemetoder styr hur roboten rör sig och vrider sig, hur snabbt den rör sig och hur dess x- och y-position spåras.

Cirkulär kompassratt från 0 till 315 grader runt en mörkgrå skärm med marinblå skärm. Robotens framsida är vänd mot 0 grader på kompassratten.

Nedan följer en lista över tillgängliga metoder:

Åtgärder — Flytta och vrid roboten.

move_at — Flyttar roboten i en specifik vinkel för alltid.
move_for — Flyttar roboten i en specifik vinkel för ett specifikt avstånd.
move_with_vectors — Flyttar roboten med hjälp av vektorbaserade x-, y- och rotationsvärden.
turn — Svänger roboten åt vänster eller höger för alltid.
turn_for — Svänger roboten åt vänster eller höger ett visst antal grader.
turn_to — Vrider roboten så att den riktas mot en specifik kurs.
stop_all_movement — Stoppar all robotrörelse.

Mutatorer — Ställ in robotrörelsevärden.

set_move_velocity — Anger för roboten hur snabbt den ska röra sig.
set_turn_velocity — Anger för roboten hur snabbt den ska svänga.
set_xy_position — Ändrar robotens nuvarande x- och y-position till nya värden.

Getters — Returnerar robotens tillstånd och position.

get_x_position — Returnerar robotens aktuella x-koordinat.
get_y_position — Returnerar robotens aktuella y-koordinat.
is_move_active — Returnerar om roboten rör sig.
is_turn_active — Returnerar om roboten roterar.
is_stopped — Returnerar om roboten varken rör sig eller roterar.

Åtgärder #

move_at #

move_at flyttar roboten för alltid i en specifik vinkel. Vinkeln är relativ till robotens aktuella position. Roboten fortsätter att röra sig tills den får en annan åtgärd, som att röra sig i en annan vinkel, vända eller stanna.

Användande:

robot.move_at(angle, velocity, units)

Parametrar	Beskrivning
`angle`	Vinkeln, i grader, som roboten rör sig. Detta kan vara ett heltal eller ett decimaltal från -360 till 360.
`velocity`	Valfritt. Hastigheten att röra sig med från 0 % till 100 % när `PERCENT`, eller från 0 till 200 millimeter per sekund när `MMPS`används . Detta kan vara ett heltal eller ett decimaltal (flyttal). Om ingen hastighet anges rör sig roboten med den aktuella rörelsehastigheten.
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard) eller `MMPS` (millimeter per 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 flyttar roboten i en specifik vinkel för ett specifikt avstånd. Vinkeln är relativ till robotens aktuella position. Projektet väntar tills roboten är klar med att röra sig innan nästa kodrad körs.

Användande:

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

Parametrar	Beskrivning
`distance`	Avståndet roboten rör sig i millimeter (mm). Detta kan vara ett heltal eller ett decimaltal (flyttal).
`angle`	Vinkeln, i grader, som roboten rör sig. Detta kan vara ett heltal eller ett decimaltal från -360 till 360.
`velocity`	Valfritt. Hastigheten att röra sig med från 0 % till 100 % när `PERCENT`, eller från 0 till 200 millimeter per sekund när `MMPS`används . Detta kan vara ett heltal eller ett decimaltal (flyttal). Om ingen hastighet anges rör sig roboten med den aktuella rörelsehastigheten.
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard) eller `MMPS` (millimeter per sekund).
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

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

En vektor är ett sätt att beskriva hur snabbt något rör sig och i vilken riktning det rör sig. move_with_vectors flyttar roboten med hjälp av vektorbaserad rörelse. Roboten kombinerar hastighetsvärden framåt, åt höger och rotation för att skapa en jämn rörelse. Roboten fortsätter att röra sig med hjälp av denna vektor tills den får en annan åtgärd, som att röra sig i en annan vinkel, vrida eller stanna.

Obs! Den här metoden ställer in värden för rörelse- och svänghastighet direkt, så den använder inte set_move_velocity eller set_turn_velocity.

Användande:

robot.move_with_vectors(forward, rightward, rotation)

Parametrar	Beskrivning
`forward`	Robotens hastighet längs y-axeln, från -100 % till 100 %. Negativa värden flyttar roboten bakåt och positiva värden flyttar den framåt.
`rightward`	Robotens hastighet längs x-axeln, från -100 % till 100 %. Negativa värden flyttar roboten åt vänster och positiva värden flyttar den åt höger.
`rotation`	Robotens rotationshastighet, från -100 % till 100 %. Negativa värden roterar roboten moturs och positiva värden roterar den medurs.

# 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 vrider roboten åt vänster eller höger för alltid. Roboten fortsätter att rotera tills den får en annan åtgärd, som att flytta eller stanna.

Användande:

robot.turn(direction, velocity, units)

Parametrar	Beskrivning
`direction`	Riktningen roboten svänger: `LEFT` eller `RIGHT`.
`velocity`	Valfritt. Hastigheten att rotera med är från 0 % till 100 % när `PERCENT`används, eller från 0 till 150 grader per sekund när `DPS`används. Detta kan vara ett heltal eller ett decimaltal (flyttal). Om ingen hastighet anges roterar roboten med den aktuella rotationshastigheten.
`units`	Valfritt. Hastighetsenheten: `DPS` (grader per sekund, standard) eller `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 vrider roboten åt vänster eller höger ett visst antal grader. Vridningen är relativ till den riktning roboten vänds i. Projektet väntar tills roboten är klar med att vrida sig innan nästa kodrad körs.

Användande:

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

Parametrar	Beskrivning
`direction`	Riktningen roboten svänger: `LEFT` eller `RIGHT`.
`angle`	Antalet grader som roboten roterar, från -360 till 360 grader. Detta kan vara ett heltal eller ett decimaltal (flyttal).
`velocity`	Valfritt. Hastigheten att rotera med är från 0 % till 100 % när `PERCENT`används, eller från 0 till 150 grader per sekund när `DPS`används. Detta kan vara ett heltal eller ett decimaltal (flyttal). Om ingen hastighet anges roterar roboten med den aktuella rotationshastigheten.
`units`	Valfritt. Hastighetsenheten: `DPS` (grader per sekund, standard) eller `PERCENT`.
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar med att vända innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

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

En kurs är den riktning roboten är vänd i, mätt i grader. turn_to vrider roboten mot en specifik kurs. Roboten kommer att svänga den kortaste riktningen för att nå målkursen.

Robotens startriktning är 0 grader.

Projektet väntar tills roboten är klar med att snurra innan nästa kodrad körs.

Användande:

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

Parametrar	Beskrivning
`heading`	Robotens riktning ska vara mellan -360 och 360 grader.
`velocity`	Valfritt. Hastigheten att rotera med är från 0 % till 100 % när `PERCENT`används, eller från 0 till 150 grader per sekund när `DPS`används. Detta kan vara ett heltal eller ett decimaltal (flyttal). Om ingen hastighet anges roterar roboten med den aktuella rotationshastigheten.
`units`	Valfritt. Hastighetsenheten: `DPS` (grader per sekund, standard) eller `PERCENT`.
`wait`	Valfritt. `wait=True` (standard) gör att projektet väntar tills roboten är klar med att vända innan nästa kodrad körs. `wait=False` gör att nästa kodrad körs direkt.

# 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 stoppar all robotens rörelse.

Användande:

robot.stop_all_movement()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

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

Mutatorer #

set_move_velocity #

set_move_velocity anger hur snabbt roboten ska röra sig. En högre procentandel gör att roboten rör sig snabbare och en lägre procentandel gör att roboten rör sig långsammare.

Varje projekt börjar med att roboten rör sig med 50 % hastighet som standard.

En rörelsehastighet på 100 % motsvarar 200 millimeter per sekund.

Användande:

robot.set_move_velocity(velocity, units)

Parametrar	Beskrivning
`velocity`	Hastigheten att röra sig med från 0 % till 100 % när `PERCENT`, eller från 0 till 200 millimeter per sekund när `MMPS`används. Detta kan vara ett heltal eller ett decimaltal (flyttal).
`units`	Valfritt. Hastighetsenheten: `PERCENT` (standard) eller `MMPS` (millimeter per 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 anger hur snabbt roboten ska snurra. En högre procentandel gör att roboten snurrar snabbare och en lägre procentandel gör att roboten snurrar långsammare.

Varje projekt börjar med att roboten roterar med 50 % hastighet (75 grader per sekund) som standard.

Användande:

robot.set_turn_velocity(velocity, units)

Parametrar	Beskrivning
`velocity`	Hastigheten att rotera med från 0 % till 100 % när `PERCENT`används, eller från 0 till 150 grader per sekund när `DPS`används. Detta kan vara ett heltal eller ett decimaltal (flyttal).
`units`	Valfritt. Hastighetsenheten: `DPS` (grader per sekund, standard) eller `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 ändrar robotens nuvarande x- och y-position till nya värden.

Om roboten till exempel har rört sig bort från sin startpunkt, och om x sätts till 0 och y sätts till 0, blir robotens nuvarande position den nya 0,0-positionen. Då kan roboten spåra framtida positioner baserat på det nya värdet.

Användande:

robot.set_xy_position(x, y)

Parametrar	Beskrivning
`x`	X-positionsvärdet som ska ställas in för roboten, i mm. Detta kan vara ett heltal eller ett decimaltal (flyttal).
`y`	Y-positionsvärdet som ska ställas in för roboten, i mm. Detta kan vara ett heltal eller ett decimaltal (flyttal).

# 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 returnerar robotens aktuella x-koordinat i millimeter.

I början av ett projekt sätts robotens x-position till 0. X-positionen ändras när roboten rör sig åt vänster eller höger och kan ställas in med metoden set_xy_position.

Användande:

robot.get_x_position()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# 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 returnerar robotens aktuella y-koordinat i millimeter.

I början av ett projekt sätts robotens y-position till 0. Y-positionen ändras när roboten rör sig framåt eller bakåt och kan ställas in med metoden set_xy_position.

Användande:

robot.get_y_position()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# 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 returnerar huruvida roboten rör sig, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på robotens rörelse.

True — Roboten rör sig.
False — Roboten rör sig inte.

Den här metoden fungerar tillsammans med Motion-metoder som har parametern wait , såsom move_for.

Användande:

robot.is_move_active()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# 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 returnerar huruvida roboten roterar, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på robotens rörelse.

True — Roboten snurrar.
False — Roboten snurrar inte.

Den här metoden fungerar tillsammans med rörelsemetoder som har parametern wait , såsom turn_for och turn_to.

Användande:

robot.is_turn_active()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

# 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 returnerar huruvida roboten varken rör sig eller roterar, som ett booleskt värde. Detta kan användas för att styra tidpunkten för andra beteenden baserat på robotens rörelse.

True — Roboten rör sig eller roterar inte.
False — Roboten rör sig eller roterar.

Användande:

robot.is_stopped()

Parametrar	Beskrivning
	Den här metoden har inga parametrar.

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