Python spécifique aux robots#
Introduction#
Le robot héros Flex comprend un moteur à pince, un moteur à bras, un capteur de vision IA, un capteur de distance et un capteur de système de positionnement de jeu (GPS).
Toutes les méthodes VR standard de VEXcode sont disponibles pour une utilisation dans le V5 26-27 Override Playground.
Vous trouverez ci-dessous la liste de toutes les méthodes spécifiques aux robots disponibles :
Transmission – Déplacez et faites tourner le robot.
Actes
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.
Mutateurs
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.
Attrapeurs
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.velocity— Renvoie la vitesse à laquelle le robot se déplace.
Mouvement – Déplacer et suivre les moteurs du robot.
Actes
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.
Mutateurs
set_position— Change la position actuelle du moteur à une nouvelle valeur.set_velocity— Indique à un moteur à quelle vitesse tourner.set_timeout— Définit le temps pendant lequel un moteur essaiera de terminer un mouvement.
Attrapeurs
is_done— Renvoie si le moteur a fini de bouger, sous forme de valeur booléenne.is_spinning— Renvoie si le moteur tourne, sous forme de valeur booléenne.position— Renvoie la position actuelle du moteur.velocity— Renvoie la vitesse de rotation du moteur.
Vision par IA – Capturez et analysez des objets à l’aide du capteur de vision par IA.
Attrapeurs
take_snapshot– Renvoie un tuple d’objets détectés pour une signature spécifique.
Propriétés
.width– Largeur de l’objet détecté en pixels..height– Hauteur de l’objet détecté en pixels..centerX– Position X du centre de l’objet en pixels..centerY– Position Y du centre de l’objet en pixels..originX– Position X du coin supérieur gauche de l’objet en pixels..originY– Position Y du coin supérieur gauche de l’objet en pixels..id– ID de classification de l’objet détecté.
Console – Afficher les valeurs dans la console et surveiller les valeurs.
Imprimer
brain.screen.print— Affiche du texte, des nombres ou des valeurs de variables dans la console.brain.screen.next_row— Déplace le curseur de la console au début de la ligne suivante.brain.screen.clear_screen— Efface toutes les lignes de la console.
Moniteur
monitor_variable— Ajoute une ou plusieurs variables prédéfinies à l’onglet Monitor.monitor_sensor— Ajoute une ou plusieurs valeurs de capteur à l’onglet Moniteur.
Détection – Utiliser les différents capteurs du robot.
Distance
found_object– Renvoie si le capteur de distance détecte un objet à portée.object_distance– Renvoie la distance entre le capteur de distance et l’objet détecté le plus proche.
GPS
x_position– Renvoie la coordonnée x actuelle du capteur GPS sur le terrain.y_position– Renvoie la coordonnée y actuelle du capteur GPS sur le terrain.heading– Renvoie la direction vers laquelle le robot est actuellement orienté en fonction du capteur GPS.
Les exemples de cette page utilisent l’emplacement de départ C de la liste de vérification d’avant-match du terrain de jeu.
Transmission#
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.
Actes#
conduire#
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 |
|---|---|
|
La direction dans laquelle le robot se déplace : |
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive(FORWARD)
wait(0.5, SECONDS)
drivetrain.stop()
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
conduire_pour#
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, 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. Unité de distance : |
|
Optionnel. |
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
tourner#
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 dans laquelle le robot tourne : |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn(LEFT)
wait(0.78, SECONDS)
drivetrain.stop()
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
tourner_pour#
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 dans laquelle le robot tourne : |
|
Le nombre de degrés de rotation du robot. Cela peut être un entier |
|
Optionnel. Unité d’angle : |
|
Optionnel. |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
tourner_vers_la_direction#
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 est de 0 degré.
Usage:
drivetrain.turn_to_heading(heading, units, wait)
Paramètres |
Description |
|---|---|
|
Le cap que le robot doit suivre, de -359 à 359 degrés. |
|
Optionnel. Unité d’angle : |
|
Optionnel. |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_to_heading(-110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
tourner_à_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é. Tourner à droite augmente la rotation, et tourner à gauche la diminue.
Par exemple, si le robot démarre à 0 degré et effectue une rotation de 720 degrés, il tournera deux fois à droite. S’il effectue ensuite une rotation de 360 degrés, il tournera une fois à gauche, car 360 est inférieur à 720.
Usage:
drivetrain.turn_to_rotation(rotation, units, wait)
Paramètres |
Description |
|---|---|
|
La valeur de rotation, en degrés, vers laquelle le robot tournera. Cela peut être un entier |
|
Optionnel. Unité d’angle : |
|
Optionnel. |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_to_rotation(-110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
arrêt#
stop arrête le mouvement du robot.
Usage:
drivetrain.stop()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn(LEFT)
wait(0.78, SECONDS)
drivetrain.stop()
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
Mutateurs#
définir_en-tête#
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 du cap, en degrés, à définir pour le robot. |
|
Optionnel. Unité d’angle : |
def main():
# Make facing the Neutral Goal the new heading
drivetrain.set_heading(110, DEGREES)
drivetrain.turn_to_heading(0, DEGREES)
# VR threads — Do not delete
vr_thread(main)
définir_rotation#
La rotation correspond à l’angle de rotation du robot, mesuré en degrés. La commande `set_rotation set_rotation modifie la rotation actuelle du robot.
Usage:
drivetrain.set_rotation(rotation, units)
Paramètres |
Description |
|---|---|
|
La valeur de rotation, en degrés, à définir pour le robot. Cela peut être un entier |
|
Optionnel. Unité d’angle : |
def main():
# Make facing the Neutral Goal the new rotation
drivetrain.set_rotation(110, DEGREES)
drivetrain.turn_to_rotation(0, DEGREES)
# VR threads — Do not delete
vr_thread(main)
définir_délai#
set_timeout définit le délai (en secondes) pendant lequel le robot tente de terminer un mouvement. S’il n’y parvient pas, il interrompt ses tentatives et passe à la ligne de code suivante. Cela évite qu’il ne se bloque.
Usage:
drivetrain.set_timeout(time, units)
Paramètres |
Description |
|---|---|
|
Le nombre de secondes pendant lesquelles le robot peut tenter de terminer un mouvement. Cela peut être un entier positif |
|
Facultatif. L’unité de temps : |
def main():
# Turn to face the Neutral Goal
drivetrain.set_timeout(0.8, SECONDS)
drivetrain.turn_for(LEFT, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
définir_vitesse_de_conduite#
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 à laquelle conduire de 0% à 100%. Cela peut être un entier |
|
Facultatif. Unité de vitesse : |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.set_drive_velocity(100, PERCENT)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
définir_vitesse_de_virage#
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%. Cela peut être un entier |
|
Facultatif. Unité de vitesse : |
def main():
# Turn to face the Neutral Goal faster
drivetrain.set_turn_velocity(100, PERCENT)
drivetrain.turn_for(LEFT, 110, DEGREES)
# VR threads — Do not delete
vr_thread(main)
Getters#
titre#
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 |
|---|---|
|
Facultatif. Unité de titre : |
def main():
# Turn to the Goal, then show heading
drivetrain.turn_for(LEFT, 110, DEGREES)
brain.screen.print("Heading: ")
brain.screen.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 |
|---|---|
|
Optionnel. Unité de rotation : |
def main():
# Spin to find a Pin, then show rotation
drivetrain.turn_for(RIGHT, 450, DEGREES)
brain.screen.print("Rotation: ")
brain.screen.print(drivetrain.rotation(DEGREES))
# VR threads — Do not delete
vr_thread(main)
est_terminé#
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. |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
arm_motor.spin_for(FORWARD, 800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
wait(0.5, SECONDS)
while not drivetrain.is_done():
wait(5, MSEC)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
est_en_mouvement#
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. |
def main():
# Raise the Arm once stopped near the Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES, wait=False)
wait (0.5, SEC)
while drivetrain.is_moving():
wait(5, MSEC)
arm_motor.spin_for(FORWARD, 800, DEGREES)
# VR threads — Do not delete
vr_thread(main)
vitesse#
La vitesse velocity renvoie la vitesse à laquelle le robot se déplace, en pourcentage de -100 % à 100 %.
Usage:
drivetrain.velocity(units)
Paramètres |
Description |
|---|---|
|
Facultatif. Unité de vitesse : |
def main():
# Show speed while driving to the Goal
drivetrain.drive_for(FORWARD, 150, MM)
brain.screen.print("Velocity: ")
brain.screen.print(drivetrain.velocity(PERCENT))
# VR threads — Do not delete
vr_thread(main)
Mouvement#
Flex utilise le moteur du bras pour lever et abaisser le bras, et le moteur de la pince pour ouvrir et fermer la pince.
Chaque moteur possède son propre comportement selon sa direction. Les descriptions de direction expliquent comment chaque direction actionne le moteur correspondant sur Flex.
Actes#
rotation#
La position spin fait tourner le moteur indéfiniment dans l’un des deux sens. 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.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
Sens de rotation du moteur :
|
def main():
# Raise the Arm before driving toward a Pin
arm_motor.spin(FORWARD)
wait(1, SECONDS)
arm_motor.stop()
# VR threads — Do not delete
vr_thread(main)
tourner_pour#
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.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
Sens de rotation du moteur :
|
|
Distance de rotation du moteur. |
|
Facultatif. L’unité de distance : |
|
Facultatif.
|
def main():
# Raise the Arm to carry the Pin to the Goal
arm_motor.spin_for(FORWARD, 800, DEGREES)
# VR threads — Do not delete
vr_thread(main)
rotation_vers_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 Arm Motor’s position is set to 0 degrees. The Claw Motor is the exception — it starts at 467 degrees (fully closed). 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.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
Valeur de la position de rotation du moteur. |
|
Facultatif. L’unité de position : |
|
Facultatif.
|
def main():
# Raise the Arm, then release the Pin
arm_motor.spin_to_position(800, DEGREES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
arrêt#
stop empêche le moteur de tourner.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Raise the Arm partway to hold the Pin
arm_motor.spin(FORWARD)
wait(1, SECONDS)
arm_motor.stop()
# VR threads — Do not delete
vr_thread(main)
Mutateurs#
définir_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.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
Valeur de position à définir pour le moteur. |
|
Facultatif. L’unité de position : |
def main():
# Reset encoder, raise Arm, place Pin
arm_motor.set_position(0, DEGREES)
arm_motor.spin_to_position(800, DEGREES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
définir_vitesse#
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.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
La vitesse de rotation de 0% à 100%. Cela peut être un entier |
|
L’unité de vitesse : |
def main():
# Raise the Arm fast to release the Pin
arm_motor.set_velocity(100, PERCENT)
arm_motor.spin_for(FORWARD, 800, DEGREES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
définir_délai#
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.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
Le temps pendant lequel le moteur peut tenter de terminer un mouvement. Cela peut être un entier positif |
|
L’unité de temps : |
def main():
# Score a Pin in a Neutral Goal
drivetrain.turn_for(LEFT, 110, DEGREES)
arm_motor.set_timeout(1, SECONDS)
arm_motor.spin_for(FORWARD, 1800, DEGREES)
drivetrain.drive_for(FORWARD, 25, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
Getters#
est_terminé#
La fonction is_done renvoie is_done , indiquant si le moteur a terminé son mouvement (valeur booléenne). Cette information peut servir à contrôler le déclenchement 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.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Raise the Arm while driving to the Goal
arm_motor.spin_to_position(800, DEGREES, wait=False)
wait(0.1, SECONDS)
while not arm_motor.is_done():
drivetrain.drive(FORWARD)
wait(5, MSEC)
drivetrain.stop()
# VR threads — Do not delete
vr_thread(main)
est_en_roulement#
La fonction is_spinning (valeur booléenne is_spinning indique si le moteur tourne. Cette information peut être utilisée pour synchroniser d’autres actions en fonction de l’état 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.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Raise the Arm while driving to the Goal, then release the Pin
arm_motor.spin_to_position(800, DEGREES, wait=False)
wait(0.1, SECONDS)
while arm_motor.is_spinning():
drivetrain.drive_for(FORWARD, 25, MM)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
position#
La position d’un moteur correspond à sa rotation, mesurée en DEGREES ou TURNS. Un tour équivaut à 360 degrés. position renvoie la position actuelle du moteur.
Au début d’un projet, la position du moteur du bras est réglée sur 0 degré. Le moteur de la pince fait exception : il démarre à 467 degrés (position complètement fermée). Si le moteur effectue un tour complet dans un sens, la position augmente. S’il tourne dans l’autre sens, la position diminue.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
L’unité pour ramener la position du moteur dans : |
def main():
# Raise the Arm, then release the Pin
while arm_motor.position(DEGREES) < 800:
arm_motor.spin(FORWARD)
wait(2, MSEC)
arm_motor.stop()
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
vitesse#
La vitesse velocity indique la vitesse de rotation du moteur.
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.
Utilisation :
L’un des deux objets moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
L’unité de vitesse à renvoyer : |
def main():
# Show Arm Motor velocity while raising
arm_motor.set_velocity(100, PERCENT)
arm_motor.spin_to_position(800, DEGREES, wait=False)
wait(0.2, SECONDS)
brain.screen.print(arm_motor.velocity(PERCENT))
# VR threads — Do not delete
vr_thread(main)
Vision IA#
Getters#
prendre_un_instantané#
take_snapshot filtre les données de l’image du capteur de vision IA en une seule signature — une description enregistrée de quelque chose que le capteur peut reconnaître, comme un élément de jeu sur le terrain — et renvoie un tuple.
The tuple stores objects ordered from largest to smallest by width, starting at index 0. Each object’s properties can be accessed using its index. An empty tuple is returned if no matching objects are detected.
Usage:
ai_vision.take_snapshot(signature)
Paramètres |
Description |
|---|---|
|
Filtre l’ensemble de données pour n’inclure que les données de la signature spécifiée. Les signatures disponibles sont :
|
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Turn to face the Pin
drivetrain.set_turn_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].centerX < 140:
drivetrain.turn(LEFT)
elif ai_objects[0].centerX > 180:
drivetrain.turn(RIGHT)
else:
drivetrain.stop()
break
# VR threads — Do not delete
vr_thread(main)
Propriétés#
Il existe sept propriétés qui sont incluses avec chaque objet stocké dans un tuple après l’utilisation de take_snapshot.
Toutes les valeurs de propriété, à l’exception .id décrivent la position et la taille de l’objet détecté dans le champ de vision du capteur de vision IA au moment take_snapshot . Ces valeurs sont exprimées en pixels, selon la résolution du capteur (320 x 240 pixels).
.largeur#
.width renvoie la largeur de l’objet détecté en pixels, qui est un entier compris entre 1 et 320.
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Approach the next Cup and Pin
drivetrain.set_drive_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].width > 140:
drivetrain.stop()
break
else:
drivetrain.drive(FORWARD)
# VR threads — Do not delete
vr_thread(main)
.hauteur#
.height renvoie la hauteur de l’objet détecté en pixels, qui est un entier compris entre 1 et 240.
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Approach the next Cup and Pin
drivetrain.set_drive_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].height > 200:
drivetrain.stop()
break
else:
drivetrain.drive(FORWARD)
# VR threads — Do not delete
vr_thread(main)
.centreX#
.centerX renvoie la coordonnée x du centre de l’objet détecté en pixels, qui est un entier compris entre 0 et 320.
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Turn and approach the next Cup and Pin
drivetrain.set_turn_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].centerX < 140:
drivetrain.turn_for(LEFT, 5, DEGREES)
else:
drivetrain.drive_for(FORWARD, 25, INCHES)
break
# VR threads — Do not delete
vr_thread(main)
.centreY#
.centerY renvoie la coordonnée y du centre de l’objet détecté en pixels, qui est un entier compris entre 0 et 240.
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Approach the next Cup and Pin
drivetrain.set_drive_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].centerY > 230:
drivetrain.stop()
break
else:
drivetrain.drive(FORWARD)
# VR threads — Do not delete
vr_thread(main)
.origineX#
.originX renvoie la coordonnée x du coin supérieur gauche de la boîte englobante de l’objet détecté en pixels, qui est un entier compris entre 0 et 320.
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Turn and approach the next Cup and Pin
drivetrain.set_turn_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].originX < 100:
drivetrain.turn_for(LEFT, 5, DEGREES)
else:
drivetrain.drive_for(FORWARD, 25, INCHES)
break
# VR threads — Do not delete
vr_thread(main)
.origine#
.originY renvoie la coordonnée y du coin supérieur gauche de la boîte englobante de l’objet détecté en pixels, qui est un entier compris entre 0 et 240.
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Approach the next Cup and Pin
drivetrain.set_drive_velocity(30, PERCENT)
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
if ai_objects[0].originY > 140:
drivetrain.stop()
break
else:
drivetrain.drive(FORWARD)
# VR threads — Do not delete
vr_thread(main)
.identifiant#
.id renvoie l’ID de la classification IA détectée sous forme d’entier.
Classification par IA |
identifiant |
Signature |
|---|---|---|
RougeBleuPin |
0 |
|
Épingle bleue et jaune |
1 |
|
Épingle rouge/jaune |
2 |
|
YellowPin |
3 |
|
Tasse |
4 |
|
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
drivetrain.turn_for(LEFT, 70, DEGREES)
# Display the ID of the next closest object
while True:
ai_objects = ai_vision.take_snapshot(AiVision.ALL_AIOBJS)
if ai_objects:
brain.screen.print(ai_objects[0].id)
break
# VR threads — Do not delete
vr_thread(main)
Console#
La console affiche du texte, des nombres et les valeurs des variables pendant l’exécution d’un projet. Les méthodes de la console permettent également de déplacer le curseur vers une nouvelle ligne, d’effacer la console et d’ajouter des variables ou des valeurs de capteurs à l’onglet Surveillance.
Imprimer#
cerveau.écran.impression#
brain.screen.print affiche du texte, des nombres ou des valeurs de variables dans la console en utilisant la position actuelle du curseur.
Utilisez brain.screen.next_row lorsque vous souhaitez que la prochaine valeur imprimée commence sur une nouvelle ligne.
Usage:
brain.screen.print(value)
Paramètres |
Description |
|---|---|
|
Le texte, le nombre ou la valeur de variable à afficher dans la console. |
def main():
# Display a message in the Console
brain.screen.print("Hello, robot!")
# VR threads — Do not delete
vr_thread(main)
cerveau.écran.ligne_suivante#
brain.screen.next_row déplace le curseur à la première colonne de la ligne suivante dans la console. La valeur suivante affichée apparaîtra sur cette ligne.
Usage:
brain.screen.next_row()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Print on two rows
brain.screen.print("Row 1")
brain.screen.next_row()
brain.screen.print("Row 2")
# VR threads — Do not delete
vr_thread(main)
cerveau.écran.effacer_écran#
brain.screen.clear_screen efface toutes les lignes de la console et déplace le curseur vers la ligne 1.
Usage:
brain.screen.clear_screen()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Display text, then clear it after two seconds
brain.screen.print("This will disappear...")
wait(2, SECONDS)
brain.screen.clear_screen()
# VR threads — Do not delete
vr_thread(main)
Moniteur#
variable de surveillance#
L’option monitor_variable ajoute une ou plusieurs variables prédéfinies à l’onglet « Surveillance » de VEXcode. Cela vous permet de suivre l’évolution de la valeur d’une variable pendant l’exécution d’un projet.
Pour que la surveillance des variables fonctionne correctement, monitor_variable doivent être globales. Veuillez indiquer le nom de chaque variable sous forme de chaîne de caractères.
Usage:
monitor_variable(“variable”)
monitor_variable(“variable1”, “variable2”)
Paramètres |
Description |
|---|---|
|
Nom d’une variable globale prédéfinie à surveiller, sous forme de chaîne de caractères. Pour surveiller plusieurs variables, séparez leurs noms par une virgule. |
def main():
# Monitor the number of loops
global loops
monitor_variable("loops")
# Turn in a full circle 3 times
for loops in range(12):
drivetrain.turn_for(RIGHT, 90, DEGREES)
# VR threads — Do not delete
vr_thread(main)
capteur_de_surveillance#
L’option monitor_sensor ajoute une ou plusieurs valeurs de capteur à l’onglet Moniteur de VEXcode. Cela vous permet de suivre l’évolution des valeurs des capteurs pendant l’exécution d’un projet.
Fournissez la valeur de chaque capteur sous forme de chaîne de caractères.
Usage:
monitor_sensor(“sensor”)
monitor_sensor(“sensor1”, “sensor2”)
Paramètres |
Description |
|---|---|
|
The sensor value to monitor, given as a string. To monitor more than one sensor value, separate each sensor value with a comma. Supported sensor identifiers include:
|
def main():
# Monitor the robot's heading
monitor_sensor("drivetrain.heading")
drivetrain.turn_for(RIGHT, 450, DEGREES)
# VR threads — Do not delete
vr_thread(main)
Détection#
Distance#
objet trouvé#
found_object indique si le capteur de distance détecte actuellement un objet à moins de 2000 mm.
True— Le capteur de distance détecte un objet.False— Le capteur de distance ne détecte aucun objet.
Usage:
distance.found_object()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Turn until something is detected, then release the Pin
drivetrain.turn(RIGHT)
while True:
wait(5, MSEC)
if distance.found_object():
drivetrain.stop()
break
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
distance objet#
object_distance renvoie la distance entre le capteur de distance et l’objet détecté le plus proche.
Usage:
distance.object_distance(units)
Paramètres |
Description |
|---|---|
|
Unité de distance : |
def main():
# Drive until 200 mm from the Goal, then release the Pin
while distance.object_distance(MM) > 200:
wait(5, MSEC)
drivetrain.drive(FORWARD)
drivetrain.stop()
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
GPS#
position x#
x_position renvoie la coordonnée x actuelle d’un capteur GPS (Game Positioning System™) sur le terrain.
Usage:
gps.x_position(units)
Paramètres |
Description |
|---|---|
unités |
Unité de la valeur de décalage : |
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive(FORWARD)
while not gps.x_position(MM) > -1370:
wait(2, MSEC)
drivetrain.stop()
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
position en y#
y_position renvoie la coordonnée y actuelle d’un capteur GPS (Game Positioning System™) sur le terrain.
Usage:
gps.y_position(units)
Paramètres |
Description |
|---|---|
unités |
Unité de la valeur de décalage : |
def main():
# Raise the Arm, drive to the Goal, release the Pin
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive(FORWARD)
while not gps.y_position(MM) < -450:
wait(2, MSEC)
drivetrain.stop()
claw_motor.spin_for(REVERSE, 180, DEGREES)
# VR threads — Do not delete
vr_thread(main)
titre#
heading renvoie le cap vers lequel le robot est actuellement orienté en fonction des relevés du capteur GPS (Game Positioning System™) de 0 à 359 degrés.
Usage:
gps.heading()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Raise the Arm, drive to the Goal, release the Pin
monitor_sensor("gps.heading")
arm_motor.spin_for(FORWARD, 300, DEGREES)
drivetrain.drive_for(FORWARD, 10, INCHES)
claw_motor.spin_for(REVERSE, 180, DEGREES)
# Turn left to face the Neutral Goal
drivetrain.set_turn_velocity(30, PERCENT)
drivetrain.turn(LEFT)
while not gps.heading() < 18:
wait(2, MSEC)
drivetrain.stop()
# VR threads — Do not delete
vr_thread(main)