Transmission#

Introduction #

Le système de transmission comprend des roues et des moteurs qui contrôlent la propulsion et les virages du robot. On retrouve ce type de système dans des modèles comme le Code Base 2.0, la Super Car ou un robot personnalisé.

Drivetrains use the Inertial Sensor in the Brain to detect crashes and help the robot move and turn precisely. At the start of each project, the drivetrain calibrates the Inertial Sensor automatically. Keep the robot still for about 2 seconds during calibration, so the robot can move and turn correctly.

Il existe plusieurs façons de programmer la transmission. Vous trouverez ci-dessous la liste de toutes les méthodes de programmation de la transmission :

Actions — Déplacer et faire pivoter le robot.

drive — Déplace le robot vers l’avant ou vers l’arrière en permanence.
drive_for — Déplace le robot vers l’avant ou vers l’arrière sur une distance spécifique.
drive_until — Déplace le robot vers l’avant jusqu’à ce que le capteur oculaire détecte un objet ou que le robot détecte une collision.
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_heading — Oriente le robot vers un cap spécifique compris entre -359 et 359 degrés. Le robot empruntera le chemin le plus court pour atteindre le cap cible.
turn_to_rotation — Fait tourner le robot vers une rotation spécifique.
stop — Arrête le mouvement du robot.

Modificateurs — Ajustez les paramètres de la transmission.

set_drive_velocity — Indique au robot à quelle vitesse conduire.
set_turn_velocity — Indique au robot à quelle vitesse tourner.
set_stopping — Indique comment le robot s’arrêtera de bouger : en freinant, en roulant sur sa roue ou en maintenant.
set_timeout — Définit la durée pendant laquelle le robot essaiera de terminer un mouvement.
set_heading — Change le cap actuel du robot en un nouveau cap.
set_rotation — Change la rotation actuelle du robot en une nouvelle rotation.

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

get_heading — Renvoie le cap actuel du robot de 0 à 359 degrés.
get_rotation — Renvoie la rotation actuelle du robot.
get_velocity — Renvoie la vitesse à laquelle le robot se déplace, en pourcentage de -100% à 100%.
get_yaw — Renvoie le lacet actuel du robot.
get_roll — Renvoie le lancer actuel du robot.
get_pitch — Renvoie le pitch actuel du robot.
get_crashed — Renvoie si le robot a détecté un crash, sous forme de valeur booléenne.
is_stopped — Renvoie si le robot a fini de se déplacer, sous forme de valeur booléenne.

Actes #

drive #

La commande drive fait avancer ou reculer le robot indéfiniment. Le robot continuera à se déplacer jusqu’à ce qu’une autre action, comme tourner ou s’arrêter, lui soit donnée.

Usage:
drivetrain.drive(direction)

Paramètres	Description
`direction`	La direction dans laquelle le robot se déplace : `FORWARD` ou `REVERSE`.

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

drive_for #

La commande drive_for déplace le robot vers l’avant ou vers l’arrière sur une distance spécifique.

Usage:
drivetrain.drive_for(direction, distance, units, wait)

Paramètres	Description
`direction`	La direction dans laquelle le robot se déplace : `FORWARD` ou `REVERSE`.
`distance`	La distance parcourue par le robot. Il peut s’agir d’un nombre entier ou décimal.
`units`	Facultatif. L’unité de distance : `MM` (millimètres, par défaut) ou `INCHES`.
`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.

# Build Used: Code Base 2.0
def main():
    # Drive back and forth
    drivetrain.drive_for(FORWARD, 100, MM)
    drivetrain.drive_for(REVERSE, 4, INCHES)
    

# Start threads — Do not delete
start_thread(main)

drive_until #

La commande drive_until fait avancer le robot jusqu’à ce que le capteur oculaire détecte un objet ou que le robot détecte une collision.

Usage:
drivetrain.drive_until(condition, wait)

Paramètres	Description
`condition`	La condition qui arrête le robot : `OBJECT` ou `CRASH`.
`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.

# Build Used: Code Base 2.0
def main():
    # Turn right after a crash
    drivetrain.drive_until(CRASH)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

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 passer de la marche à l’arrêt.

Usage:
drivetrain.turn(direction)

Paramètres	Description
`direction`	Direction dans laquelle le robot tourne : `LEFT` ou `RIGHT`.

# Build Used: Code Base 2.0
def main():
    # Turn right and left, then stop
    drivetrain.turn(RIGHT)
    wait(2, SECONDS)
    drivetrain.turn(LEFT)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

turn_for #

La commande turn_for fait pivoter le robot vers la gauche ou la droite d’un nombre précis de degrés. La rotation est relative à la position actuelle du robot.

Usage:
drivetrain.turn_for(direction, angle, wait)

Paramètres	Description
`direction`	Direction dans laquelle le robot tourne : `LEFT` ou `RIGHT`.
`angle`	Le nombre de degrés de rotation du robot. Il peut s’agir d’un nombre entier ou décimal.
`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.

# Build Used: Code Base 2.0
def main():
    # Turn right then left
    drivetrain.turn_for(RIGHT, 90)
    drivetrain.turn_for(LEFT, 90)

# Start threads — Do not delete
start_thread(main)

turn_to_heading #

Le cap est la direction vers laquelle le cerveau du robot est orienté, mesurée en degrés. turn_to_heading oriente le robot vers un cap spécifique compris entre -359 et 359 degrés. Le robot empruntera le chemin le plus court pour atteindre le cap cible.

Le cap initial est de 0 degré.

Une base de code VEX GO 2.0 affichant les directions de cap : 0 degré vers l’avant, 90 degrés vers la droite, 180 degrés vers l’arrière et 270 degrés vers la gauche.

Usage:
drivetrain.turn_to_heading(angle, wait)

Paramètres	Description
`angle`	La direction vers laquelle le robot doit être orienté est un nombre entier, de -359 à 359 degrés.
`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.

# Build Used: Code Base 2.0
def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

turn_to_rotation #

turn_to_rotation fait tourner le robot dans une rotation spécifique.

La rotation correspond à l’angle de rotation du robot, mesuré en degrés. Au début d’un projet, la valeur de rotation est fixée à 0 degré. La rotation peut également être définie à l’aide de set_rotation.

Les valeurs de rotation sont absolues. Cela signifie que le sens de rotation dépend de la rotation actuelle du robot. Tourner à droite augmente la rotation, et tourner à gauche la diminue.

Par exemple, si le robot démarre à 0 degré et que vous effectuez une rotation de 720 degrés, il tournera deux fois à droite. Si vous effectuez ensuite une rotation de 360 degrés, il tournera une fois à gauche, car 360 est inférieur à 720.

Une base de code VEX GO 2.0 montrant des flèches tournant vers la droite et la gauche. La flèche de gauche indique « moins » et la flèche de droite indique « plus ».

Usage:
drivetrain.turn_to_rotation(angle, wait)

Paramètres	Description
`angle`	La valeur de rotation, en degrés, vers laquelle le robot effectuera une rotation. Il peut s’agir d’un entier.
`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.

# Build Used: Code Base 2.0
def main():
    # Make one full turn to the right
    drivetrain.turn_to_rotation(360)
    # Make another full turn to the right
    drivetrain.turn_to_rotation(720)
    # Make one full turn to the left, returning to 360 degrees
    drivetrain.turn_to_rotation(360)
# Start threads — Do not delete
start_thread(main)

stop #

stop arrête le mouvement du robot.

Usage:
drivetrain.stop()

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

# Build Used: Code Base 2.0
def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

Mutateurs #

set_drive_velocity #

La valeur set_drive_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 avec le robot se déplaçant par défaut à 50 % de sa vitesse maximale.

Remarque : Une vitesse plus élevée rend le robot plus rapide, mais peut nuire à sa précision. Une vitesse plus faible le rend plus lent, mais plus précis.

Usage:
drivetrain.set_drive_velocity(velocity)

Paramètres	Description
`velocity`	La vitesse à laquelle conduire, de 0 % à 100 %.

# Build Used: Code Base 2.0
def main():
    # Drive at different velocities
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive slow
    drivetrain.set_drive_velocity(20)
    drivetrain.drive_for(FORWARD, 100, MM)
    wait(1, SECONDS)
    # Drive fast
    drivetrain.set_drive_velocity(100)
    drivetrain.drive_for(FORWARD, 100, MM)

# Start threads — Do not delete
start_thread(main)

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 maximale.

Remarque : Une vitesse plus élevée permet au robot de tourner plus vite, mais sa précision peut être moindre. Une vitesse plus faible permet au robot de tourner plus lentement, mais sa précision est accrue.

Usage:
drivetrain.set_turn_velocity(velocity)

Paramètres	Description
`velocity`	La vitesse de virage de 0 % à 100 %.

# Build Used: Code Base 2.0
def main():
    # Turn at different velocities
    drivetrain.turn_for(RIGHT, 180)
    wait(1, SECONDS)
    # Turn fast
    drivetrain.set_turn_velocity(100)
    drivetrain.turn_for(RIGHT, 180)

# Start threads — Do not delete
start_thread(main)

set_stopping #

set_stopping définit comment le robot arrêtera de bouger : en freinant, en laissant le robot rouler ou en maintenant son mouvement.

Usage:
drivetrain.set_stopping(brake)

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

Paramètres

Description

brake

Mode d’arrêt du robot :

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

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

# Build Used: Code Base 2.0
def main():
    # Drive, then coast to a stop
    drivetrain.set_drive_velocity(100)
    drivetrain.set_stopping(COAST)
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# Start threads — Do not delete
start_thread(main)

set_timeout #

La valeur set_timeout définit la durée pendant laquelle le robot tente de terminer un mouvement. S’il ne parvient pas à terminer dans ce délai, il interrompt ses tentatives et passe à la ligne de code suivante. Cela évite que le robot ne se bloque sur un mouvement.

Usage:
drivetrain.set_timeout(value, units)

Paramètres	Description
`value`	Durée pendant laquelle le robot tente d’effectuer un mouvement. Il peut s’agir d’un nombre entier ou décimal.
`units`	Facultatif. L’unité de temps : `SECONDS` (par défaut) ou `MSEC` (millisecondes).

# Build Used: Code Base 2.0
def main():
    # Drive as far as possible for 1 second before turning right
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

set_heading #

Le cap correspond à la direction vers laquelle le cerveau du robot est orienté, mesurée en degrés. La commande set_heading modifie le cap actuel du robot en lui attribuant une nouvelle valeur.

Par exemple, si le robot s’est tourné vers la droite, le fait de régler son cap à 0 degré fait de cette position (orientée vers la droite) le nouveau point de référence à 0 degré. Le robot peut ensuite se tourner vers d’autres positions en fonction de ce nouveau cap.

Usage:
drivetrain.set_heading(value)

Paramètres	Description
`value`	Valeur du cap, en degrés, à définir pour le robot. Il peut s’agir d’un nombre entier compris entre 0 et 359.

# Build Used: Code Base 2.0
def main():
    # Face the new 0 degree heading
    drivetrain.set_heading(90)
    drivetrain.turn_to_heading(0)

# Start threads — Do not delete
start_thread(main)

set_rotation #

La rotation correspond à l’angle de rotation du robot, mesuré en degrés. Au début d’un projet, la valeur de rotation est fixée à 0 degré. La commande set_rotation modifie la rotation actuelle du robot en lui attribuant une nouvelle valeur.

Par exemple, si le robot a effectué deux tours complets vers la droite, sa valeur de rotation sera de 720 degrés. Définir la rotation à 0 degré la réinitialisera de 720 à 0 degré. Le robot pourra ensuite effectuer des rotations en fonction de cette nouvelle valeur.

Usage:
drivetrain.set_rotation(value)

Paramètres	Description
`value`	Valeur de rotation, en degrés, à définir pour le robot. Il peut s’agir d’un entier.

# Build Used: Code Base 2.0
def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720)
    drivetrain.turn_to_rotation(0)

# Start threads — Do not delete
start_thread(main)

Getters #

get_heading #

Le cap est la direction vers laquelle le cerveau du robot est orienté, mesurée en degrés. get_heading get_heading` renvoie ce cap, de 0 à 359 degrés.

Le cap initial du robot est de 0 degré.

Un cerveau VEX GO affichant les directions : 0 degré vers l’avant, 90 degrés vers la droite, 180 degrés vers l’arrière et 270 degrés vers la gauche.

Usage:
drivetrain.get_heading()

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

# Build Used: Code Base 2.0
def main():
    # Display the heading while turning
    monitor_sensor("drivetrain.get_heading")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_rotation #

La rotation correspond à l’angle de rotation du robot, mesuré en degrés. Au début d’un projet, la valeur de rotation est fixée à 0 degré. get_rotation get_rotation renvoie la rotation actuelle du robot.

Tourner à droite augmente la rotation, et tourner à gauche la diminue. Par exemple, deux virages complets à droite correspondent à une rotation de 720 degrés.

Une base de code VEX GO 2.0 montrant des flèches tournant vers la droite et la gauche. La flèche de gauche indique « moins » et la flèche de droite indique « plus ».

Usage:
drivetrain.get_rotation()

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

# Build Used: Code Base 2.0
def main():
    # Display the rotation while turning
    monitor_sensor("drivetrain.get_rotation")
    drivetrain.turn_for(RIGHT, 450)


# Start threads — Do not delete
start_thread(main)

get_velocity #

get_velocity renvoie la vitesse de déplacement du robot, en pourcentage de -100% à 100%.

Une valeur positive indique que le robot avance. Une valeur négative indique que le robot recule.

Usage:
drivetrain.get_velocity()

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

# Build Used: Code Base 2.0
def main():
    # Display the velocity of the robot before and while moving
    console.print("Start: ")
    console.print(drivetrain.get_velocity())
    console.new_line()
    drivetrain.drive(FORWARD)
    wait(0.5, SECONDS)
    console.print("Moving: ")
    console.print(drivetrain.get_velocity())
    drivetrain.stop()


# Start threads — Do not delete
start_thread(main)

get_yaw #

Le lacet correspond à la rotation du robot à gauche ou à droite par rapport à sa position initiale, mesurée en degrés. get_yaw get_yaw` renvoie la valeur de lacet actuelle du robot.

Tourner à droite augmente la valeur de lacet, et tourner à gauche la diminue.

Usage:
drivetrain.get_yaw()

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

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the yaw while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_yaw")
    while True:
        if drivetrain.get_yaw() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_yaw() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_roll #

Le roulis correspond à l’inclinaison du robot vers la gauche ou la droite, mesurée en degrés. get_roll get_roll` renvoie la valeur de roulis actuelle du robot.

Avec le cerveau orienté vers l’avant, incliner à gauche augmente la valeur de roulis, et incliner à droite la diminue.

Usage:
drivetrain.get_roll()

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

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the roll while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_roll")
    while True:
        if drivetrain.get_roll() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_roll() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_pitch #

L’inclinaison (ou pitch) correspond à l’angle d’inclinaison du robot vers l’avant ou vers l’arrière, mesuré en degrés. get_pitch get_pitch` renvoie la valeur d’inclinaison actuelle du robot.

Lorsque le cerveau est orienté vers l’avant, l’incliner vers l’avant augmente la valeur de la hauteur tonale, et l’incliner vers l’arrière la diminue.

Usage:
drivetrain.get_pitch()

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

# Build Used: Super Code Base 2.0
def main():
    # Change the LED color based on the pitch while
    # moving the robot by hand
    monitor_sensor("drivetrain.get_pitch")
    while True:
        if drivetrain.get_pitch() > 0:
            bumper.set_color(GREEN)
        elif drivetrain.get_pitch() < 0:
            bumper.set_color(RED)
        else:
            bumper.set_color(NONE)

# Start threads — Do not delete
start_thread(main)

get_crashed #

get_crashed renvoie, sous forme de valeur booléenne, si le robot a détecté un crash.

True — Un crash a été détecté.
False — Aucun crash n’a été détecté.

Usage:
drivetrain.get_crashed()

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

# Build Used: Super Code Base 2.0
def main():
    # Drive until a crash
    drivetrain.drive(FORWARD)
    while not drivetrain.get_crashed():
        wait(50, MSEC)
    drivetrain.stop()
    drivetrain.turn_for(RIGHT, 90)

# Start threads — Do not delete
start_thread(main)

is_stopped #

La fonction is_stopped renvoie is_stopped , indiquant si le robot a terminé son mouvement (valeur booléenne). Cette information peut servir à contrôler le déclenchement d’autres actions en fonction des mouvements du robot.

True — Le robot a terminé son déplacement.
False — Le robot est toujours en mouvement.

Cette méthode fonctionne en collaboration avec les méthodes de transmission suivantes qui ont le paramètre wait : drive_for, drive_until, turn_for, turn_to_heading, et turn_to_rotation.

Usage:
drivetrain.is_stopped()

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

# Build Used: Code Base 2.0
def main():
    # Turn when the drivetrain is done moving forward
    drivetrain.drive_for(FORWARD, 100, MM, wait=False)
    wait(0.25, SECONDS)
    while True:
        if drivetrain.is_stopped():
            drivetrain.turn_for(RIGHT, 180)
            break
        else:
            console.print("Still moving...")
            wait(0.1, SECONDS)
            console.clear()

# Start threads — Do not delete
start_thread(main)