Transmission#

Introduction #

La transmission contrôle la façon dont le robot VR se déplace et tourne. Elle peut avancer ou reculer, tourner à gauche ou à droite, s’orienter et suivre sa rotation.

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.
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 — Tourne le robot pour faire face à un cap spécifique de -359 à 359 degrés.
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_heading — Change le cap actuel du robot en un nouveau cap.
set_rotation — Change la rotation actuelle du robot en une nouvelle rotation.
set_timeout — Définit le temps que le robot essaiera de mettre pour terminer un mouvement.
set_drive_velocity — Indique au robot à quelle vitesse conduire.
set_turn_velocity — Indique au robot à quelle vitesse tourner.

Getters — Vérifiez l’état de la transmission.

heading — Renvoie le cap actuel du robot de 0 à 359,99 degrés.
rotation — Renvoie la rotation actuelle du robot.
is_done — Renvoie si le robot a fini de se déplacer, sous forme de valeur booléenne.
is_moving — Renvoie si le robot est en mouvement, 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`.

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

La commande drive_for déplace le robot vers l’avant ou vers l’arrière sur une distance spécifique. Le programme attendra que le robot ait terminé son déplacement avant d’exécuter la ligne de code suivante.

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. Cela peut être un entier `integer` ou un nombre décimal (`float`).
`units`	Optionnel. Unité de distance : `INCHES` (par défaut) ou `MM` (millimètres).
`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.

def main():
    # Drive forward and backward
    drivetrain.drive_for(FORWARD, 200, MM)
    drivetrain.drive_for(REVERSE, 200, MM)

# VR threads — Do not delete
vr_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 avancer ou s’arrêter.

Usage:
drivetrain.turn(direction)

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

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

# VR threads — Do not delete
vr_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. Le programme attendra la fin de la rotation avant d’exécuter la ligne de code suivante.

Usage:
drivetrain.turn_for(direction, angle, 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. Cela peut être un entier `integer` ou un nombre décimal (`float`).
`units`	Optionnel. Unité de rotation : `DEGREES` (par défaut).
`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.

def main():
    # Turn the robot right and left
    drivetrain.turn_for(RIGHT, 90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_for(LEFT, 90, DEGREES)

# VR threads — Do not delete
vr_thread(main)

turn_to_heading #

Le cap est la direction vers laquelle le 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 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:
drivetrain.turn_to_heading(angle, units, wait)

Paramètres	Description
`angle`	La direction vers laquelle le robot doit être orienté, en degrés. Cela peut être un entier `integer` ou un nombre décimal (`float`) compris entre -359 et 359.
`units`	Optionnel. Unité de rotation : `DEGREES` (par défaut).
`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.

def main():
    # Turn to face the cardinal directions
    drivetrain.turn_to_heading(90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(180, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(270, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_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 la méthode 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.

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

Usage:
drivetrain.turn_to_rotation(angle, units, wait)

Paramètres	Description
`angle`	La valeur de rotation, en degrés, vers laquelle le robot tournera. Cela peut être un entier `integer` ou un nombre décimal (`float`).
`units`	Optionnel. Unité de rotation : `DEGREES` (par défaut).
`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.

def main():
    # Turn left, then spin in a circle
    # clockwise and face right
    drivetrain.turn_to_rotation(-90, DEGREES)
    wait(1, SECONDS)
    drivetrain.turn_to_rotation(450, DEGREES)

# VR threads — Do not delete
vr_thread(main)

stop #

stop arrête le mouvement du robot.

Usage:
drivetrain.stop()

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

def main():
    # Drive forward then stop
    drivetrain.drive(FORWARD)
    wait(2, SECONDS)
    drivetrain.stop()

# VR threads — Do not delete
vr_thread(main)

Mutateurs #

set_heading #

Le cap est la direction vers laquelle le 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(heading, units)

Paramètres	Description
`heading`	La valeur du cap, en degrés, à définir pour le robot. Cela peut être un entier `integer` ou un nombre décimal (`float`).
`units`	Facultatif. Unité de titre : `DEGREES` (par défaut).

def main():
    # Face the new 0 degrees
    drivetrain.set_heading(90, DEGREES)
    drivetrain.turn_to_heading(0, DEGREES)

# VR threads — Do not delete
vr_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(rotation, units)

Paramètres	Description
`rotation`	La valeur de rotation, en degrés, à définir pour le robot. Cela peut être un entier `integer` ou un nombre décimal (`float`).
`units`	Optionnel. Unité de rotation : `DEGREES` (par défaut).

def main():
    # Spin counterclockwise two times
    drivetrain.set_rotation(720, DEGREES)
    drivetrain.turn_to_rotation(0, DEGREES)

# VR threads — Do not delete
vr_thread(main)

set_timeout #

La valeur set_timeout définit le temps imparti au robot pour terminer un mouvement. Si le robot 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`	Le temps dont dispose le robot pour 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).

def main():
    # Turn right after driving forward
    drivetrain.set_timeout(1, SECONDS)
    drivetrain.drive_for(FORWARD, 25, INCHES)
    drivetrain.turn_for(RIGHT, 90)

# VR threads — Do not delete
vr_thread(main)

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 peut améliorer sa précision.

Usage:
drivetrain.set_drive_velocity(velocity, units)

Paramètres	Description
`velocity`	La vitesse à laquelle conduire de 0% à 100%. Cela peut être un entier `integer` ou un nombre décimal (`float`).
`units`	Facultatif. Unité de vitesse : `PERCENT` (par défaut).

def main():
    # Drive forward at different velocities
    # Default velocity
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive slower
    drivetrain.set_drive_velocity(20, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)
    wait(1, SECONDS)
    # Drive faster
    drivetrain.set_drive_velocity(100, PERCENT)
    drivetrain.drive_for(FORWARD, 150, MM)

# VR threads — Do not delete
vr_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 peut être accrue.

Usage:
drivetrain.set_turn_velocity(velocity, units)

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

def main():
    # Turn at different velocities
    # Default velocity
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn slower
    drivetrain.set_turn_velocity(20, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)
    wait(1, SECONDS)
    # Turn faster
    drivetrain.set_turn_velocity(100, PERCENT)
    drivetrain.turn_for(RIGHT, 120, DEGREES)

# VR threads — Do not delete
vr_thread(main)

Getters #

heading #

Le cap est la direction vers laquelle le robot est orienté, mesurée en degrés. La commande heading renvoie le cap actuel du robot, compris entre 0 et 359,99 degrés.

Le cap initial du robot est de 0 degré.

Usage:
drivetrain.heading(units)

Paramètres	Description
`units`	Facultatif. Unité de titre : `DEGREES` (par défaut).

def main():
    # Display the heading after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.print("Heading: ")
    brain.print(drivetrain.heading(DEGREES))

# VR threads — Do not delete
vr_thread(main)

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

Usage:
drivetrain.rotation(units)

Paramètres	Description
`units`	Optionnel. Unité de rotation : `DEGREES` (par défaut).

def main():
    # Display the rotation after turning
    drivetrain.turn_for(RIGHT, 450, DEGREES)
    brain.print("Rotation: ")
    brain.print(drivetrain.rotation(DEGREES))

# VR threads — Do not delete
vr_thread(main)

is_done #

La fonction is_done renvoie is_done , indiquant si le robot a terminé son déplacement (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 Drivetrain suivantes qui ont le paramètre wait : drive_for, turn_for, turn_to_heading, et turn_to_rotation.

Usage:
drivetrain.is_done()

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

is_moving #

La fonction is_moving renvoie une valeur booléenne indiquant si le robot est en mouvement ( is_moving . 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.

Usage:
drivetrain.is_moving()

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