Boucles et variables en programmation par blocs avec Arduino

Les boucles et les variables en programmation par blocs sont les deux briques qui font passer un programme de "fais ça une fois" à "fais-le tout le temps, et intelligemment". Une boucle exécute les mêmes blocs encore et encore, et une variable retient un nombre pendant ces répétitions. Dans les blocs BlueGrays, elles s'appellent "répéter indéfiniment", "compter avec i", "variables globales (en haut)" et "définir … à" ; dans le code Arduino envoyé sur la carte, leurs équivalents sont loop(), la boucle for, une variable int et une ligne d'affectation.

Dans cette partie, nous lisons les blocs de quatre projets gratuits à côté de leur vrai code C++ : Chenillard à LED, qui allume six LED l'une après l'autre, Chenillard à LED à vitesse réglable, qui prend sa vitesse sur un potentiomètre, Chenillard K2000 à LED, qui envoie la lumière d'un bout à l'autre puis la ramène, et sa version avec potentiomètre, Chenillard K2000 à vitesse réglable. Les quatre utilisent le même circuit : six LED sur les broches D2–D7 et un potentiomètre sur A0. À la fin, tu écriras ton propre exemple de compteur et tu verras une à une les trois erreurs les plus fréquentes chez les débutants : compter un de trop ou un de moins, déborder d'un tableau et les longues attentes qui rendent les boutons aveugles.

Le bloc "répéter indéfiniment" et loop() : pourquoi la carte ne s'arrête-t-elle jamais ?

Un programme sur ordinateur se ferme quand son travail est fini ; un programme Arduino, non. La carte n'a pas de système d'exploitation et le processeur n'a rien d'autre à faire. C'est pourquoi tous les projets en blocs ont le même squelette : ce qui se trouve dans "configuration (une fois)" s'exécute une seule fois à la mise sous tension ou après un appui sur reset, et ce qui se trouve dans "répéter indéfiniment" se répète de haut en bas sans s'arrêter. Côté C++, ce sont les fonctions setup() et loop(). Quand la dernière ligne de loop() est terminée, la carte revient aussitôt à la première ; une loop() courte sans attente peut tourner des dizaines de milliers de fois par seconde. Le seul moyen d'arrêter la carte est de couper l'alimentation ou de téléverser un autre programme. Cette répétition sans fin n'est pas un défaut, c'est le principe : lire un bouton, surveiller un capteur, allumer une LED, tout cela est refait à chaque tour, et la carte réagit ainsi en permanence à ce qui change autour d'elle.

Les variables en programmation par blocs : variables globales et bloc déclarer

Une variable est une petite boîte dans laquelle tu ranges un nombre et que tu appelles par son nom. Dans les blocs, les variables se créent dans le bloc violet "variables globales (en haut)". Le bloc "déclarer entier (int) potValue = 0" qu'il contient devient la ligne int potValue dans le code : int est le type, potValue le nom et 0 la valeur de départ. "En haut" compte : ces lignes se placent tout en haut du fichier, en dehors de setup() et de loop(). Une variable globale déclarée ainsi est visible partout dans le programme et ne perd pas sa valeur chaque fois que loop() recommence. Sur l'Arduino Uno, un int occupe 2 octets et contient les nombres entiers de -32768 à 32767, largement assez pour la plage 0–1023 de analogRead() et pour les numéros de broche. Tu remarqueras peut-être que les blocs de Chenillard à LED à vitesse réglable indiquent potValue = 0 alors que son code écrit seulement int potValue;. Le résultat est le même : en C++, une variable globale sans valeur de départ commence à zéro.

Le bloc qui modifie une variable par la suite est "définir … à". Le bloc "définir potValue à lecture analogique A0" devient potValue = analogRead(A0); dans le code. Le signe = n'est pas ici l'égalité des maths ; il veut dire "calcule la valeur de droite et range-la dans la boîte de gauche". Une comparaison qui demande si deux valeurs sont égales s'écrit avec == en C++, comme nous l'avons vu avec le bloc si dans la partie précédente de la série. Quand le bloc définir s'exécute, l'ancienne valeur est effacée et la nouvelle est écrite. Tous les blocs qui lisent la variable utilisent désormais cette nouvelle valeur : "attendre potValue ms" attend autant de millisecondes que potValue en contient à cet instant.

La boucle de comptage : le bloc "compter avec i" et la boucle for Arduino

Pour répéter une action un nombre fixe de fois, on utilise le bloc vert "compter avec i de 0 à 5 par 1". Il crée un compteur nommé i, lui donne la valeur 0, exécute les blocs qu'il contient, ajoute 1 à i, les exécute de nouveau et continue jusqu'à ce que i dépasse 5. Son équivalent Arduino est la ligne for (int i = 0; i < 6; i++). Les parenthèses contiennent trois parties séparées par des points-virgules : le départ (int i = 0), la condition pour continuer (i < 6) et le pas après chaque tour (i++, c'est-à-dire ajouter un à i). Le point le plus important : la valeur de fin du bloc est incluse. "De 0 à 5" signifie 0, 1, 2, 3, 4 et 5 ; la boucle fait donc 6 tours, pas 5, et chacune des six LED a le sien. C'est pourquoi le code écrit i < 6, qui revient au même que i <= 5. Le modèle "commencer à zéro, continuer tant que c'est inférieur au nombre d'éléments" est très courant dans le code Arduino, car le 6 donne directement le nombre de LED.

Le bloc tableau : "tableau 2 3 4 5 6 7" et ledPins[i]

Au lieu de déclarer six variables pour six LED, tu peux toutes les garder dans une seule liste. Quand le bloc violet "tableau 2 3 4 5 6 7" est branché sur "déclarer entier (int) ledPins = …", il devient la ligne int ledPins[] = {2, 3, 4, 5, 6, 7}; dans le code. Les crochets indiquent qu'il s'agit d'un tableau et les accolades contiennent ses valeurs. On atteint un élément par sa position, l'indice, et en C++ l'indice commence à 0 : le premier élément est ledPins[0] et le dernier ledPins[5]. Dans les blocs, c'est le rôle de "élément i de ledPins", qui devient ledPins[i]. Comme la boucle de comptage commence elle aussi à 0, les deux s'emboîtent parfaitement : à chaque tour, i donne l'indice suivant et ledPins[i] le numéro de broche qui s'y trouve. Autre avantage : pour changer l'ordre des LED, il suffit d'échanger les nombres de la liste, sans toucher à la boucle. Pour aller plus loin, lis les tableaux sur Arduino.

Chenillard à LED : blocs et C++ ligne par ligne

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2
3void setup() {
4  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
5  for(int i = 0; i < 6; i++) {
6    pinMode(ledPins[i], OUTPUT);
7  }
8}
9
10void loop() {
11  // Her LED'i sırayla 150 ms yak / Light each LED in turn for 150 ms
12  for(int i = 0; i < 6; i++) {
13    digitalWrite(ledPins[i], HIGH);
14    delay(150);
15    digitalWrite(ledPins[i], LOW);
16  }
17}

Imagine le programme comme une frise chronologique. Au démarrage, la boucle de la configuration met les six broches en sortie une à une, de 0 à 5, et cela ne se reproduit plus jamais. Puis répéter indéfiniment commence : la boucle de comptage qu'il contient allume la LED de D2, attend 150 ms, l'éteint, puis fait de même pour D3, D4, D5, D6 et D7. Un tour dure 6 × 150 = 900 ms. Quand la dernière LED s'éteint, loop() se termine, la carte revient aussitôt au début et la lumière repart de D2 ; comme il n'y a pas de pause entre les tours, la lumière semble couler sans interruption. Pour changer la vitesse, un seul nombre suffit, le 150 : avec 50 la lumière va trois fois plus vite, avec 500 elle se promène tranquillement. Rendre cette vitesse fixe réglable avec un bouton rotatif nous amène au projet suivant.

Chenillard à vitesse réglable : la valeur du potentiomètre devient le temps d'attente

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2int potValue;                         // Pot değeri = bekleme (ms) / Pot value = delay (ms)
3
4void setup() {
5  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
6  for(int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for(int i = 0; i < 6; i++) {
13    potValue = analogRead(A0);        // Hızı oku (0-1023) / Read the speed (0-1023)
14    digitalWrite(ledPins[i], HIGH);
15    delay(potValue);                  // Pot değeri kadar ms bekle / Wait as many ms as the pot value
16    digitalWrite(ledPins[i], LOW);
17  }
18}

La seule différence avec le chenillard à LED, ce sont deux nouveaux blocs. "déclarer entier (int) potValue = 0" s'ajoute aux variables globales, et la boucle de comptage commence par "définir potValue à lecture analogique A0". analogRead(A0) transforme la tension sur la broche centrale du potentiomètre en un nombre de 0 à 1023 ; ce nombre passe directement à "attendre potValue ms", c'est-à-dire à la ligne delay(potValue). Tourne le bouton vers une extrémité et chaque LED reste allumée environ une seconde (1023 ms), un tour dure alors près de 6 secondes ; vers l'autre extrémité, l'attente tombe à 0 et les LED commutent si vite qu'elles semblent toutes briller faiblement en même temps. Lire le potentiomètre dans la boucle, avant chaque LED, est un choix voulu : dès que tu tournes, la LED suivante prend la nouvelle vitesse, sans attendre la fin du tour. Le fonctionnement d'un potentiomètre est expliqué dans qu'est-ce qu'un potentiomètre.

K2000 : deux boucles qui comptent à l'aller et au retour

Dans l'effet K2000, la lumière va d'un bout à l'autre puis revient. Les blocs de Chenillard K2000 à LED contiennent deux boucles de comptage l'une sous l'autre dans répéter indéfiniment. La première est le familier "compter avec i de 0 à 5 par 1" et mène la lumière de D2 à D7. La seconde est "compter avec i de 4 à 1 par 1" : comme le départ est plus grand que la fin, le bloc compte à rebours et i prend les valeurs 4, 3, 2, 1. Dans le code, c'est la ligne for(int i = 4; i > 0; i--) ; i-- retire un à i. Pourquoi de 4 à 1 et pas de 5 à 0 ? Parce que ledPins[5] (D7) s'allume déjà à la fin de l'aller et ledPins[0] (D2) au début du suivant. Sauter les extrémités au retour évite que les LED des bouts s'allument deux fois de suite, et le rebond paraît fluide. Un aller-retour, c'est 6 + 4 = 10 pas de 100 ms, soit 1 seconde. Chenillard K2000 à vitesse réglable utilise les deux mêmes boucles ; il ajoute seulement "définir potValue à lecture analogique A0" au début des deux et emploie "attendre potValue ms" au lieu de 100 ms. Pour d'autres motifs, jette un œil à K2000 et chenillard avec Arduino.

Ton propre exemple de compteur : compteur de tours et port série

Écrivons maintenant un petit exemple qui réunit tout : chaque fois que le chenillard termine un tour, un compteur augmente, et la carte envoie à l'ordinateur à la fois les valeurs de i et le nombre de tours. Avec les blocs vus sur les images, on le construirait ainsi : sous le tableau ledPins, dans les variables globales, on ajoute "déclarer entier (int) rounds = 0". La configuration reçoit le bloc "démarrer le port série à 9600 bauds". Dans la boucle de comptage, avant d'allumer la LED, des blocs "écrire sur le port série" affichent le texte "i = ", puis i, puis le texte " pin = " avec l'option "sans retour", et enfin "élément i de ledPins" avec l'option "retour à la ligne". Après la boucle de comptage, toujours dans répéter indéfiniment, un bloc "définir rounds à …" reçoit la somme rounds + 1, et le nombre de tours s'affiche avec "écrire sur le port série … retour à la ligne".

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri / LED pins
2int rounds = 0;                       // tamamlanan tur sayısı / number of finished rounds
3
4void setup() {
5  Serial.begin(9600);                 // seri port 9600 baud / serial port at 9600 baud
6  for (int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for (int i = 0; i < 6; i++) {
13    Serial.print("i = ");             // aynı satırda kal / stay on the same line
14    Serial.print(i);
15    Serial.print("  pin = ");
16    Serial.println(ledPins[i]);       // alt satıra geç / new line
17    digitalWrite(ledPins[i], HIGH);
18    delay(300);
19    digitalWrite(ledPins[i], LOW);
20  }
21  rounds = rounds + 1;                // sayacı bir artır / add one to the counter
22  Serial.print("Tur / Round: ");
23  Serial.println(rounds);
24}

Après le téléversement, ouvre le moniteur série de l'Arduino IDE et règle-le sur 9600 bauds. À chaque tour, tu verras six lignes, de "i = 0 pin = 2" à "i = 5 pin = 7", puis une ligne "Tur / Round" qui compte 1, 2, 3. Cette sortie est la preuve la plus nette que la valeur de fin du bloc compter est incluse : "de 0 à 5" donne exactement six valeurs. Remarque aussi que rounds est déclarée dans les variables globales ; elle n'est pas remise à zéro à chaque début de loop() et garde sa valeur d'un tour à l'autre. Un tour dure 6 × 300 = 1,8 seconde, la limite de int, 32767, est donc atteinte au bout d'environ 16 heures ; pour compter plus longtemps, passe la variable en unsigned long. Plus de détails sur le moniteur série dans le moniteur série Arduino.

Circuit : 6 LED, résistances de 220 Ω et un potentiomètre

Une résistance de 220 Ω laisse passer environ (5 − 2) / 220 ≈ 14 mA dans une LED rouge alimentée en 5 V, une valeur sûre pour la LED comme pour la broche de l'Arduino. Si tu utilises des LED d'une autre couleur, vérifie la résistance avec le calculateur de résistance pour LED. Regroupe toutes les cathodes sur la ligne GND de la breadboard et relie-la à la broche GND de l'Arduino. Si tu inverses les pattes extérieures du potentiomètre, rien ne casse ; seul le sens de rotation s'inverse. Le chenillard à LED et le K2000 n'utilisent pas le potentiomètre, mais le laisser branché ne gêne pas : tu peux ainsi essayer les quatre projets à la suite sur le même circuit.

Erreurs fréquentes avec les boucles et les variables

Explorer les blocs de boucles et de variables dans l'appli BlueGrays

Les quatre projets de cet article et ceux ci-dessous sont entièrement gratuits dans l'appli BlueGrays, blocs et code compris. Dans la partie code d'un projet, active l'interrupteur Voir en blocs : le code est remplacé par les blocs du même programme ; touche l'image pour l'ouvrir en plein écran et zoomer tranquillement sur les longues boucles de comptage. L'onglet Comprendre les blocs parcourt le programme étape par étape et, à chaque étape, montre seulement ses blocs et ce qu'ils font. D'autres projets gratuits à voir en blocs : Gyrophare de police à LED, qui fonctionne avec une variable delayTime et deux boucles de comptage, Feu de circulation, qui enchaîne quatre états dans répéter indéfiniment, Mesurer l'intensité lumineuse avec une LDR, qui garde sa mesure dans une variable et l'écrit sur le port série, et Allumer et éteindre une LED avec un bouton, qui mémorise l'état de la LED dans une variable. Chaque exemple Arduino du Guide du code existe aussi en blocs, et les Questions du jour t'aident à consolider tes acquis avec 5 questions par jour, du niveau A1 au C2. La liste complète des projets en blocs se trouve sur la page programmation par blocs. Les blocs ne sont pas téléversés directement sur la carte ; c'est toujours le vrai code du projet qui y va, tu copies donc dans l'Arduino IDE le programme que tu as compris grâce aux blocs et tu le téléverses.

Maintenant que tu connais les boucles et les variables, l'étape suivante consiste à prendre ces nombres dans le monde réel : dans la 5e partie de la série, nous abordons la lecture de capteurs avec des blocs, le port série et le passage à MicroPython sur la Pico. D'ici là, tu peux consulter dans l'appli BlueGrays le chenillard à LED, le K2000 et leurs versions à vitesse réglable avec schéma et code, passer aux blocs avec Voir en blocs et à l'explication pas à pas avec Comprendre les blocs, et suivre toi-même à quelle ligne de code correspond chaque boucle de comptage.