mBot2 - programmation mBlock/python

Programmer mBot2 – Parcours d’exercices (blocs + Python)

Dans ce cours, tu vas apprendre à programmer le robot mBot2 avec :

• les blocs (mBlock, façon Scratch),
• et, en option, quelques idées de code Python.

Pour chaque exercice :

• on commence par la version en blocs (à faire en priorité),
• puis on voit comment on ferait la même chose en Python (pour ceux qui veulent aller plus loin).

---

0. Préparation – Bien démarrer avec mBot2

Avant de commencer :

• Vérifie que la batterie de mBot2 est chargée.
• Ouvre mBlock sur ton ordinateur ou ta tablette.
• Ajoute le robot mBot2 dans ton projet.
• Connecte le robot (USB ou Bluetooth).

Teste un tout petit programme :

• Allumer les LEDs en bleu pendant 2 secondes,
• Puis les éteindre.

Si ça marche, tu es prêt(e) pour la suite !

---

Exercice 1 – Faire avancer et reculer le robot

Objectif : Découvrir les moteurs, la vitesse et la durée.

Version en blocs (mBlock)

1. Crée un nouveau programme mBlock avec mBot2 connecté.
2. Ajoute un bloc du style « quand le programme démarre » (ou quand on clique sur le drapeau).
3. Ajoute un bloc du type : « régler les vitesses des moteurs à 50 % » (ou similaire).
4. Ajoute ensuite un bloc « attendre 2 secondes ».
5. Ajoute un bloc pour arrêter les moteurs.
6. Ajoute ensuite :
   • un bloc pour mettre les moteurs à une vitesse négative (par ex. -50) → le robot recule,
   • un bloc « attendre 2 secondes »,
   • un bloc « arrêter les moteurs ».

Idée : teste plusieurs vitesses (20, 50, 80, etc.) et observe la différence.

Version en Python (optionnel)

Idée générale des étapes en Python :

1. Importer les modules nécessaires (par exemple from mbot2 import * et import time).
2. Dire aux moteurs d’avancer (par exemple chassis.set_speed(50, 50)).
3. Utiliser time.sleep(2) pour attendre 2 secondes.
4. Arrêter les moteurs : chassis.set_speed(0, 0).
5. Régler une vitesse négative pour reculer, attendre, puis arrêter à nouveau.

from mbot2 import *
import time

# Avancer 2 secondes
chassis.set_speed(50, 50)
time.sleep(2)
chassis.set_speed(0, 0)

# Reculer 2 secondes
chassis.set_speed(-50, -50)
time.sleep(2)
chassis.set_speed(0, 0)

---

Exercice 2 – Tourner à gauche et à droite

Objectif : Comprendre comment tourner en jouant sur les deux moteurs.

Version en blocs (mBlock)

1. Faire avancer le robot tout droit pendant 1 seconde (comme à l’exercice 1).
2. Pour tourner à droite sur place :
   • Moteur gauche : vitesse positive (ex. 50),
   • Moteur droit : vitesse négative (ex. -50).
   • Ajouter « attendre 0,5 seconde » puis arrêter les moteurs.
3. Refaire la même chose pour tourner à gauche (inverser les signes des vitesses).
4. Enchaîner : avancer → tourner → avancer → tourner → etc., pour essayer de dessiner un carré.

Version en Python (optionnel)

1. Avancer comme dans l’exercice 1 : chassis.set_speed(50, 50), puis time.sleep(1).
2. Pour tourner à droite :
   • chassis.set_speed(50, -50) pour faire tourner le robot sur lui-même.
   • time.sleep(0.5) pour contrôler la durée de la rotation.
   • Arrêter : chassis.set_speed(0, 0).
3. Réutiliser ce schéma plusieurs fois pour dessiner un carré.

---

Exercice 3 – Lumières et sons

Objectif : Utiliser les LEDs et le buzzer pour rendre le robot “expressif”.

Version en blocs (mBlock)

1. Ajouter un bloc pour régler la couleur des LEDs de la face avant (par exemple rouge).
2. Ajouter « attendre 0,5 seconde », puis changer la couleur en vert, puis en bleu, puis éteindre.
3. Ajouter des blocs pour jouer une note ou une sonnerie à chaque changement de couleur.
4. Créer une petite “séquence de démarrage” :
   • Rouge + son grave,
   • Puis orange + son moyen,
   • Puis vert + son aigu,
   • Puis le robot commence à avancer.

Version en Python (optionnel)

1. Importer le module pour les LEDs et le haut-parleur (souvent accessible via mbot2 ou modules associés).
2. Utiliser une fonction du type rgb_led.show_color(r, g, b) (le nom exact dépend de la bibliothèque).
3. Utiliser la fonction du haut-parleur, par exemple speaker.play_tone(frequence, durée).
4. Alterner : couleur → son → pause → nouvelle couleur → etc.

L’important ici : comprendre que le Python fait la même chose que les blocs, mais sous forme de lignes de texte.

---

Exercice 4 – Capteur de distance : éviter un obstacle

Objectif : Utiliser le capteur de distance pour que le robot réagisse à un obstacle.

Version en blocs (mBlock)

1. Créer une variable distance pour voir la valeur du capteur.
2. Dans une boucle “répéter indéfiniment” :
   • Mettre la variable distance à la valeur renvoyée par le capteur de distance (bloc prévu dans mBlock pour mBot2).
   • Afficher cette valeur sur l’écran ou simplement la laisser visible dans la liste des variables.
3. Ajouter une condition :
   • Si distance < 20 cm :
     • arrêter les moteurs,
     • reculer un peu,
     • tourner à gauche,
     • repartir en avant.
   • Sinon : avancer tout droit.

Version en Python (optionnel)

1. Lire la distance avec une fonction du type d = ultrasonic_sensor.get_distance().
2. Afficher cette valeur dans la console Python avec print(d) (côté PC) si tu peux.
3. Utiliser une boucle while True: pour répéter le comportement :
   • Lire la distance,
   • Si d < 20 :
     • arrêter, reculer, tourner,
   • Sinon, avancer.
4. Ajouter un petit time.sleep(0.05) dans la boucle pour éviter que le robot ne change d’avis trop vite.

---

Exercice 5 – Suivi de ligne (capteur de ligne)

Objectif : Utiliser les capteurs de ligne pour faire suivre une bande noire au robot.

Version en blocs (mBlock)

1. Tracer une ligne noire sur une feuille (ou au sol) : un circuit simple.
2. Afficher les valeurs des capteurs de ligne (gauche et droite) dans mBlock.
3. Tester en mettant le robot sur le blanc, puis sur le noir, pour voir la différence de valeur.
4. Dans une boucle “répéter indéfiniment” :
   • Si le capteur gauche voit du noir → tourner légèrement à gauche.
   • Si le capteur droit voit du noir → tourner légèrement à droite.
   • Sinon → avancer tout droit.
5. Ajuster les vitesses jusqu’à ce que mBot2 suive bien la ligne.

Version en Python (optionnel)

1. Lire les valeurs des capteurs de ligne, par exemple :
   • gauche = line_sensor.get_left()
   • droite = line_sensor.get_right()
   (les noms exacts dépendent de la bibliothèque utilisée).
2. Dans une boucle while True: :
   • Lire gauche et droite.
   • Si gauche détecte le noir → mettre le moteur gauche plus lent que le droit.
   • Si droite détecte le noir → moteur droit plus lent que le gauche.
   • Sinon → mêmes vitesses pour les deux moteurs.
3. Ajouter un time.sleep(0.01) pour rendre le mouvement plus stable.

---

Exercice 6 – Gyroscope : tourner de 90° précisément

Objectif : Utiliser le capteur d’orientation pour faire des rotations précises.

Version en blocs (mBlock)

1. Repérer le bloc qui donne l’angle du robot (gyroscope).
2. Créer une variable « angleDépart ».
3. Quand on commence la rotation :
   • mettre angleDépart à la valeur actuelle de l’angle,
   • mettre les moteurs pour tourner (par exemple gauche 50, droit -50).
4. Dans une boucle « répéter jusqu’à ce que » :
   • tester si l’angle actuel est supérieur à angleDépart + 90,
   • si oui, arrêter les moteurs.

Version en Python (optionnel)

1. Lire l’angle actuel du robot, par ex. :
   • angle_depart = gyro.get_yaw() (le nom exact peut varier).
2. Mettre les moteurs en rotation :
   • chassis.set_speed(50, -50)
3. Dans une boucle, relire l’angle :
   • angle_actuel = gyro.get_yaw()
   • Si angle_actuel >= angle_depart + 90 :
     • arrêter les moteurs et quitter la boucle.
4. Ajouter un petit time.sleep(0.01) à l’intérieur de la boucle.

---

Exercice 7 – Combiner plusieurs capteurs

Objectif : Mélanger capteur de ligne, capteur de distance, LEDs et sons pour un comportement plus “intelligent”.

Scénario possible :

• Le robot suit une ligne.
• S’il détecte un obstacle trop proche, il s’arrête, clignote en rouge, joue un son, contourne l’obstacle, puis revient sur la ligne.

Version en blocs (mBlock)

1. Reprendre la base du suivi de ligne (Exercice 5).
2. Dans la boucle principale :
   • Commencer par mesurer la distance avec le capteur.
   • Si distance < 15 :
     • arrêter les moteurs,
     • allumer les LEDs en rouge,
     • jouer un son d’alerte,
     • reculer un peu et tourner,
     • puis essayer de retrouver la ligne.
   • Sinon :
     • continuer normalement le code du suivi de ligne.

Version en Python (optionnel)

1. Dans une boucle infinie :
   • Lire la distance avec le capteur ultrason.
   • Lire les capteurs de ligne.
2. Si distance < 15 :
   • arrêter les moteurs, allumer les LEDs en rouge, jouer un son, reculer, tourner, etc.
3. Sinon :
   • appliquer la logique du suivi de ligne (comme à l’exercice 5) : ajuster les vitesses en fonction des capteurs gauche/droite.
4. Fin de la boucle : petit time.sleep(0.01) pour stabiliser le comportement.

---

Exercice 8 – mBot2 en mode Python (pour aller plus loin)

Objectif : Comprendre comment traduire une idée en blocs en quelques lignes de Python.

Par exemple, on peut reprendre le principe de l’Exercice 4 (éviter un obstacle) en Python.

Étapes générales :

1. Importer les modules nécessaires : from mbot2 import * et import time.
2. Créer une boucle while True: qui tourne en continu.
3. À chaque tour de boucle :
   • lire la distance : d = ultrasonic_sensor.get_distance(),
   • si d < 20 : reculer, tourner, etc.,
   • sinon : avancer.
4. Terminer le tour de boucle avec time.sleep(0.05) pour que le robot ne soit pas trop “nerveux”.

Tu peux essayer de partir d’un programme en blocs que tu comprends bien, puis de chercher à quoi il ressemblerait en Python.

---

Exercice 9 – Projet final : Parcours d’aventure

Objectif : Créer ton propre parcours en utilisant plusieurs fonctions du robot.

Idée de scénario :

• Le robot démarre quand on appuie sur un bouton.
• Il suit une ligne de départ.
• Il évite au moins un obstacle avec le capteur de distance.
• Il termine sur une “zone d’arrivée” où il joue une animation de LEDs + sons.

Version en blocs (mBlock)

1. Réutiliser les blocs des exercices précédents :
   • blocs moteurs (avancer, tourner),
   • capteur de distance,
   • capteurs de ligne,
   • LEDs et sons.
2. Organiser le programme en plusieurs parties (par exemple avec des messages ou des blocs personnalisés) :
   • « démarrage »
   • « suivre la ligne »
   • « éviter l’obstacle »
   • « célébration de fin »

Version en Python (optionnel)

1. Créer des fonctions Python qui jouent le rôle des blocs :
   • def suivre_ligne(): ...
   • def eviter_obstacle(): ...
   • def celebration(): ...
2. Dans while True:, décider dans quel “état” se trouve le robot et appeler la bonne fonction.
3. Par exemple, utiliser une variable etat qui vaut "depart", puis "parcours", puis "fin".

---

QCM de révision – Comprends-tu ton mBot2 ?

1. 1. Le capteur de distance du mBot2 sert principalement à :

   • A. Mesurer la couleur du sol.
   • B. Mesurer la distance entre le robot et un obstacle.
   • C. Afficher des images sur l’écran.
   • D. Changer la vitesse des moteurs.

2. 2. Pour suivre une ligne noire sur fond blanc, on utilise surtout :

   • A. Le buzzer.
   • B. Les capteurs de ligne sous le robot.
   • C. Le capteur de distance.
   • D. Le gyroscope.

3. 3. Le gyroscope est utile pour :

   • A. Jouer de la musique.
   • B. Tourner le robot avec un angle précis (par exemple 90°).
   • C. Voir la couleur du sol.
   • D. Augmenter la vitesse des moteurs.

4. 4. Quand on combine plusieurs capteurs (ligne + distance), il faut :

   • A. Ignorer tous les capteurs sauf un.
   • B. Réfléchir à l’ordre dans lequel on teste les capteurs et quelles actions sont prioritaires.
   • C. Ne jamais utiliser de conditions.
   • D. Utiliser toujours la même action.

5. 5. Une “boucle” (bloc répéter ou while en Python) sert à :

   • A. Faire une instruction une seule fois.
   • B. Répéter plusieurs fois un même groupe d’instructions.
   • C. Éteindre le robot.
   • D. Changer la couleur des blocs.

Corrigé : 1-B, 2-B, 3-B, 4-B, 5-B.

Avec ces exercices, tu as exploré une grande partie des possibilités de mBot2 : moteurs, capteurs, LEDs, sons, blocs et même un peu de Python. Tu peux maintenant inventer tes propres défis !