Mouvement#

Introduction #

Le robot de codage VEX AIM utilise une transmission holonome pour se déplacer en avant, en arrière, à gauche, à droite ou en angle, tout en pouvant pivoter de manière autonome. Les méthodes de mouvement contrôlent ses déplacements et ses virages, sa vitesse et le suivi de ses positions x et y.

Cadran de boussole circulaire de 0 à 315 degrés entourant un écran gris foncé bleu marine. L'avant du robot est orienté vers 0 degré sur le cadran de la boussole.

Vous trouverez ci-dessous une liste des méthodes disponibles :

Actions — Déplacer et faire pivoter le robot.

move_at — Déplace le robot à un angle spécifique pour toujours.
move_for — Déplace le robot à un angle spécifique pour une distance spécifique.
move_with_vectors — Déplace le robot en utilisant des valeurs x, y et de rotation basées sur des vecteurs.
turn — Fait tourner le robot à gauche ou à droite indéfiniment.
turn_for — Tourne le robot à gauche ou à droite d’un nombre spécifique de degrés.
turn_to — Tourne le robot pour faire face à une direction spécifique.
stop_all_movement — Arrête tous les mouvements du robot.

Modificateurs — Définissent les valeurs de déplacement du robot.

set_move_velocity — Indique au robot à quelle vitesse se déplacer.
set_turn_velocity — Indique au robot à quelle vitesse tourner.
set_xy_position — Modifie la position x et y actuelle du robot à de nouvelles valeurs.

Getters — Renvoie l’état et la position du robot.

get_x_position — Renvoie la coordonnée x actuelle du robot.
get_y_position — Renvoie la coordonnée y actuelle du robot.
is_move_active — Renvoie si le robot est en mouvement.
is_turn_active — Renvoie si le robot est en train de tourner.
is_stopped — Renvoie si le robot ne bouge ni ne tourne.

Actes #

move_at #

La commande move_at déplace le robot indéfiniment selon un angle précis. Cet angle est relatif à la position actuelle du robot. Le robot continuera à se déplacer jusqu’à ce qu’une autre action lui soit donnée, comme changer d’angle, tourner ou s’arrêter.

Usage:

robot.move_at(angle, velocity, units)

Paramètres	Description
`angle`	L’angle, en degrés, de déplacement du robot. Il peut s’agir d’un nombre entier ou décimal compris entre -360 et 360.
`velocity`	Facultatif. La vitesse de déplacement, de 0 % à 100 % avec `PERCENT`, ou de 0 à 200 millimètres par seconde avec `MMPS`Il peut s’agir d’un entier ou d’un nombre décimal (flottant). Si aucune vitesse n’est spécifiée, le robot se déplace à sa vitesse actuelle.
`units`	Optionnel. L’unité de vitesse : `PERCENT` (par défaut) ou `MMPS` (millimètres par seconde).

# 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 déplace le robot selon un angle précis et sur une distance donnée. Cet angle est relatif à la position actuelle du robot. Le programme attendra la fin du déplacement avant d’exécuter la ligne de code suivante.

Usage:

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

Paramètres	Description
`distance`	Distance parcourue par le robot, en millimètres (mm). Il peut s’agir d’un entier ou d’un nombre décimal (flottant).
`angle`	L’angle, en degrés, de déplacement du robot. Il peut s’agir d’un nombre entier ou décimal compris entre -360 et 360.
`velocity`	Facultatif. La vitesse de déplacement, de 0 % à 100 % avec `PERCENT`, ou de 0 à 200 millimètres par seconde avec `MMPS`Il peut s’agir d’un entier ou d’un nombre décimal (flottant). Si aucune vitesse n’est spécifiée, le robot se déplace à sa vitesse actuelle.
`units`	Optionnel. L’unité de vitesse : `PERCENT` (par défaut) ou `MMPS` (millimètres par seconde).
`wait`	Optionnel. `wait=True` (par défaut) : le programme attend que le robot ait fini de se déplacer avant d’exécuter la ligne de code suivante. `wait=False` : la ligne de code suivante s’exécute immédiatement.

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

Un vecteur permet de décrire la vitesse et la direction d’un mouvement. La commande move_with_vectors déplace le robot à l’aide d’un mouvement vectoriel. Le robot combine les valeurs de vitesse avant, droite et de rotation pour créer un mouvement fluide. Il continuera à se déplacer selon ce vecteur jusqu’à ce qu’une autre action lui soit donnée, comme changer d’angle, tourner ou s’arrêter.

Remarque : Cette méthode définit directement les valeurs de vitesse de déplacement et de rotation, elle n’utilise donc pas set_move_velocity ni set_turn_velocity.

Usage:

robot.move_with_vectors(forward, rightward, rotation)

Paramètres	Description
`forward`	La vitesse du robot le long de l’axe y, de -100 % à 100 %. Les valeurs négatives font reculer le robot et les valeurs positives le font avancer.
`rightward`	La vitesse du robot le long de l’axe x, de -100 % à 100 %. Les valeurs négatives déplacent le robot vers la gauche et les valeurs positives le déplacent vers la droite.
`rotation`	Vitesse de rotation du robot, de -100 % à 100 %. Les valeurs négatives font tourner le robot dans le sens antihoraire et les valeurs positives dans le sens horaire.

# 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 fait tourner le robot à gauche ou à droite en continu. Il continuera de tourner jusqu’à ce qu’on lui donne une autre instruction, comme se déplacer ou s’arrêter.

Usage:

robot.turn(direction, velocity, units)

Paramètres	Description
`direction`	Direction dans laquelle le robot tourne : `LEFT` ou `RIGHT`.
`velocity`	Optionnel. La vitesse de rotation, de 0 % à 100 % avec l’option `PERCENT`, ou de 0 à 150 degrés par seconde avec l’option `DPS`Il peut s’agir d’un entier ou d’un nombre décimal (flottant). Si aucune vitesse n’est spécifiée, le robot tourne à la vitesse de rotation actuelle.
`units`	Facultatif. L’unité de vitesse : `DPS` (degrés par seconde, par défaut) ou `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 #

La fonction turn_for fait pivoter le robot vers la gauche ou la droite d’un nombre précis de degrés. Le virage est relatif à la direction actuelle du robot. Le programme attendra la fin du virage avant d’exécuter la ligne de code suivante.

Usage:

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

Paramètres	Description
`direction`	Direction dans laquelle le robot tourne : `LEFT` ou `RIGHT`.
`angle`	Le nombre de degrés de rotation du robot, compris entre -360 et 360 degrés. Il peut s’agir d’un entier ou d’un nombre décimal (flottant).
`velocity`	Optionnel. La vitesse de rotation, de 0 % à 100 % avec l’option `PERCENT`, ou de 0 à 150 degrés par seconde avec l’option `DPS`Il peut s’agir d’un entier ou d’un nombre décimal (flottant). Si aucune vitesse n’est spécifiée, le robot tourne à la vitesse de rotation actuelle.
`units`	Facultatif. L’unité de vitesse : `DPS` (degrés par seconde, par défaut) ou `PERCENT`.
`wait`	Optionnel. `wait=True` (par défaut) : le programme attend que le robot ait terminé sa rotation avant d’exécuter la ligne de code suivante. `wait=False` : la ligne de code suivante s’exécute immédiatement.

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

Le cap est la direction vers laquelle le robot est orienté, mesurée en degrés. La commande turn_to oriente le robot vers un cap précis. Le robot empruntera le chemin le plus court pour atteindre le cap cible.

Le cap initial du robot est de 0 degré.

Le projet attendra que le robot ait fini de tourner avant d’exécuter la ligne de code suivante.

Usage:

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

Paramètres	Description
`heading`	L’orientation vers laquelle le robot doit être dirigé, de -360 à 360 degrés.
`velocity`	Optionnel. La vitesse de rotation, de 0 % à 100 % avec l’option `PERCENT`, ou de 0 à 150 degrés par seconde avec l’option `DPS`Il peut s’agir d’un entier ou d’un nombre décimal (flottant). Si aucune vitesse n’est spécifiée, le robot tourne à la vitesse de rotation actuelle.
`units`	Facultatif. L’unité de vitesse : `DPS` (degrés par seconde, par défaut) ou `PERCENT`.
`wait`	Optionnel. `wait=True` (par défaut) : le programme attend que le robot ait terminé sa rotation avant d’exécuter la ligne de code suivante. `wait=False` : la ligne de code suivante s’exécute immédiatement.

# 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 arrête tous les mouvements du robot.

Usage:

robot.stop_all_movement()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

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

Mutateurs #

set_move_velocity #

La commande `set_move_velocity set_move_velocity indique au robot sa vitesse de déplacement. Un pourcentage plus élevé augmente la vitesse du robot, et un pourcentage plus faible la diminue.

Chaque projet commence par défaut avec le robot se déplaçant à 50 % de sa vitesse maximale.

Une vitesse de déplacement de 100 % équivaut à 200 millimètres par seconde.

Usage:

robot.set_move_velocity(velocity, units)

Paramètres	Description
`velocity`	La vitesse de déplacement de 0 % à 100 % lors de l’utilisation `PERCENT`, ou de 0 à 200 millimètres par seconde lors de l’utilisation `MMPS`Cela peut être un entier ou un nombre décimal (flottant).
`units`	Optionnel. L’unité de vitesse : `PERCENT` (par défaut) ou `MMPS` (millimètres par seconde).

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

La valeur set_turn_velocity indique au robot sa vitesse de rotation. Un pourcentage plus élevé accélère la rotation, et un pourcentage plus faible la ralentit.

Chaque projet commence par défaut avec le robot tournant à 50 % de sa vitesse (75 degrés par seconde).

Usage:

robot.set_turn_velocity(velocity, units)

Paramètres	Description
`velocity`	La vitesse de rotation de 0 % à 100 % lors de l’utilisation `PERCENT`, ou de 0 à 150 degrés par seconde lors de l’utilisation `DPS`Cela peut être un entier ou un nombre décimal (flottant).
`units`	Facultatif. L’unité de vitesse : `DPS` (degrés par seconde, par défaut) ou `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 #

La commande set_xy_position modifie la position actuelle x et y du robot en de nouvelles valeurs.

Par exemple, si le robot s’est éloigné de son point de départ, définir x et y à 0 fait de sa position actuelle la nouvelle position (0, 0). Le robot peut alors suivre ses positions futures à partir de cette nouvelle valeur.

Usage:

robot.set_xy_position(x, y)

Paramètres	Description
`x`	Valeur de la position x à définir pour le robot, en mm. Il peut s’agir d’un entier ou d’un nombre décimal (flottant).
`y`	Valeur de la position y à définir pour le robot, en mm. Il peut s’agir d’un entier ou d’un nombre décimal (flottant).

# 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 renvoie la coordonnée x actuelle du robot en millimètres.

Au début d’un projet, la position x du robot est définie sur 0. La position x change lorsque le robot se déplace vers la gauche ou la droite et peut être définie à l’aide de la méthode set_xy_position.

Usage:

robot.get_x_position()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

# 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 renvoie la coordonnée y actuelle du robot en millimètres.

Au début d’un projet, la position y du robot est définie sur 0. La position y change lorsque le robot avance ou recule et peut être définie à l’aide de la méthode set_xy_position.

Usage:

robot.get_y_position()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

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

La fonction is_move_active (valeur booléenne is_move_active indique si le robot est en mouvement. Cette information peut être utilisée pour contrôler le déclenchement d’autres comportements en fonction des mouvements du robot.

True — Le robot est en mouvement.
False — Le robot ne bouge pas.

Cette méthode fonctionne avec les méthodes Motion qui ont le paramètre wait , comme move_for.

Usage:

robot.is_move_active()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

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

La fonction is_turn_active (valeur booléenne : is_turn_active indique si le robot est en train de tourner. Cette information peut être utilisée pour contrôler le déclenchement d’autres comportements en fonction des mouvements du robot.

True — Le robot tourne.
False — Le robot ne tourne pas.

Cette méthode fonctionne avec les méthodes Motion qui ont le paramètre wait , telles que turn_for et turn_to.

Usage:

robot.is_turn_active()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

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

La fonction is_stopped renvoie is_stopped , indiquant si le robot est immobile ou ne tourne pas (valeur booléenne). Cette information peut servir à synchroniser d’autres actions en fonction des mouvements du robot.

True — Le robot ne bouge pas et ne tourne pas.
False — Le robot est en mouvement ou en rotation.

Usage:

robot.is_stopped()

Paramètres	Description
	Cette méthode ne comporte aucun paramètre.

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