6. Contrôle du FetchBot avec Python¶
Objectif: Faire déplacer le FetchBot avec Python.
Âge |
14 à 18 ans |
Notions abordées |
Robotique, programmation avec Python, condition, boucle. |
Durée |
4 heures |
Dispositif pédagogiques |
Par groupe de 2 |
Matériel |
Un FetchBot, Un laptop/tablette par groupe de 2, avec connexion à Internet |
Prérequis |
1. Connaissances de bases de Python (voir Activité 3 - Reconnaissance d’images avec Python) |
6.1. Préparation¶
Ton rover est construit, et tu y es connecté avec VNC viewer depuis un ordinateur ou une tablette.
6.2. Broches de contrôle¶
La carte contrôleur de moteur EduKit prend la sortie de certaines broches GPIO (General Purpose Input/Output) du Raspberry Pi et fait tourner les moteurs en avant ou en arrière selon que ces broches sont activées ou désactivées. La carte contrôleur est un type de contrôleur appelé “H Bridge”. Wikipedia propose un bon article sur le pont en H si tu veux en savoir plus.
La carte contrôleur de moteur EduKit utilise deux broches pour contrôler le moteur gauche et deux broches pour contrôler le moteur droit. Les broches GPIO 9 et 10 contrôlent le moteur A (le moteur de droite), et les broches 7 et 8 contrôlent le moteur B (le moteur de gauche).
Pour chaque moteur, une broche est utilisée pour faire tourner le moteur vers l’avant. L’autre broche GPIO fait tourner le moteur en arrière. Lorsque les deux broches sont désactivées, ou lorsque les deux broches sont activées, le moteur ne tourne pas.
Pour le FetchBot, tu vas utiliser la broche GPIO 10 pour faire tourner le moteur de droite en avant, et la broche GPIO 9 pour le faire tourner en arrière.
Le moteur de gauche utilise la broche GPIO 8 pour le faire tourner en avant et la broche GPIO 7 pour le faire tourner en arrière
6.3. Faire avancer le robot¶
Ouvre l’éditeur Python Thonny, et créé un nouveau fichier en cliquant sur l’icône ‘+’. Copie le code ci-dessous:
Remarque: Tous les textes après les ‘#” sont des commentaires, et tu n’es pas obligé de les recopier. Ils aident cependant à comprendre ce que fait le code.
# Robot forward
import time # Import the Time library
import gpiozero # Import the GPIO Zero Library
right_motor = gpiozero.Motor(9, 10)
left_motor = gpiozero.Motor(7, 8)
# Forward: Turn both motors on with a speed of 0.5
left_motor.forward(0.5)
right_motor.forward(0.5)
# Wait for 1 seconds
time.sleep(1)
# Turn the motors off
left_motor.stop()
right_motor.stop()
Sauvegarde le fichier sous le nom ‘1-rover-forward.py’.
6.3.1. Tester le code¶
Note
Avant d’exécuter le code, allume la batterie.
Note
Place ton robot sur un support de manière à ce que les moteurs ne touchent pas le sol. Tu ne veux pas que ton robot tombe du bureau !
Tu es maintenant prêt à exécuter le code. Clique sur le bouton ‘Run’ de l’éditeur Thonny. Si tu constates que le code ne s’exécute pas correctement, il se peut qu’il y ait une erreur dans le code que tu as tapé.
Tu devrais maintenant voir les deux moteurs tourner en avant en même temps. Si un seul moteur tourne, vérifie ton câblage. Si l’un des moteurs tourne en arrière, intervertis les fils rouge et noir de ce moteur dans le bornier. Continue à tester le code jusqu’à ce que les fils soient à la bonne place.
6.4. Fais tourner le robot¶
Pour faire tourner le robot, il suffit de ne faire avancer qu’un moteur:
Pour faire tourner le robot à gauche, stoppe le moteur gauche et fais tourner le moteur droit:
# Turn left
left_motor.stop()
right_motor.forward(0.5)
Pour faire tourner le robot à droite, stoppe le moteur droit et fais tourner le moteur gauche
# Turn right
right_motor.stop()
left_motor.forward(0.5)
Dans l’éditeur Thonny, créée un nouveau fichier ‘2-rover-forward-turn.py’ et copie le code ci-dessous. Il permet de faire avancer le FetchBot pendant une seconde, puis de le faire tourner à droite pendant une seconde, puis de le faire tourner à gauche pendant une seconde.
# Robot forward, left and right
import time # Import the Time library
import gpiozero # Import the GPIO Zero Library
right_motor = gpiozero.Motor(9, 10)
left_motor = gpiozero.Motor(7, 8)
# Forward: Turn both motors on with a speed of 0.5
left_motor.forward(0.5)
right_motor.forward(0.5)
# Wait for 1 seconds
time.sleep(1)
# Turn the motors off
left_motor.stop()
right_motor.stop()
# Turn right: Only turn on left motor with a speed of 0.5
right_motor.stop()
left_motor.forward(0.5)
# Wait for 1 seconds
time.sleep(1)
# Turn the motors off
left_motor.stop()
right_motor.stop()
# Turn right: Only turn on right motor with a speed of 0.5
right_motor.forward(0.5)
left_motor.stop()
# Wait for 1 seconds
time.sleep(1)
# Turn the motors off
left_motor.stop()
right_motor.stop()
6.5. Utilise des fonctions pour contrôler le robot¶
Le code ci-dessus est un peu difficile à lire. Tu vas utiliser des fonctions pour faire avancer ou tourner le robot, et rendre le code plus clair.
La fonction pour avancer sera appelée ‘forward’, et prendra comme paramètres la vitesse (speed) et la durée pendant laquelle faire avancer le robot (duration). Par défaut, on mettra les valeurs de 0.5 pour la vitesse, et de 1 seconde pour la durée.
def forward(speed=0.5, duration=1):
# Forward: Turn both motors on with the speed "speed"
left_motor.forward(speed)
right_motor.forward(speed)
# Wait for "duration" seconds
time.sleep(duration)
# Turn the motors off
left_motor.stop()
right_motor.stop()
Pour aller en arrière, créons la fonction backward:
def backward(speed=0.5, duration=1):
# Backward: Turn both motors on for backward rotation with the speed "speed"
left_motor.backward(speed)
right_motor.backward(speed)
# Wait for "duration" seconds
time.sleep(duration)
# Turn the motors off
left_motor.stop()
right_motor.stop()
De la même manière, on peut créer deux fonctions pour tourner à droite et tourner à gauche. Appellons-les ‘turn_right’ et ‘turn_left’:
def turn_right(speed=0.5, duration=1):
# right: Turn on right motor backward and left motor forward with a speed of 0.5
right_motor.backward(speed)
left_motor.forward(speed)
# Wait for "duration" seconds
time.sleep(duration)
# Turn the motors off
left_motor.stop()
right_motor.stop()
def turn_left(speed=0.5, duration=1):
# left: Turn on right motor foward and left motor backward with a speed of 0.5
right_motor.forward(speed)
left_motor.backward(speed)
# Wait for "duration" seconds
time.sleep(duration)
# Turn the motors off
left_motor.stop()
right_motor.stop()
Note
Pour les fonctions permettant de tourner, le code a été modifié pour que les deux moteurs tournent de façon inverse, ce qui permettra au robot de tourner plus efficacement.
Dans l’éditeur Thonny, créée un nouveau fichier ‘motor_control.py’ et copie le code ci-dessous où les fonctions sont utilisées pour contrôler le FetchBot. Avec ces fonctions, tu peux écrire de façon plus claire la suite de déplacements que tu veux faire, par exemple, avancer pendant deux secondes à la vitesse 1, puis tourner à gauche pendant 3 secondes à la vitesse 0.5, puis avancer pendant 1 seconde à la vitesse 0.5.
# Robot forward, left and right
import time # Import the Time library
import gpiozero # Import the GPIO Zero Library
right_motor = gpiozero.Motor(9, 10)
left_motor = gpiozero.Motor(7, 8)
def forward(speed=0.5, duration=1):
# Forward: Turn both motors on with the speed "speed"
left_motor.forward(speed)
right_motor.forward(speed)
# Wait for "duration" seconds
time.sleep(duration)
# Turn the motors off
left_motor.stop()
right_motor.stop()
def backward(speed=0.5, duration=1):
# Backward: Turn both motors on for backward rotation with the speed "speed"
left_motor.backward(speed)
right_motor.backward(speed)
# Wait for "duration" seconds
time.sleep(duration)
# Turn the motors off
left_motor.stop()
right_motor.stop()
def turn_right(speed=0.5, duration=1):
# right: Turn on right motor backward and left motor forward with a speed of 0.5
right_motor.backward(speed)
left_motor.forward(speed)
# Wait for "duration" seconds
time.sleep(duration)
# Turn the motors off
left_motor.stop()
right_motor.stop()
def turn_left(speed=0.5, duration=1):
# left: Turn on right motor foward and left motor backward with a speed of 0.5
right_motor.forward(speed)
left_motor.backward(speed)
# Wait for "duration" seconds
time.sleep(duration)
# Turn the motors off
left_motor.stop()
right_motor.stop()
Crée maintenant un nouveau fichier ‘3-test-rover.py’ où tu importes ce code avec l’instruction import motor_control. Tu peux ensuite appeler les fonctions pour contrôler le FetchBot en rajoutant motor_control avant le nom de la fonction. Le code est beaucoup plus clair:
# Import functions for controlling robot
import motor_control
# Move forward
motor_control.forward(speed=1, duration=3)
# Turn left
motor_control.turn_left(speed=0.5, duration=2)
# Move forward
motor_control.forward(speed=0.5, duration=1)
Copie ce code dans le nouveau fichier ‘3-rover-control.py’ et teste-le.
6.6. Pour aller plus loin¶
Tu sais maintenant comment faire avancer ou tourner le FetchBot à différentes vitesses, et pour différentes durées. Expérimente avec différents parcours. Pourrais-tu faire le code qui permettrait au robot de faire un itinéraire en forme de carré?