Mouvement#

Introduction #

Motors control how parts of a robot move. Motors can be used to raise an arm, turn a claw, spin a wheel, or move another part of a build. Two motors can work together as a drivetrain to move and turn the whole robot.

Chaque moteur est configuré dans la fenêtre « Périphériques ». Selon la version, le nom des moteurs peut varier. Par exemple, la version « Competition Advanced 2.0 » possède un moteur nommé arm_motor. Un robot personnalisé peut utiliser des noms de moteurs différents.

Par défaut, la touche FORWARD fait tourner le moteur dans le sens antihoraire, et la touche REVERSE le fait tourner dans le sens horaire. Si l’inversion du sens de rotation d’un moteur est activée dans la fenêtre « Périphériques », ces sens seront inversés.

Un moteur VEX GO montrant le sens de rotation avant indiqué par un signe plus et une flèche indiquant qu'il tourne vers la gauche, ou dans le sens antihoraire.

Un moteur VEX GO montrant le sens inverse indiqué par un signe moins et une flèche indiquant qu'il tourne vers la droite, ou dans le sens horaire.

Il existe de nombreuses façons de programmer des moteurs. Vous trouverez ci-dessous la liste de toutes les méthodes de programmation de mouvement :

Actions — Arrêter et faire tourner les moteurs.

spin — Fait tourner un moteur en avant ou en arrière indéfiniment.
spin_for — Fait tourner un moteur sur une distance spécifique.
spin_to_position — Fait tourner un moteur jusqu’à une position spécifique.
stop — Empêche un moteur de tourner.

Modificateurs — Ajustez les paramètres du moteur.

set_velocity — Indique à un moteur à quelle vitesse tourner.
set_max_torque — Définit la force avec laquelle un moteur est autorisé à pousser pendant la rotation.
set_position — Change la position actuelle du moteur à une nouvelle valeur.
set_stopping — Définit comment un moteur s’arrêtera de bouger : en freinant, en laissant la roue libre ou en maintenant.
set_timeout — Définit le temps pendant lequel un moteur essaiera de terminer un mouvement.

Getters — Vérifiez l’état du moteur.

get_position — Renvoie la position actuelle du moteur.
get_velocity — Renvoie la vitesse de rotation du moteur, en pourcentage de -100 % à 100 %.
get_current — Renvoie la quantité de puissance que le moteur utilise à partir de la batterie, en pourcentage de 0 % à 100 %.
is_stopped — Renvoie si le moteur a fini de bouger, sous forme de valeur booléenne.
is_moving — Renvoie si le moteur tourne, sous forme de valeur booléenne.

Actes #

spin #

La valeur spin fait tourner le moteur en marche avant ou arrière indéfiniment. Le moteur continuera de tourner jusqu’à ce qu’une autre action lui soit donnée, comme changer de sens de rotation ou s’arrêter.

Usage:
arm_motor.spin(direction)

Paramètres	Description
`direction`	Sens de rotation du moteur : `FORWARD` ou `REVERSE`.

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor, then stop
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

spin_for #

La fonction spin_for fait tourner un moteur sur une distance spécifique, relative à sa position actuelle. Le programme attendra la fin de la rotation avant d’exécuter la ligne de code suivante.

Usage:
arm_motor.spin_for(direction, angle, units, wait)

Paramètres	Description
`direction`	Sens de rotation du moteur : `FORWARD` ou `REVERSE`.
`angle`	Distance de rotation du moteur. `DEGREES` : utiliser des nombres entiers. `TURNS` : utiliser des nombres entiers ou décimaux.
`units`	Facultatif. L’unité de distance : `DEGREES` (par défaut) ou `TURNS`.
`wait`	Optionnel. `wait=True` (par défaut) : le projet attend que le moteur ait fini de tourner avant d’exécuter la ligne de code suivante. `wait=False` : la ligne de code suivante s’exécute immédiatement.

# Build Used: Competition Advanced 2.0
def main():
    # Raise and lower the ArmMotor
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_for(FORWARD, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

spin_to_position #

spin_to_position fait tourner un moteur jusqu’à une position spécifique.

A motor’s position is how far it has spun, measured in DEGREES or TURNS. One turn is equal to 360 degrees. At the beginning of a project, the motor position is set to 0 degrees. The motor position can also be set using the set_position method.

Les valeurs de position sont absolues. Cela signifie que le sens de rotation dépend de la position actuelle du moteur.

Par exemple, si le moteur démarre à 0 degré et atteint une position de 720 degrés, il effectuera deux tours dans le sens horaire. S’il atteint ensuite une position de 360 degrés, il effectuera un tour dans le sens antihoraire, car 360 est inférieur à 720.

Usage:
arm_motor.spin_to_position(angle, units, wait)

Paramètres	Description
`angle`	Valeur de la position de rotation du moteur. `DEGREES` : utilisez des entiers. `TURNS` vous pouvez utiliser des entiers ou des décimaux.
`units`	Facultatif. L’unité de position : `DEGREES` (par défaut) ou `TURNS`.
`wait`	Optionnel. `wait=True` (par défaut) : le projet attend que le moteur ait fini de tourner avant d’exécuter la ligne de code suivante. `wait=False` : la ligne de code suivante s’exécute immédiatement.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

stop #

stop empêche le moteur de tourner.

Usage:
arm_motor.stop()

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

# Build Used: Competition Advanced 2.0
def main():
    # Raise the ArmMotor
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

Mutateurs #

set_velocity #

La commande `set_velocity set_velocity indique à un moteur sa vitesse de rotation. Un pourcentage plus élevé augmente la vitesse de rotation, et un pourcentage plus faible la diminue.

Chaque projet commence avec chaque moteur tournant par défaut à 50 % de sa vitesse maximale.

Remarque : Une vitesse plus élevée fait tourner le moteur plus vite, mais sa précision peut être moindre. Une vitesse plus faible fait tourner le moteur plus lentement, mais sa précision peut être accrue.

Usage:
arm_motor.set_velocity(velocity)

Paramètres	Description
`velocity`	La vitesse de rotation de 0% à 100%. Cela peut être un entier `integer` ou un nombre décimal (`float`).

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different velocities
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move slow
    arm_motor.set_velocity(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move fast
    arm_motor.set_velocity(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_max_torque #

Le couple est une force de rotation. Il indique la force avec laquelle un moteur peut pousser ou tirer lorsqu’il tourne.

set_max_torque définit le couple maximal qu’un moteur est autorisé à utiliser.

Un pourcentage plus élevé permet au moteur de fournir une force plus importante, par exemple pour soulever un objet lourd. Un pourcentage plus faible limite la force que le moteur peut fournir. Cela permet de protéger le robot si le moteur se bloque ou atteint sa limite de course.

Chaque projet démarre avec le couple de chaque moteur réglé par défaut à 50 %.

Usage:
arm_motor.set_max_torque(value)

Paramètres	Description
`value`	Le couple maximal que le moteur peut utiliser de 0 % à 100 %. Cela peut être un entier `integer` ou un nombre décimal (`float`).

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor at different torques
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    # Move with less torque
    arm_motor.set_max_torque(20)
    arm_motor.spin_for(FORWARD, 180, DEGREES)
    wait(1, SECONDS)
    # Move with maximum torque
    arm_motor.set_max_torque(100)
    arm_motor.spin_for(REVERSE, 180, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_position #

A motor’s position is how far it has spun, measured in DEGREES or TURNS. One turn is equal to 360 degrees. set_position changes the motor’s current position to a new value.

Par exemple, si un moteur a effectué une rotation de 180 degrés, le fait de régler sa position à 0 degré la ramènera de 180 à 0 degré. Le moteur pourra ensuite effectuer des rotations en fonction de cette nouvelle valeur.

Usage:
arm_motor.set_position(position, units)

Paramètres	Description
`position`	Valeur de position à définir pour le moteur. `DEGREES` : utiliser des entiers. `TURNS` : utiliser des entiers ou des décimaux.
`units`	Facultatif. L’unité de position : `DEGREES` (par défaut) ou `TURNS`.

# Build Used: Competition Advanced 2.0
def main():
    # Return ArmMotor to 0 degrees after raising
    arm_motor.set_position(0, DEGREES)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    wait(1, SECONDS)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

set_stopping #

set_stopping définit comment un moteur s’arrêtera de bouger : en freinant, en roue libre ou en maintenant.

Usage:
arm_motor.set_stopping(mode)

Paramètres	Description
`mode`	Mode d’arrêt du moteur : `BRAKE` — Arrêt immédiat. `COAST` — Ralentissement jusqu’à l’arrêt. `HOLD` — Arrêt immédiat et maintien de la position du moteur.

Paramètres

Description

mode

Mode d’arrêt du moteur :

BRAKE — Arrêt immédiat.
COAST — Ralentissement jusqu’à l’arrêt.
HOLD — Arrêt immédiat et maintien de la position du moteur.

Par exemple, si une version Competition Advanced 2.0 est utilisée et que arm_motor est configuré sur HOLD, le moteur maintiendra le bras dans sa position actuelle jusqu’à ce qu’un autre mouvement soit effectué. Cela signifie que le moteur luttera contre la gravité pour maintenir le bras en l’air s’il a été arrêté alors que le bras était levé.

Si cette méthode n’est pas utilisée, le moteur utilisera BRAKE lors de l’arrêt.

# Build Used: Competition Advanced 2.0
def main():
    # Move the ArmMotor, then coast to a stop
    arm_motor.set_velocity(20)
    arm_motor.set_stopping(COAST)
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout #

La valeur set_timeout définit le délai maximal pendant lequel un moteur tente de terminer un mouvement. Si le moteur ne parvient pas à terminer dans ce délai, il interrompt ses tentatives et passe à la ligne de code suivante. Cela évite que le moteur ne se bloque.

Usage:
arm_motor.set_timeout(value, units)

Paramètres	Description
`value`	Le temps pendant lequel le moteur peut tenter de terminer un mouvement. Cela peut être un entier positif `integer` ou un nombre décimal (`float`).
`units`	Facultatif. L’unité de temps : `SECONDS` (par défaut) ou `MSEC` (millisecondes).

# Build Used: Competition Advanced 2.0
def main():
    # Move ArmMotor as far as possible for 1 second before resetting
    arm_motor.set_position(0, DEGREES)
    arm_motor.set_timeout(1, SECONDS)
    arm_motor.spin_for(REVERSE, 180, DEGREES)
    arm_motor.spin_to_position(0, DEGREES)

# Start threads — Do not delete
start_thread(main)

Getters #

get_position #

La position d’un moteur correspond à sa rotation, mesurée en degrés DEGREES ou en tours TURNS. Un tour équivaut à 360 degrés. get_position renvoie la position actuelle du moteur.

Au début d’un projet, la position du moteur est initialement à 0 degré. Si le moteur effectue un tour complet dans un sens, la position sera de 360 degrés, soit un tour. S’il tourne dans l’autre sens, la position sera négative.

Usage:
arm_motor.get_position(units)

Paramètres	Description
`units`	Optionnel. L’unité de retour de la position du moteur : `DEGREES` (par défaut) ou `TURNS`.

# Build Used: Competition Advanced 2.0
def main():
    # Display how far the ArmMotor moves after one second
    arm_motor.set_position(0, DEGREES)
    console.print("Start: ")
    console.print(arm_motor.get_position(DEGREES))
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    arm_motor.stop()
    console.print("After: ")
    console.print(arm_motor.get_position(DEGREES))

# Start threads — Do not delete
start_thread(main)

get_velocity #

get_velocity renvoie la vitesse de rotation du moteur, en pourcentage de -100% à 100%.

Une valeur positive indique que le moteur tourne dans le sens horaire. Une valeur négative indique que le moteur tourne dans le sens antihoraire.

Usage:
arm_motor.get_velocity()

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

# Build Used: Competition Advanced 2.0
def main():
    # Display the ArmMotor's velocity when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_velocity())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_velocity())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

get_current #

get_current renvoie la quantité d’énergie que le moteur utilise à partir de la batterie, en pourcentage de 0 % à 100 %.

Une intensité plus élevée signifie que le moteur consomme plus d’énergie. Cela peut se produire lorsque le moteur soulève une charge lourde, exerce une pression sur un objet ou tente de se dégager alors qu’il est bloqué.

Usage:
arm_motor.get_current()

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

# Build Used: Competition Advanced 2.0
def main():
    # Display the motor's current when it moves
    console.print("Resting: ")
    console.print(arm_motor.get_current())
    console.new_line()
    arm_motor.spin(REVERSE)
    wait(1, SECONDS)
    console.print("Moving: ")
    console.print(arm_motor.get_current())
    arm_motor.stop()

# Start threads — Do not delete
start_thread(main)

is_stopped #

La fonction is_stopped renvoie is_stopped , indiquant si le moteur a terminé son mouvement (valeur booléenne). Cette information peut servir à synchroniser d’autres actions en fonction de l’état du moteur.

True — Le moteur a fini de tourner.
False — Le moteur tourne toujours.

Cette méthode fonctionne en collaboration avec les méthodes Motion suivantes qui ont le paramètre wait : spin_for et spin_to_position.

Usage:
arm_motor.is_stopped()

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

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_stopped():
            eye.set_light(OFF)
        else:
            eye.set_light(ON)

# Start threads — Do not delete
start_thread(main)

is_moving #

La fonction is_moving (valeur booléenne is_moving indique si le moteur tourne ou non. Cette information peut être utilisée pour synchroniser d’autres actions en fonction du mouvement du moteur.

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

Cette méthode fonctionne en collaboration avec les méthodes Motion suivantes qui ont le paramètre wait : spin_for et spin_to_position.

Usage:
arm_motor.is_moving()

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

# Build Used: Competition Advanced 2.0
def main():
    # Turn the Eye Sensor's light on while ArmMotor is moving
    arm_motor.spin_for(REVERSE, 180, DEGREES, wait=False)
    wait(0.1, SECONDS)
    while True:
        if arm_motor.is_moving():
            eye.set_light(ON)
        else:
            eye.set_light(OFF)

# Start threads — Do not delete
start_thread(main)