Python spécifique aux robots#
Introduction#
Le robot héros Swish comprend une option de moteur, une option de groupe de moteurs et le capteur optique.
Toutes les méthodes VR standard VEXcode sont disponibles pour une utilisation dans le IQ 24-25 Rapid Relay 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 le moteur et le groupe de moteurs du robot.
Actes
spin— Fait tourner un moteur ou un groupe de moteurs en avant ou en arrière indéfiniment.spin_for— Fait tourner un moteur ou un groupe de moteurs sur une distance spécifique.spin_to_position— Fait tourner un moteur ou un groupe de moteurs vers une position spécifique.stop— Empêche un moteur ou un groupe de moteurs de tourner.
Mutateurs
set_position— Modifie la position actuelle du moteur ou du groupe de moteurs à une nouvelle valeur.set_velocity— Indique à un moteur ou à un groupe de moteurs à quelle vitesse tourner.set_timeout— Définit le temps pendant lequel un moteur ou un groupe de moteurs essaiera de terminer un mouvement.
Attrapeurs
is_done— Renvoie si le moteur ou le groupe de moteurs a fini de bouger, sous forme de valeur booléenne.is_spinning— Renvoie si le moteur ou le groupe de moteurs tourne, sous forme de valeur booléenne.position— Renvoie la position actuelle du moteur ou du groupe de moteurs.velocity— Renvoie la vitesse de rotation du moteur ou du groupe de moteurs.
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.
Optique
is_near_object– Renvoie si le capteur optique détecte un objet à portée.color– Renvoie la couleur détectée par le capteur optique.brightness– Renvoie la quantité de lumière réfléchie par l’objet.hue– Renvoie la teinte détectée par le capteur optique.object_detected– Enregistre une fonction à appeler lorsque le capteur optique détecte un objet.object_lost– Enregistre une fonction à appeler lorsque le capteur optique perd un objet.
Les exemples de cette page utilisent la position de départ par défaut du Playground.
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():
# Drive forward then stop
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop()
# VR threads — Do not delete
vr_thread(main)
conduire_pour#
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 |
|---|---|
|
La direction dans laquelle le robot se déplace : |
|
La distance parcourue par le robot. Cela peut être un entier |
|
L’unité de distance : |
|
Optionnel. |
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)
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():
# 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)
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 |
|
L’unité de rotation : |
|
Optionnel. |
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)
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 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 |
|---|---|
|
La direction vers laquelle le robot doit être orienté, en degrés. Cela peut être un entier |
|
L’unité de rotation : |
|
Optionnel. |
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)
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é. 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 |
|---|---|
|
La valeur de rotation, en degrés, vers laquelle le robot tournera. Cela peut être un entier |
|
L’unité de rotation : |
|
Optionnel. |
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)
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():
# Drive forward then stop
drivetrain.drive(FORWARD)
wait(2, SECONDS)
drivetrain.stop()
# 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. Cela peut être un entier |
|
L’unité d’en-tête : |
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)
définir_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 |
|---|---|
|
La valeur de rotation, en degrés, à définir pour le robot. Cela peut être un entier |
|
L’unité de rotation : |
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)
définir_délai#
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 |
|
L’unité de temps : |
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)
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 |
|
L’unité de vitesse : |
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)
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 |
|
L’unité de vitesse : |
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#
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 |
|---|---|
|
L’unité d’en-tête : |
def main():
# Display the heading after turning
drivetrain.turn_for(RIGHT, 450, 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 |
|---|---|
|
L’unité de rotation : |
def main():
# Display the rotation after turning
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. |
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. |
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 |
|---|---|
|
L’unité de vitesse : |
Exemple
def main():
# Display the velocity after driving
drivetrain.drive_for(FORWARD, 150, MM)
brain.screen.print("Velocity: ")
brain.screen.print(drivetrain.velocity(PERCENT))
Mouvement#
Swish utilise le moteur d’aspiration pour collecter les balles et les acheminer vers la catapulte. Le groupe moteur de la catapulte abaisse et libère le bras de la catapulte pour lancer les balles.
Chaque moteur et groupe de moteurs possède son propre comportement directionnel. Les descriptions de direction expliquent comment chaque direction actionne le moteur ou le groupe de moteurs correspondant sur Swish.
Actes#
rotation#
La commande spin fait tourner un moteur ou un groupe de moteurs en marche avant ou arrière en continu. Le moteur ou le groupe de moteurs continuera de tourner jusqu’à ce qu’une autre action lui soit donnée, comme un changement de sens de rotation ou un arrêt.
Utilisation :
L’un des deux objets moteur ou groupe de moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
Sens de rotation du moteur ou du groupe moteur :
|
def main():
# Spin the Intake Motor to bring a Ball onto the Catapult
intake_motor.spin(FORWARD)
wait(2, SECONDS)
intake_motor.stop()
# VR threads — Do not delete
vr_thread(main)
tourner_pour#
La fonction spin_for fait tourner un moteur ou un groupe de moteurs sur une distance spécifique. Cette distance est relative à la position actuelle du moteur ou du groupe de moteurs. Le programme attendra la fin de la rotation avant d’exécuter la ligne de code suivante.
Utilisation :
L’un des deux objets moteur ou groupe de moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
Sens de rotation du moteur ou du groupe moteur :
|
|
Distance de rotation du moteur ou du groupe de moteurs. |
|
Facultatif. L’unité de distance : |
|
Facultatif.
|
def main():
# Release the preloaded Ball
catapult_group.spin_for(REVERSE, 5, DEGREES)
# Lower the Catapult to prepare to load another Ball
catapult_group.spin_for(FORWARD, 1350, DEGREES)
# VR threads — Do not delete
vr_thread(main)
rotation_vers_position#
spin_to_position fait tourner un moteur ou un groupe de moteurs vers une position spécifique.
A motor or motor group’s position is how far it has spun, measured in DEGREES or TURNS. One turn is equal to 360 degrees. At the beginning of a project, the motor or motor group position is set to 0 degrees. The motor or motor group 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 ou du groupe de moteurs.
Par exemple, si le moteur ou le groupe de moteurs 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 moteur ou groupe de 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 ou du groupe de moteurs. |
|
Facultatif. L’unité de position : |
|
Facultatif.
|
def main():
# Release the preloaded Ball
catapult_group.spin_to_position(-90, DEGREES)
# Lower the Catapult to prepare to load another Ball
catapult_group.spin_to_position(1260, DEGREES)
# VR threads — Do not delete
vr_thread(main)
moteur d’arrêt#
stop empêche un moteur ou un groupe de moteurs de tourner.
Utilisation :
L’un des deux objets moteur ou groupe de 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():
# Spin the Intake Motor to bring a Ball onto the Catapult
intake_motor.spin(FORWARD)
wait(2, SECONDS)
intake_motor.stop()
# VR threads — Do not delete
vr_thread(main)
Mutateurs#
définir_position#
A motor or motor group’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 or motor group’s current position to a new value.
Par exemple, si un moteur ou un groupe de moteurs a pivoté de 180 degrés, le fait de le positionner à 0 degré le ramènera à sa position initiale. Le moteur ou le groupe de moteurs pourra ensuite pivoter selon cette nouvelle valeur.
Utilisation :
L’un des deux objets moteur ou groupe de 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 ou le groupe de moteurs. |
|
Facultatif. L’unité de position : |
def main():
# Lower the Catapult to prepare to load another Ball
catapult_group.spin_to_position(1260, DEGREES)
# Set the new Catapult position to be 0 degrees
catapult_group.set_position(0, DEGREES)
# VR threads — Do not delete
vr_thread(main)
définir_vitesse#
La valeur set_velocity indique à un moteur ou à un groupe de moteurs sa vitesse de rotation. Un pourcentage plus élevé augmente la vitesse de rotation, tandis qu’un pourcentage plus faible la diminue.
Chaque projet commence par une vitesse de rotation de 50 % pour chaque moteur ou groupe de moteurs, par défaut.
Remarque : Une vitesse plus élevée fait tourner le moteur ou le groupe de moteurs plus vite, mais la précision peut être moindre. Une vitesse plus faible fait tourner le moteur ou le groupe de moteurs plus lentement, mais la précision peut être meilleure.
Utilisation :
L’un des deux objets moteur ou groupe de moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
La vitesse de rotation de -100% à 100%. Cela peut être un entier |
|
L’unité de vitesse : |
def main():
# Start spinning the Intake Motor to prepare for picking up a Ball
intake_motor.set_velocity(100, PERCENT)
intake_motor.spin(FORWARD)
# 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 ou un groupe de moteurs tente de terminer un mouvement. Si le moteur ou le groupe de moteurs ne parvient pas à terminer dans ce délai, il interrompt ses tentatives et passe à la ligne de code suivante. Ceci évite le blocage du moteur ou du groupe de moteurs lors d’un mouvement.
Utilisation :
L’un des deux objets moteur ou groupe de moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
Le temps pendant lequel le moteur ou le groupe de moteurs peut tenter de terminer un mouvement. Cela peut être un entier positif |
|
L’unité de temps : |
def main():
# Limit how long the Catapult waits to reach its target
catapult_group.set_timeout(2, SECONDS)
catapult_group.spin_for(FORWARD, 2160, DEGREES)
# VR threads — Do not delete
vr_thread(main)
Getters#
est_terminé#
La fonction is_done renvoie is_done indiquant si le moteur ou le groupe de moteurs a terminé son mouvement (valeur booléenne). Cette information peut servir à contrôler le déclenchement d’autres actions en fonction du mouvement du moteur ou du groupe de moteurs.
True— Le moteur ou le groupe de moteurs a terminé son mouvement.False— Le moteur ou le groupe de moteurs est toujours en mouvement.
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 moteur ou groupe de 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. |
est_en_roulement#
La fonction is_spinning (valeur booléenne is_spinning indique si le moteur ou le groupe de moteurs est en rotation. Cette information peut être utilisée pour contrôler la synchronisation d’autres actions en fonction du mouvement du moteur ou du groupe de moteurs.
True— Le moteur ou le groupe de moteurs tourne.False— Le moteur ou le groupe 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 moteur ou groupe de 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. |
position#
A motor or motor group’s position is how far it has spun, measured in DEGREES or TURNS. One turn is equal to 360 degrees. position returns the motor or motor group’s current position.
Au début d’un projet, la position du moteur ou du groupe de moteurs est initialement fixée à 0 degré. Si le moteur ou le groupe de moteurs effectue une rotation complète dans un sens, sa position sera de 360 degrés, soit un tour. S’il tourne dans l’autre sens, sa position sera négative.
Utilisation :
L’un des deux objets moteur ou groupe de moteurs disponibles peut être utilisé avec cette méthode, comme indiqué ci-dessous :
moteur |
Commande |
|---|---|
|
|
|
|
Paramètres |
Description |
|---|---|
|
L’unité permet de ramener la position du moteur ou du groupe de moteurs dans : |
def main():
# Lower the Catapult to prepare to load another Ball
while not catapult_group.position(DEGREES) == 1260:
catapult_group.spin(FORWARD)
# VR threads — Do not delete
vr_thread(main)
vitesse#
La vitesse velocity indique la vitesse de rotation du moteur ou du groupe de moteurs.
Une valeur positive indique que le moteur ou le groupe de moteurs tourne dans le sens horaire. Une valeur négative indique que le moteur ou le groupe de moteurs tourne dans le sens antihoraire.
Utilisation :
L’un des deux objets moteur ou groupe de 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():
# Print the current Catapult velocity
brain.screen.print(catapult_group.velocity(PERCENT))
# 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 displays text, numbers, or variable values in the Console using the current cursor position. It behaves like print on the Console API page.
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 amount of loops
global loops
monitor_variable("loops")
# Drive in a square 3 times
for loops in range(12):
drivetrain.turn_for(RIGHT, 90, DEGREES)
drivetrain.drive_for(FORWARD, 150, MM)
# 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#
Optique#
est_proche_objet#
is_near_object renvoie une valeur booléenne indiquant si le capteur optique détecte ou non un objet à portée.
True– Le capteur optique détecte un objet.False– Le capteur optique ne détecte aucun objet.
Usage:
intake_optical.is_near_object()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Launch a loaded Ball once the Intake Optical Sensor detects a Ball
if intake_optical.is_near_object():
catapult_group.spin_for(REVERSE, 5, DEGREES)
# VR threads — Do not delete
vr_thread(main)
couleur#
La fonction color renvoie une instance d’une classe Color , en fonction de la valeur de teinte détectée. Ces instances peuvent être comparées à des objets Color prédéfinis pour créer des instructions conditionnelles.
Les couleurs possibles sont :
NONERED- Une valeur de teinte comprise entre 340° et 20°GREEN- Une valeur de teinte comprise entre 80° et 140°BLUE- Une valeur de teinte comprise entre 200° et 240°YELLOW- Une valeur de teinte comprise entre 40° et 60°ORANGE- Une valeur de teinte comprise entre 20° et 40°PURPLE- Une valeur de teinte comprise entre 240° et 280°CYAN- Une valeur de teinte comprise entre 140° et 200°
Remarque : Le capteur optique recherche des plages de teintes correspondant à la couleur spécifiée. Pour détecter des plages de teintes spécifiques, voir hue.
Usage:
intake_optical.color()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Launch a loaded Ball once yellow is detected in the Intake
if intake_optical.color() == YELLOW:
catapult_group.spin_for(REVERSE, 5, DEGREES)
# VR threads — Do not delete
vr_thread(main)
luminosité#
brightness renvoie la quantité de lumière réfléchie par l’objet sous forme décimale (float) représentant un pourcentage.
Un pourcentage plus élevé signifie qu’une plus grande quantité de lumière est réfléchie vers le capteur optique. Un pourcentage plus faible signifie qu’une moindre quantité de lumière est réfléchie.
Usage:
intake_optical.brightness()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Launch a loaded Ball once the Intake Optical Sensor sees a Ball
if intake_optical.brightness() > 0:
catapult_group.spin_for(REVERSE, 5, DEGREES)
# VR threads — Do not delete
vr_thread(main)
teinte#
hue renvoie la valeur de teinte de la couleur détectée sous forme décimale (float) de 0 à 359.
La teinte est une façon de décrire une couleur à l’aide de nombres sur un cercle chromatique.
Usage:
intake_optical.hue()
Paramètres |
Description |
|---|---|
Cette méthode ne comporte aucun paramètre. |
def main():
# Launch a loaded Ball once the Intake Optical Sensor reports a hue value
if intake_optical.hue() > 100:
catapult_group.spin_for(REVERSE, 5, DEGREES)
# VR threads — Do not delete
vr_thread(main)
objet_détecté#
object_detected enregistre une fonction à appeler chaque fois que le capteur optique détecte un nouvel objet.
Usage:
intake_optical.object_detected(callback, arg)
Paramètres |
Description |
|---|---|
|
Une fonction précédemment définie qui s’exécute lorsque le capteur optique détecte un nouvel objet. |
|
Facultatif. Un tuple contenant les arguments à transmettre à la fonction de rappel. Voir Utilisation des fonctions avec paramètres pour plus d’informations. |
def launch_ball():
catapult_group.spin_for(REVERSE, 5, DEGREES)
def main():
# Launch the Ball when the Intake Optical Sensor detects an object
intake_optical.object_detected(launch_ball)
# VR threads — Do not delete
vr_thread(main)
objet_perdu#
object_lost enregistre une fonction à appeler chaque fois que le capteur optique perd un objet détecté.
Usage:
intake_optical.object_lost(callback, arg)
Paramètres |
Description |
|---|---|
|
Une fonction définie précédemment qui s’exécute lorsque le capteur optique perd un objet détecté. |
|
Facultatif. Un tuple contenant les arguments à transmettre à la fonction de rappel. Voir Utilisation des fonctions avec paramètres pour plus d’informations. |
def lower_catapult():
catapult_group.spin_to_position(1260, DEGREES)
def main():
# Lower the Catapult when the Intake Optical Sensor no longer detects an object
intake_optical.object_lost(lower_catapult)
# VR threads — Do not delete
vr_thread(main)