Programmation par blocs Arduino : faire clignoter une LED

En programmation par blocs avec Arduino, le premier programme est presque toujours le même : faire clignoter une LED. Dans cet article, on le fait du début à la fin. On branche une LED sur la broche 9 avec une résistance de 220 Ω, on lit un par un les blocs du projet Clignotement d'une LED de BlueGrays et on voit côte à côte en quelle ligne du code C++ téléversé dans la carte chaque bloc se transforme. Tu vas aussi essayer de changer un seul nombre, le 100 du bloc « attendre 100 ms », pour régler la vitesse du clignotement.

On ne s'arrête pas à une seule LED. On va faire grandir la même logique pas à pas jusqu'à des programmes qui allument deux LED à tour de rôle, se comportent comme un feu tricolore et clignotent comme un gyrophare de police. Ensuite, tu verras la même idée sur l'ESP32 et sur le Raspberry Pi Pico en MicroPython. À la fin, un tableau récapitule les erreurs que presque tous les débutants font une fois. Tous les projets de cet article sont gratuits dans BlueGrays, blocs et code compris, et tu peux voir tous les projets en blocs classés par plateforme sur la page programmation par blocs.

De quoi as-tu besoin ?

Le circuit : brancher la LED sur la broche 9

Une LED a deux pattes et son sens compte. La patte longue est l'anode (+), la courte la cathode (-) ; côté cathode, le boîtier en plastique présente un méplat. Le courant ne circule que de l'anode vers la cathode : si tu la branches à l'envers, il ne se passe rien. Relie la broche 9 de l'Arduino à une extrémité de la résistance de 220 Ω, et l'autre extrémité à la patte longue de la LED. La patte courte va au GND. La résistance limite le courant : des 5 V on retire les quelque 2 V de la LED rouge, il reste 3 V aux bornes de la résistance, et 3 V / 220 Ω font environ 14 mA. C'est confortable pour la LED et sans danger pour la broche de l'Arduino. Tu peux vérifier la valeur pour la couleur de ta LED avec le calculateur de résistance pour LED. Le fonctionnement d'une LED est expliqué dans qu'est-ce qu'une LED, et la façon dont les rangées d'une plaque d'essai sont reliées à l'intérieur dans qu'est-ce qu'une breadboard.

Ton premier programme en blocs : Clignotement d'une LED

Une fois le circuit prêt, passons au programme. Ouvre le projet Clignotement d'une LED dans BlueGrays et active Voir en blocs dans la partie code : tu verras les blocs ci-dessous. Il y a sept blocs au total, répartis en deux grands groupes : en haut configuration (une fois), en dessous répéter indéfiniment. Les blocs s'affichent dans la langue de l'application : en français on lit « écrire HAUT sur la broche », en anglais « write HIGH to pin ».

Les blocs du groupe configuration (une fois) ne s'exécutent qu'une fois, à la mise sous tension de la carte ou quand tu appuies sur reset. Il n'y a ici qu'un bloc : « régler la broche 9 en SORTIE ». Les broches numériques de l'Arduino peuvent être des entrées ou des sorties. Comme on pilote une LED, on dit à la carte « je vais envoyer du courant par cette broche ». Le groupe répéter indéfiniment démarre quand la configuration est terminée et s'exécute de haut en bas encore et encore tant que la carte est alimentée. Ses quatre blocs allument la LED, attendent 100 millisecondes, l'éteignent et attendent encore 100 millisecondes. Après le dernier bloc, le programme remonte au début et la LED se rallume. Ce qu'on appelle clignoter, c'est simplement ces quatre étapes répétées cinq fois par seconde.

Bloc → ligne C++ : que devient chaque bloc ?

1// Led Yakma (proje 1): D9'daki LED 100 ms yanar, 100 ms söner
2// LED Blink (project 1): the LED on D9 is on for 100 ms, off for 100 ms
3void setup() {
4  pinMode(9,OUTPUT);     // LED pini çıkış / LED pin as output
5}
6
7void loop() {
8  digitalWrite(9,HIGH);  // LED'i yak / turn the LED on
9  delay(100);            // 100 ms bekle (1000 ms = 1 s) / wait 100 ms (1000 ms = 1 s)
10  digitalWrite(9,LOW);   // LED'i söndür / turn the LED off
11  delay(100);            // 100 ms bekle / wait 100 ms
12}
13

En mettant le tableau à côté du code, tu vois tout ce que les blocs gèrent pour toi. La forme des groupes configuration et répéter indéfiniment correspond aux accolades des fonctions void setup() et void loop() : le groupe dans lequel se trouve un bloc décide entre quelles accolades sa ligne est écrite. Avec les blocs, tu n'as pas à penser au point-virgule à la fin de chaque instruction, aux majuscules et minuscules (pinMode, digitalWrite) ni aux parenthèses. Mais dès que tu modifies toi-même le code dans l'Arduino IDE, ils comptent ; un seul point-virgule oublié suffit à provoquer une erreur de compilation. C'est là tout l'intérêt des blocs : d'abord tu poses la logique du programme, ensuite tu apprends comment cette même logique s'écrit en code.

Que se passe-t-il si tu changes « attendre 100 ms » ?

Le temps d'attente est en millisecondes (ms), et 1000 ms font une seconde. Les deux blocs d'attente du projet sont à 100 ms, donc la LED reste allumée 0,1 seconde et éteinte 0,1 seconde. Un cycle complet dure 200 ms : la LED clignote cinq fois par seconde. Augmente le nombre dans les deux blocs et la LED ralentit ; diminue-le et elle accélère. En dessous d'un certain seuil, l'œil ne distingue plus les clignotements et la LED semble allumée en permanence. Le tableau montre ce que tu verras en changeant les deux attentes :

Faire grandir le programme : deux LED, feu tricolore, gyrophare

Si tu sais faire clignoter une LED, tu n'as besoin de rien de nouveau pour en piloter plusieurs : tu répètes les trois mêmes blocs avec d'autres broches. Dans le projet Deux LED clignotant en alternance, deux broches passent en sortie dans la configuration : 8 et 9. Dans répéter indéfiniment viennent « écrire HAUT sur la broche 8 » et « écrire BAS sur la broche 9 », puis « attendre 200 ms ». Ensuite on écrit l'inverse et on attend encore 200 ms. L'astuce : les deux blocs d'écriture s'enchaînent sans attente entre eux, donc les deux LED semblent s'échanger au même instant. Le bloc d'attente décide combien de temps dure chaque état.

Le projet Feu de circulation applique la même idée à trois LED : rouge sur D2, orange sur D3, vert sur D4. Le groupe répéter indéfiniment compte quatre phases qui suivent toutes le même schéma : un bloc écrire HAUT ou BAS pour chacune des trois LED, puis un bloc d'attente. Les blocs d'écriture décident quelle LED reste allumée, le bloc d'attente pendant combien de temps. Plus de blocs ne rend pas le programme plus difficile, seulement plus long. Une version avec bouton piéton, plus proche d'un vrai carrefour, se trouve dans l'article feu tricolore Arduino.

1// Trafik Lambası (proje 3) / Traffic Light (project 3)
2void setup() {
3  pinMode(2,OUTPUT);    // Kırmızı / Red
4  pinMode(3,OUTPUT);    // Sarı / Yellow
5  pinMode(4,OUTPUT);    // Yeşil / Green
6}
7
8void loop() {
9  // Kırmızı yanar, 2 s bekle / Red on, wait 2 s
10  digitalWrite(2,HIGH);
11  digitalWrite(3,LOW);
12  digitalWrite(4,LOW);
13  delay(2000);
14  // Sarı yanar, 0,3 s bekle / Yellow on, wait 0.3 s
15  digitalWrite(2,LOW);
16  digitalWrite(3,HIGH);
17  digitalWrite(4,LOW);
18  delay(300);
19  // Yeşil yanar, 2 s bekle / Green on, wait 2 s
20  digitalWrite(2,LOW);
21  digitalWrite(3,LOW);
22  digitalWrite(4,HIGH);
23  delay(2000);
24  // Sarı yanar, sonra başa (kırmızıya) dön / Yellow on, then back to red
25  digitalWrite(2,LOW);
26  digitalWrite(3,HIGH);
27  digitalWrite(4,LOW);
28  delay(300);
29}
30

Dans le projet Gyrophare de police à LED, deux nouveaux types de blocs apparaissent. Le premier est le groupe variables globales (en haut) avec le bloc « déclarer entier (int) delayTime = 60 ». C'est la ligne int delayTime = 60; du code, qui donne un nom au temps de flash. Comme les blocs d'attente utilisent delayTime au lieu d'un nombre, pour changer la vitesse tu modifies seulement le 60, et non quatre blocs séparés. Le second est le bloc vert « répéter 3 fois » : il exécute trois fois les quatre blocs qu'il contient et devient en C++ la boucle for(int i=0;i<3;i++).

Faisons le calcul : à chaque flash, la LED rouge est allumée 60 ms et éteinte 60 ms, donc un flash dure 120 ms. Trois flashs font 360 ms, et pareil pour la LED bleue. Un cycle complet dure environ 0,7 seconde. Avec delayTime à 30, ça flashe deux fois plus vite ; à 120, plus lentement. Variables et boucles sont le sujet de la partie 4 de la série ; on les détaille dans « répéter indéfiniment », blocs de comptage et tableaux. Le projet Chenillard à LED, qui fait courir la lumière le long d'une rangée de LED, est l'étape suivante sur ce chemin.

La même idée sur ESP32 et Raspberry Pi Pico

Sur l'ESP32, les blocs sont presque identiques à ceux de l'Arduino, car l'ESP32 se programme lui aussi en C++ avec l'Arduino IDE. Dans le projet Clignotement LED avec ESP32, la LED est sur le GPIO 5 et les blocs d'attente sont à 500 ms. Les lignes de code sont les mêmes : pinMode(5, OUTPUT); digitalWrite(5, HIGH); delay(500);. Les seules différences sont le numéro de broche, les 3,3 V que délivrent les broches de l'ESP32 et le choix d'une carte ESP32 dans l'Arduino IDE. Tout ce que tu apprends sur l'Uno se transpose directement à l'ESP32.

Dans les projets Raspberry Pi Pico, les blocs se traduisent en code MicroPython et leurs noms changent un peu. Dans le projet LED externe sur le Pico, la LED est sur GP14. Le bloc « broche led : GP LED_PIN, SORTIE » correspond à led = Pin(LED_PIN, Pin.OUT), « allumer (on) la broche led » à led.on(), « attendre 0.5 secondes » à time.sleep(0.5), et répéter indéfiniment à la boucle while True:. Attention : en MicroPython, l'attente est en secondes et non en millisecondes ; le delay(500) de l'Arduino devient ici time.sleep(0.5). Pour essayer sans aucun câble, le projet LED intégrée du Pico fait clignoter la LED sur GP25, directement sur la carte ; sur un Pico W, on accède à la LED intégrée avec le nom « LED » au lieu de GP25.

1# Pico harici LED (proje 8163), seri port satırları çıkarıldı
2# Pico external LED (project 8163), serial print lines removed
3from machine import Pin
4import time
5
6LED_PIN = 14                    # GP14, herhangi bir boş GPIO / any free GPIO
7led = Pin(LED_PIN, Pin.OUT)     # pini çıkış yap / set the pin as output
8
9while True:                     # sürekli tekrarla / loop forever
10    led.on()                    # LED'i yak / turn the LED on
11    time.sleep(0.5)             # 0,5 saniye bekle / wait 0.5 s
12    led.off()                   # LED'i söndür / turn the LED off
13    time.sleep(0.5)
14

Erreurs fréquentes et solutions

Pas à pas dans l'application : des blocs à la carte

1. Dans BlueGrays, ouvre le projet Clignotement d'une LED, qui porte le badge blocs dans la liste des projets. Le filtre permet aussi d'afficher uniquement les projets avec blocs.
2. En suivant le schéma, place la LED, la résistance de 220 Ω et deux câbles sur la plaque d'essai.
3. Dans la partie code, active Voir en blocs. Les blocs remplacent le code ; touche l'image pour l'ouvrir en plein écran.
4. Passe à l'onglet Comprendre les blocs. Le programme y est expliqué pas à pas : chaque étape n'affiche que ses blocs et ce qu'ils font.
5. Désactive l'interrupteur pour revenir au vrai code, copie-le et colle-le dans l'Arduino IDE. Les blocs ne sont pas téléversés directement dans la carte ; c'est toujours ce code qui y va.
6. Dans l'Arduino IDE, choisis Arduino Uno comme carte et le bon port, puis clique sur Téléverser. Si l'IDE n'est pas encore installé, l'article installer l'Arduino IDE te guide pas à pas.
7. Une fois que la LED clignote, remplace les deux lignes delay(100) par delay(1000), téléverse à nouveau et constate la différence par toi-même.

Dans cet article, la LED a toujours clignoté au même rythme ; le programme n'écoutait rien du monde extérieur. L'étape suivante, c'est de laisser la carte prendre des décisions : la partie 3 de la série, le bouton et le bloc « si », présente un programme qui allume la LED quand on appuie sur un bouton, et montre comment ce bloc devient un if/else en C++.

Dans l'application BlueGrays, tu peux consulter Clignotement d'une LED, Deux LED clignotant en alternance, Feu de circulation, Gyrophare de police à LED et les projets LED pour ESP32 et Pico avec leur schéma et leur code, passer à la version en blocs du même programme avec Voir en blocs et lire ce que fait chaque étape avec Comprendre les blocs.