Transmission#
Introduction#
Le robot VEX IQ (2e génération) utilise une transmission pour se déplacer et tourner. Une transmission est composée de moteurs et de roues qui fonctionnent ensemble pour déplacer le robot.
A configured drivetrain can use a connected Gyro Sensor, the Brain’s built-in Inertial Sensor, or no sensor. When a sensor is used, the drivetrain uses it to help the robot move and turn precisely. At the start of each project, the drivetrain calibrates the sensor automatically. Keep the robot still for about 2 seconds during calibration, so the robot can move and turn correctly.
Cette page utilise drivetrain comme exemple de nom de transmission. Remplacez-le par le nom que vous avez configuré, selon vos besoins.
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— 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.calibrate_drivetrain— Calibre le capteur configuré avec la transmission.
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 le temps que le robot essaiera de mettre pour 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.set_turn_threshold— Indique à quelle distance le robot doit se rapprocher d’un angle cible avant qu’un virage ne soit terminé.set_turn_constant— Modifie la force avec laquelle le robot corrige ses virages.
Getters — Vérifiez l’état du mouvement.
heading— Renvoie le cap actuel du robot de 0 à 359 degrés.rotation— Renvoie la rotation actuelle du robot.velocity— Renvoie la vitesse à laquelle le robot se déplace.current— Renvoie la quantité de courant électrique utilisée par la transmission.is_moving— Renvoie si le robot est en mouvement, sous forme de valeur booléenne.is_done— Renvoie si le robot a fini de se déplacer, sous forme de valeur booléenne.is_turning— Renvoie si le robot tourne, sous forme de valeur booléenne.power— Renvoie la vitesse à laquelle la transmission utilise l’énergie.torque— Renvoie la quantité de couple utilisée par la transmission.efficiency— Renvoie l’efficacité avec laquelle la transmission utilise la puissance.temperature— Renvoie la température de la transmission.
Constructeurs — Créez et configurez manuellement la transmission.
DriveTrain— Crée un groupe motopropulseur sans capteur gyroscopique ni capteur inertiel.SmartDrive— Crée une transmission avec un capteur gyroscopique ou un capteur inertiel.
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, velocity, units)
Paramètres |
Description |
|---|---|
|
La direction dans laquelle le robot se déplace : |
|
Optional. The velocity to drive with from 0% to 100% when using |
|
Optionnel. L’unité de vitesse : |
# Drive forward then stop
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop()
# Drive slowly in reverse then stop
drivetrain.drive(REVERSE, 20, PERCENT)
wait(2, SECONDS)
drivetrain.stop()
drive_for#
La commande drive_for déplace le robot en avant ou en arrière sur une distance spécifique. Le programme attendra la fin du déplacement du robot avant d’exécuter la ligne de code suivante.
Usage:
drivetrain.drive_for(direction, distance, units, velocity, units_v, wait)
Paramètres |
Description |
|---|---|
|
La direction dans laquelle le robot se déplace : |
|
La distance parcourue par le robot. Cela peut être un entier |
|
Optionnel. L’unité de distance : |
|
Optional. The velocity to drive with from 0% to 100% when using |
|
Facultatif. L’unité de vitesse : |
|
Optionnel. |
# Drive forward and backward
drivetrain.drive_for(FORWARD, 10)
drivetrain.drive_for(REVERSE, 10)
# Quickly drive forward and backward
drivetrain.drive_for(FORWARD, 200, MM, 100, PERCENT)
drivetrain.drive_for(REVERSE, 200, MM, 100, PERCENT)
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, velocity, units)
Paramètres |
Description |
|---|---|
|
Direction dans laquelle le robot tourne : |
|
Facultatif. La vitesse de rotation : de 0 % à 100 % avec |
|
Facultatif. L’unité de vitesse : |
# Turn right and left, then stop
drivetrain.turn(RIGHT)
wait(2, SECONDS)
drivetrain.turn(LEFT)
wait(2, SECONDS)
drivetrain.stop()
# Quickly turn right and left, then stop
drivetrain.turn(RIGHT, 100, PERCENT)
wait(2, SECONDS)
drivetrain.turn(LEFT, 100, PERCENT)
wait(2, SECONDS)
drivetrain.stop()
turn_for#
La commande turn_for fait pivoter le robot vers la gauche ou la droite d’un nombre précis de degrés ou de tours. 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, velocity, units_v, wait)
Paramètres |
Description |
|---|---|
|
Direction dans laquelle le robot tourne : |
|
Le nombre de tours du robot. Cela peut être un entier |
|
Optionnel. Unité de rotation : |
|
Facultatif. La vitesse de rotation : de 0 % à 100 % avec |
|
Facultatif. L’unité de vitesse : |
|
Optionnel. |
# Turn the robot right and left
drivetrain.turn_for(RIGHT, 90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_for(LEFT, 90, DEGREES)
# Quickly turn the robot right and left
drivetrain.turn_for(RIGHT, 90, DEGREES, 100, PERCENT)
wait(1, SECONDS)
drivetrain.turn_for(LEFT, 90, DEGREES, 100, PERCENT)
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, velocity, units_v, wait)
Paramètres |
Description |
|---|---|
|
La direction vers laquelle le robot doit être orienté, en degrés. Cela peut être un entier |
|
Facultatif. Unité de titre : |
|
Facultatif. La vitesse de rotation : de 0 % à 100 % avec |
|
Optionnel. L’unité de vitesse : |
|
Optionnel. |
# 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)
# Turn twice slowly
drivetrain.turn_to_heading(90, DEGREES, 20, PERCENT)
wait(1, SECONDS)
drivetrain.turn_to_heading(180, DEGREES, 20, PERCENT)
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 ou en tours. 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, velocity, units_v, wait)
Paramètres |
Description |
|---|---|
|
La valeur de rotation, en degrés ou en tours, vers laquelle le robot tournera. Cela peut être un entier |
|
Optionnel. Unité de rotation : |
|
Facultatif. La vitesse de rotation : de 0 % à 100 % avec |
|
Optionnel. L’unité de vitesse : |
|
Optionnel. |
# 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)
# Turn left then slowly spin in a
# circle clockwise
drivetrain.turn_to_rotation(-90, DEGREES)
wait(1, SECONDS)
drivetrain.turn_to_rotation(450, DEGREES, 20, PERCENT)
stop#
stop arrête le mouvement du robot.
Usage:
drivetrain.stop(mode)
Paramètres |
Description |
|---|---|
|
Optionnel. Mode d’arrêt du robot :
|
# Drive forward then stop
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop()
# Drive forward and coast to a stop
drivetrain.set_drive_velocity(100, PERCENT)
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop(COAST)
calibrate_drivetrain#
calibrate_drivetrain est une fonction intégrée qui calibre le capteur gyroscopique ou le capteur inertiel configuré avec la transmission.
L’étalonnage permet au capteur de mesurer correctement les mouvements. Maintenez le robot immobile pendant environ 2 secondes lors de l’étalonnage. Si le robot bouge pendant cette opération, le capteur risque de ne pas mesurer correctement les mouvements.
Le projet attendra la fin de l’étalonnage avant d’exécuter la ligne de code suivante.
Remarque : Cette fonction ne peut pas être utilisée dans VS Code.
Usage:
calibrate_drivetrain()
Paramètres |
Description |
|---|---|
Cette fonction n’a pas de paramètres. |
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 peut améliorer sa précision.
Usage:
drivetrain.set_drive_velocity(velocity, units)
Paramètres |
Description |
|---|---|
|
La vitesse de déplacement de 0 % à 100 % lors de l’utilisation |
|
Optionnel. L’unité de vitesse : |
# 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)
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 |
|---|---|
|
La vitesse de rotation de 0 % à 100 % lors de l’utilisation |
|
Optionnel. L’unité de vitesse : |
# Turn at different velocities
# Default velocity
drivetrain.turn_for(RIGHT, 360)
wait(1, SECONDS)
# Turn slower
drivetrain.set_turn_velocity(20, PERCENT)
drivetrain.turn_for(RIGHT, 360)
wait(1, SECONDS)
# Turn faster
drivetrain.set_turn_velocity(100, PERCENT)
drivetrain.turn_for(RIGHT, 360)
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(mode)
Paramètres |
Description |
|---|---|
|
Mode d’arrêt du robot :
|
Si cette méthode n’est pas utilisée, le robot utilisera BRAKE lors de l’arrêt.
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 |
|---|---|
|
Le temps dont dispose le robot pour tenter de terminer un mouvement. Cela peut être un entier positif |
|
Facultatif. L’unité de temps : |
# Turn right after driving forward
drivetrain.set_timeout(1, SECONDS)
drivetrain.drive_for(FORWARD, 25, INCHES)
drivetrain.turn_for(RIGHT, 90)
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 |
|---|---|
|
La valeur de cap, en degrés ou en tours, à définir pour le robot. Cela peut être un entier |
|
Optionnel. Unité de cap : |
# Face the new 0 degrees
drivetrain.set_heading(90, DEGREES)
drivetrain.turn_to_heading(0, DEGREES)
set_rotation#
La rotation correspond à l’angle de rotation du robot, mesuré en degrés ou en tours. 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.
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 |
|---|---|
|
La valeur de rotation, en degrés ou en tours, à définir pour le robot. Cela peut être un entier |
|
Optionnel. Unité de rotation : |
# Spin counterclockwise two times
drivetrain.set_rotation(720, DEGREES)
drivetrain.turn_to_rotation(0, DEGREES)
set_turn_threshold#
set_turn_threshold définit à quelle distance le robot doit se rapprocher d’un angle cible avant qu’un virage ne soit terminé.
Un seuil plus bas permet des virages plus précis, mais le robot risque de mettre plus de temps à les terminer. Un seuil plus élevé permet des virages plus rapides, mais ils risquent d’être moins précis.
Usage:
drivetrain.set_turn_threshold(value)
Paramètres |
Description |
|---|---|
|
Le seuil de virage, en degrés. Il peut s’agir d’un entier |
# Set the turn threshold to 5 degrees
drivetrain.set_turn_threshold(5)
set_turn_constant#
set_turn_constant modifie la force avec laquelle le robot corrige ses virages.
Plus la valeur est élevée, plus le robot corrige les virages avec force. Plus la valeur est faible, plus il corrige les virages en douceur. La valeur par défaut est 1,0.
Usage:
drivetrain.set_turn_constant(value)
Paramètres |
Description |
|---|---|
|
La constante de rotation. Il peut s’agir d’un nombre décimal ( |
# Increase the turn constant to 2.0
drivetrain.set_turn_constant(2.0)
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 degrés.
Le cap initial du robot est de 0 degré.
Usage:
drivetrain.heading(units)
Paramètres |
Description |
|---|---|
|
Facultatif. Unité de retour du cap : |
# Display the heading after turning
drivetrain.turn_for(RIGHT, 450, DEGREES)
brain.screen.print("Heading: ")
brain.screen.print(drivetrain.heading())
rotation#
La rotation correspond à l’angle de rotation du robot, mesuré en degrés ou en tours. 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 |
|---|---|
|
Optionnel. Unité de rotation : |
# Display the rotation after turning
drivetrain.turn_for(RIGHT, 450, DEGREES)
brain.screen.print("Rotation: ")
brain.screen.print(drivetrain.rotation())
velocity#
La vitesse velocity indique la vitesse à laquelle le robot se déplace.
Il peut renvoyer la vitesse en pourcentage (de -100 % à 100 %), en tr RPM (de -127 à 127 tr/min) ou en degrés VelocityUnits.DPS à 3 degrés par seconde). Une valeur positive indique que le robot avance, une valeur négative indique qu’il recule.
Usage:
drivetrain.velocity(units)
Paramètres |
Description |
|---|---|
|
Facultatif. L’unité dans laquelle renvoyer la vitesse : |
current#
La fonction current indique l’intensité du courant électrique consommé par la transmission, mesurée en ampères. L’intensité correspond à la quantité d’électricité qui traverse la transmission.
Une intensité plus élevée signifie que la transmission consomme davantage de courant électrique. Cela peut se produire lorsque le robot pousse contre un objet ou tente de se dégager alors qu’il est bloqué.
Cela permet de vérifier si la transmission force pendant un mouvement. Si le courant reste élevé, la transmission risque de chauffer ou de consommer moins d’énergie.
Usage:
drivetrain.current(units)
Paramètres |
Description |
|---|---|
|
Facultatif. Unité de mesure du courant : |
is_moving#
La fonction is_moving renvoie is_moving , indiquant si le robot est en mouvement (valeur booléenne). 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 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_moving()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
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_turning#
La fonction is_turning (valeur booléenne : is_turning 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 en collaboration avec les méthodes Drivetrain suivantes qui ont le paramètre wait : turn_for, turn_to_heading, et turn_to_rotation.
Usage:
drivetrain.is_turning()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
power#
La puissance power la transmission utilise l’énergie.
Une valeur de puissance plus élevée signifie que la transmission consomme de l’énergie plus rapidement. Cela peut se produire lorsque le robot pousse contre un objet ou tente de se dégager alors qu’il est bloqué.
Cela permet de comparer les mouvements ou de vérifier si la transmission peine. Si la puissance reste élevée, la transmission risque de chauffer ou de consommer moins d’énergie.
Usage:
drivetrain.power()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
torque#
Le couple indique la force avec laquelle la transmission peut pousser ou tirer pendant que les roues tournent.
torque renvoie la quantité de couple utilisée par la transmission, mesurée en Newton-mètres (Nm) ou en pouces-livres (InLb).
Une valeur de couple plus élevée signifie que la transmission exerce une force de poussée ou de traction plus importante. Cela peut se produire lorsque le robot pousse contre un objet ou tente de se dégager alors qu’il est bloqué.
Cela peut servir à vérifier si la transmission peine ou à comparer la force de poussée nécessaire pour différents mouvements.
Usage:
drivetrain.torque(units)
Paramètres |
Description |
|---|---|
|
Optionnel. Unité de retour du couple : |
efficiency#
efficiency indique l’efficacité avec laquelle la transmission utilise la puissance, en pourcentage de 0 % à 100 %.
Le rendement indique la part de la puissance de la transmission utilisée pour le mouvement. Un rendement élevé signifie qu’une plus grande partie de la puissance est utilisée pour le déplacement. Un rendement faible peut s’expliquer par un effort important de la transmission sans déplacement significatif, par exemple lorsque le robot est bloqué ou qu’il pousse contre un obstacle.
Cela peut servir à comparer des mouvements ou à vérifier si la transmission gaspille de l’énergie au lieu de l’utiliser pour le mouvement.
Usage:
drivetrain.efficiency()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
temperature#
La fonction temperature renvoie la température moyenne de la transmission dans l’unité de température sélectionnée.
La température indique le niveau de chaleur des moteurs de la transmission. Une température plus élevée signifie que les moteurs chauffent pendant leur fonctionnement. Pour un fonctionnement optimal, les moteurs doivent rester en dessous de 55 °C.
Si les moteurs surchauffent, leur courant maximal sera réduit pour se protéger. À 70 °C, les moteurs s’arrêteront complètement jusqu’à leur refroidissement.
Cela peut servir à vérifier si la transmission chauffe excessivement lors de mouvements répétés, de longues courses ou lorsqu’elle exerce une pression contre un objet.
Usage:
drivetrain.temperature(units)
Paramètres |
Description |
|---|---|
|
Facultatif. L’unité de température à renvoyer : |
Constructeurs#
Les constructeurs permettent de créer DriveTrain et SmartDrive SmartDrive code. Ceci est utile pour configurer une transmission sans utiliser la fenêtre Périphériques.
Au moins deux objets Motor ou MotorGroup doivent être créés avant de créer une transmission.
DriveTrain#
DriveTrain crée une transmission sans capteur gyroscopique ni capteur inertiel.
Usage:
DriveTrain(lm, rm, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)
Paramètre |
Description |
|---|---|
|
Le moteur ou groupe moteur gauche. |
|
Le moteur ou le groupe de moteurs droit. |
|
Optionnel. Circonférence des roues motrices. La valeur par défaut est de 300 millimètres. |
|
Optionnel. Largeur entre les roues gauche et droite. Valeur par défaut : 320 millimètres. |
|
Optionnel. Distance entre les roues avant et arrière. Valeur par défaut : 320 millimètres. |
|
Optionnel. L’unité pour |
|
Optionnel. Rapport de transmission utilisé pour ajuster les distances de transmission si des engrenages sont utilisés. Peut être un entier |
# Create left and right drive motor objects
left_drive_smart = Motor(Ports.PORT1, 1.0, False)
right_drive_smart = Motor(Ports.PORT2, 1.0, True)
'''
Create a Drivetrain with the following values:
wheelTravel: 200
trackWidth: 173
wheelBase: 76
units: MM
externalGearRatio: 1
'''
drivetrain = DriveTrain(left_drive_smart, right_drive_smart, 200, 173, 76, MM, 1)
# Create two motor group objects for left and right motors
left_motor_a = Motor(Ports.PORT1, 1.0, False)
left_motor_b = Motor(Ports.PORT2, 1.0, False)
left_drive_smart = MotorGroup(left_motor_a, left_motor_b)
right_motor_a = Motor(Ports.PORT3, 1.0, True)
right_motor_b = Motor(Ports.PORT4, 1.0, True)
right_drive_smart = MotorGroup(right_motor_a, right_motor_b)
'''
Create a Drivetrain with the following values:
wheelTravel: 200
trackWidth: 173
wheelBase: 76
units: MM
externalGearRatio: 1
'''
drivetrain = DriveTrain(left_drive_smart, right_drive_smart, 200, 173, 76, MM, 1)
SmartDrive#
SmartDrive crée une transmission avec un capteur gyroscopique ou un capteur inertiel.
Usage:
SmartDrive(lm, rm, g, wheelTravel, trackWidth, wheelBase, units, externalGearRatio)
Paramètre |
Description |
|---|---|
|
Le moteur ou groupe moteur gauche. |
|
Le moteur ou le groupe de moteurs droit. |
|
Le capteur gyroscopique ou le capteur inertiel utilisé par la transmission. |
|
Optionnel. Circonférence des roues motrices. La valeur par défaut est de 300 millimètres. |
|
Optionnel. Largeur entre les roues gauche et droite. Valeur par défaut : 320 millimètres. |
|
Optionnel. Distance entre les roues avant et arrière. Valeur par défaut : 320 millimètres. |
|
Optionnel. L’unité pour |
|
Optionnel. Rapport de transmission utilisé pour ajuster les distances de transmission si des engrenages sont utilisés. Peut être un entier |
# Create the Inertial Sensor
brain_inertial = Inertial()
# Make left and right drive motors
left_drive_smart = Motor(Ports.PORT1, 1.0, False)
right_drive_smart = Motor(Ports.PORT6, 1.0, True)
# Create a SmartDrive object with wheelTravel 200
drivetrain = SmartDrive(left_drive_smart, right_drive_smart, brain_inertial, 200)
Pour concevoir une transmission intelligente à plusieurs moteurs, il faut créer les moteurs séparément avant de les regrouper en un groupe de moteurs.
# Create the Inertial Sensor
brain_inertial = Inertial()
# Create two motor groups for left and right motors
left_motor_a = Motor(Ports.PORT1, 1.0, False)
left_motor_b = Motor(Ports.PORT2, 1.0, False)
left_drive_smart = MotorGroup(left_motor_a, left_motor_b)
right_motor_a = Motor(Ports.PORT5, 1.0, True)
right_motor_b = Motor(Ports.PORT6, 1.0, True)
right_drive_smart = MotorGroup(right_motor_a, right_motor_b)
# Create a SmartDrive object with wheelTravel 200 mm
drivetrain = SmartDrive(left_drive_smart, right_drive_smart, brain_inertial, 200)