Programmation par blocs en classe : plan Arduino sur 8 semaines

La robotique éducative, côté programmation, consiste à écrire des programmes qui permettent à une carte de percevoir son environnement, de prendre une décision et de déclencher une action : un bouton ou un capteur de lumière perçoit, l'Arduino décide, une LED, un buzzer ou un moteur réagit. En classe, le plus simple pour enseigner cette boucle est de commencer par la programmation par blocs, puis de passer au vrai code du même programme quand les élèves ont compris la logique. Voici un plan prêt à l'emploi pour la programmation par blocs en classe avec Arduino, destiné aux enseignants, aux clubs de robotique et aux parents qui animent un atelier à la maison : 8 semaines, une séance de 40 minutes par semaine, chacune autour d'un projet à blocs gratuit de BlueGrays.

Chaque semaine du plan comporte un objectif, un projet BlueGrays gratuit, le nouveau bloc découvert cette semaine-là et son équivalent dans le vrai code. Viennent ensuite une liste de matériel pour une classe de 24, une séance type minute par minute, une grille d'évaluation, des pistes de différenciation pour les groupes rapides et plus lents, une variante sans matériel avec des simulateurs et des consignes de sécurité. Le plan repose sur l'Arduino Uno, avec une semaine facultative sur la Raspberry Pi Pico et MicroPython.

Qu'est-ce que la programmation robotique et pourquoi commencer par les blocs ?

Quand on parle de robotique au collège ou en club, on pense tout de suite à une voiture robot, mais tout robot repose sur les trois mêmes tâches : percevoir, décider, agir. Lire un bouton, c'est percevoir ; se demander « le bouton est-il appuyé ? », c'est décider ; allumer une LED ou faire sonner un buzzer, c'est agir. Une fois qu'un élève a compris ces trois étapes avec une LED et un bouton, transposer la même logique aux moteurs et à un capteur de distance revient surtout à changer de composants. C'est pourquoi ce plan commence par les LED et les boutons plutôt que par les moteurs, et arrive aux « yeux » du robot avec le capteur de distance HC-SR04 la dernière semaine.

Pourquoi commencer par les blocs ? Entre 10 et 14 ans, le pire ennemi des premières séances, ce sont les points-virgules, les accolades et les majuscules ; l'élève se demande pourquoi ça ne compile pas au lieu de comprendre ce que fait le programme. Les blocs suppriment ces erreurs, et l'attention va droit à la logique. Rester dans les blocs n'est pas pour autant l'objectif : dans la vraie vie, l'Arduino se programme en C++ et la Pico en MicroPython. Les blocs de BlueGrays sont conçus pour ce pont ; chaque bloc correspond ligne pour ligne au vrai code envoyé sur la carte. Les élèves lisent d'abord les blocs, puis regardent le code du même programme et associent chaque bloc à sa ligne. Tu peux voir tous les projets à blocs et leur fonctionnement sur la page dédiée à la programmation par blocs.

Le plan de 8 semaines de programmation par blocs en classe

Chaque séance est prévue pour 40 minutes et des groupes de 2 ou 3. Tous les projets du tableau sont entièrement gratuits dans BlueGrays, blocs et code compris : les élèves n'ont pas besoin de Premium. L'ordre est voulu : d'abord la sortie (LED), puis le temps, les variables et la répétition, ensuite l'entrée (bouton) et les conditions, la mémorisation d'un état, un capteur analogique, les tableaux et les boucles, et pour finir le son et la distance. Chaque semaine ajoute une seule idée nouvelle à la précédente.

Pendant le plan, fais-en une règle : à la fin de chaque séance, les élèves modifient une seule valeur. En semaine 1, voir la LED ralentir quand l'attente de 100 ms de Clignotement d'une LED passe à 1000 ms donne dès la première séance le sentiment « c'est moi qui pilote le programme ». En semaine 3, faire passer la variable delayTime de Gyrophare de police à LED de 60 à 200 montre qu'un seul nombre agit sur six blocs à la fois ; c'est la façon la plus courte d'expliquer à quoi sert une variable. En semaine 6, régler le seuil de 50 de Veilleuse avec LDR selon la lumière de la salle apprend que les valeurs d'un capteur dépendent de l'environnement. En semaine 7, donne à chaque groupe un potentiomètre de 10 kΩ pour Chenillard à LED à vitesse réglable ; changer la vitesse des LED à la main devient souvent le moment préféré de la semaine.

Liste du matériel pour une classe de 24

Avec 24 élèves en groupes de 3, tu obtiens 8 groupes ; préparer 9 kits, dont un de réserve, suffit. En binômes, calcule les quantités pour 12 groupes. Aucune soudure n'est nécessaire : tout s'enfiche sur la breadboard. Plutôt que d'acheter les composants un par un, compare cette liste au contenu d'un kit de démarrage ; nous détaillons ce que contiennent les kits courants dans le guide du kit de démarrage Arduino.

Séance type : semaine 5, allumer et éteindre une LED avec un bouton

Le déroulé ci-dessous vaut pour une séance de 40 minutes, et tu peux reprendre la même trame chaque semaine : échauffement, lecture collective des blocs, prédiction, montage, vrai code, modification d'une valeur, question de sortie. L'exemple utilise le projet de la semaine 5, Allumer et éteindre une LED avec un bouton, car l'idée qu'« un programme peut se souvenir de quelque chose » est un tournant de la programmation robotique.

1int ledState = 0;     // LED durumu: 0 = kapalı, 1 = açık / LED state: 0 = off, 1 = on
2int lastButton = 0;   // Önceki buton okuması / Previous button reading
3
4void setup() {
5  pinMode(13, INPUT);   // Buton girişi (harici pull-down) / Button input (external pull-down)
6  pinMode(7, OUTPUT);   // LED çıkışı / LED output
7}
8
9void loop() {
10  int button = digitalRead(13);   // Butonu oku / Read the button
11  if (button != lastButton) {     // Buton durumu değişti / Button state changed
12    if (button == 1) {            // Yalnız basış anında (LOW -> HIGH) / Only at the press (LOW -> HIGH)
13      ledState = !ledState;       // Durumu tersine çevir / Flip the state
14      digitalWrite(7, ledState);
15    }
16    delay(50);                    // Sıçramayı atlamak için kısa bekleme / Short wait to skip the bounce
17    lastButton = button;          // Bu okumayı sakla / Store this reading
18  }
19}
20

Quand tu places les blocs et le code côte à côte, la correspondance saute aux yeux : les deux blocs « déclarer entier (int) » dans « variables globales (en haut) » sont les deux premières lignes du code, « configuration (une fois) » devient setup() et « répéter indéfiniment » devient loop(). Le bloc « définir button à lire la broche 13 » est la ligne int button = digitalRead(13), la comparaison « ≠ » est != et « non ledState » est !ledState. Lors de la prédiction, la plupart des groupes disent « si je garde le bouton appuyé, la LED va clignoter » ; en essayant, ils voient qu'elle ne change qu'une fois, car le « si » extérieur ne s'exécute que lorsque l'état du bouton change. Ce moment où une prédiction fausse est corrigée est la minute la plus formatrice de la séance. Quand delay(50) passe à 0, certains appuis inversent la LED deux fois et rien ne semble se passer ; c'est l'entrée idéale pour expliquer les rebonds du bouton. Aux groupes qui se demandent pourquoi le bouton est relié à GND par 10 kΩ, montre le guide pour brancher un bouton-poussoir.

Comment utiliser BlueGrays en classe

• Ouvrir le projet : Les élèves ouvrent le projet de la semaine sur leur téléphone ou une tablette. Le badge blocs dans la liste signale les projets à blocs, et le filtre permet de n'afficher que ceux-là. Chaque projet comprend la liste des composants et le schéma de câblage.
• Voir en blocs : En activant ce bouton dans la partie code, le code est remplacé par les blocs du même programme. Un appui sur l'image l'ouvre en plein écran, idéal pour une lecture collective au vidéoprojecteur. Les blocs s'affichent dans la langue de l'application.
• Comprendre les blocs : Cet onglet explique le programme pas à pas ; à chaque étape, seuls les blocs de cette étape et leur rôle sont affichés. Pour les groupes plus lents, c'est comme un assistant pédagogique.
• Passer au vrai code : Bouton désactivé, le code du même programme apparaît. L'élève le copie dans l'IDE Arduino (dans Thonny pour la Pico) et le téléverse sur la carte.
• Guide du code : On y trouve des exemples de commandes comme digitalWrite, if/else et for, chacun aussi en blocs. Les élèves prennent l'habitude d'y regarder avant de te demander quand ils oublient une commande.
• Questions du jour : Cinq questions par jour, du niveau A1 à C2, avec un classement hebdomadaire et des badges. Tu peux les conseiller pour quelques minutes de révision par jour entre les séances.

Pas de matériel ? Faire cours avec un simulateur

Si les kits ne sont pas encore arrivés ou si tu fais cours à distance, les simulateurs dans le navigateur comme Tinkercad Circuits et Wokwi sont une bonne alternative. Les deux proposent l'Arduino Uno, la breadboard, les LED, les résistances et les boutons, ainsi que de nombreux capteurs ; tu montes le circuit à l'écran et tu le lances en collant le vrai code du projet. Le déroulé reste le même : lire les blocs dans BlueGrays, coller le code dans le simulateur, modifier une valeur, observer le résultat. Tinkercad a aussi son propre éditeur de blocs, si bien que certains enseignants y passent entièrement les premières semaines. Reste que voir une vraie LED s'allumer et brancher des fils sur une breadboard motive énormément ; mieux vaut placer le simulateur avant le matériel plutôt qu'à sa place. Pour l'installation et un premier circuit, consulte les guides sur la simulation Arduino avec Tinkercad et la simulation Wokwi.

Évaluation : une grille pour les séances de robotique

En robotique, le processus compte autant que le résultat : le groupe qui a allumé la LED et celui qui a trouvé pourquoi elle ne s'allumait pas ont peut-être appris la même chose. La grille ci-dessous s'utilise plus facilement en se concentrant sur un critère par séance ; au bout des 8 semaines, il suffit que chaque élève ait été observé au moins une fois sur chacun des six critères. Les questions de sortie alimentent aussi le tableau.

Différenciation pour les groupes rapides et plus lents

• Groupes rapides, tâche bonus : ajouter une quatrième phase au code de Feu de circulation (par exemple rouge et orange ensemble) ou recalculer ses durées pour un vrai carrefour. Ils modifient eux-mêmes le code dans l'IDE Arduino et gardent les blocs comme référence.
• Groupes rapides, combiner : en semaine 8, fusionner HC-SR04 Mesure de la distance (affichage en série) et Utilisation du buzzer en un seul programme qui fait sonner le buzzer quand la distance passe sous 20 cm, un radar de recul simple. C'est le premier vrai pas entre lire des blocs et écrire son propre code.
• Groupes rapides, changer de plateforme : les groupes qui ont une Pico ouvrent le projet LED externe sur Pico et comparent la version MicroPython au code C++ de la semaine 1.
• Groupes plus lents, montage tout prêt : distribue le circuit déjà monté ou pose le schéma imprimé en grand sur la table. Ces groupes consacrent leur temps à lire les blocs et à prédire.
• Groupes plus lents, pas à pas : qu'ils parcourent le programme avec l'onglet Comprendre les blocs et disent en une phrase ce qui se passe à la fin de chaque étape. Modifier une seule valeur est un objectif tout à fait suffisant pour la séance.
• Binômes mixtes : chaque groupe a au moins un « lecteur » ; associer un élève rapide au câblage mais lent à la lecture avec un élève inverse fait progresser les deux.

Passer des blocs au texte : quand et comment ?

Il n'y a pas de semaine fixe pour la transition ; le bon moment, c'est quand un élève peut dire ce que fera le programme rien qu'en regardant les blocs. Dans ce plan, la plupart des classes y arrivent en semaine 4 ou 5. La rencontre avec le code commence pourtant dès le premier jour : comme le vrai code est téléversé à chaque séance, les élèves voient les lignes setup(), loop() et digitalWrite() dès la semaine 1. La transition glisse peu à peu de « je regarde les blocs, je téléverse le code » à « je lis le code, je regarde les blocs si besoin ». Cet ordre facilite le passage :

1. Placer blocs et code côte à côte et retrouver ensemble la ligne qui correspond à chaque bloc (semaines 1 à 3).
2. Masquer les blocs, lire seulement le code et prédire ce que fera le programme ; puis vérifier avec Voir en blocs (semaines 4 et 5).
3. Modifier les valeurs uniquement dans le code : temps d'attente, numéro de broche, seuil. En cas d'erreur de compilation, lire la première ligne (semaines 5 et 6).
4. Écrire une nouvelle ligne : par exemple ajouter une LED au tableau de Chenillard à LED et passer la limite de la boucle de 6 à 7 (semaine 7).
5. Combiner deux projets en un petit programme personnel ; en cas de blocage, consulter les exemples et les blocs du Guide du code (semaine 8 et après).

Conseils de sécurité

La série Des blocs au code en résumé

• Partie 1 : Qu'est-ce que la programmation par blocs et comment un programme à blocs devient du vrai code.
• Partie 2 : Faire clignoter une LED en programmation par blocs : le premier programme, blocs et C++ côte à côte.
• Partie 3 : Le bloc si et un bouton : les conditions et leur équivalent if/else.
• Partie 4 : Boucles et variables : répéter indéfiniment et loop(), compter et for, tableaux, compteurs.
• Partie 5 : Lire des capteurs avec des blocs et MicroPython : port série, LDR, HC-SR04 et la Pico.
• Partie 6 : Cet article, qui transforme tout ce que tu as appris en un plan de 8 semaines pour la classe.

La série s'achève ici ; si tu veux revoir la logique une dernière fois avant de te lancer en classe, reviens au début avec qu'est-ce que la programmation par blocs. Tous les projets du plan sont dans l'application BlueGrays avec leur schéma, leur liste de composants et leur code ; avec Voir en blocs, tu passes à la version en blocs du même programme, avec Comprendre les blocs à l'explication pas à pas, et tu mènes la séance tranquillement depuis le vidéoprojecteur.