Bases · 12 min de lecture

Comprendre un code Arduino : lire un programme ligne par ligne

Comprendre un code Arduino : bibliothèques, broches, setup et loop, fonctions et conditions if, un exemple expliqué ligne par ligne, puis l'ESP32 et le Pico.

Comprendre un code Arduino, c'est ce qui fait la différence entre copier un programme en espérant qu'il marche et en faire vraiment ton propre projet. Presque tous les programmes que tu trouves sur Internet, dans les livres ou dans les exemples d'un copain suivent le même squelette : en haut les bibliothèques et les broches, au milieu un setup() qui s'exécute une seule fois, en bas un loop() qui tourne à l'infini et, si besoin, quelques fonctions maison. Une fois ce squelette repéré, tu peux dire même devant un code inconnu : « cette ligne lit telle broche, et dans tel cas elle fait tourner tel moteur ».

Dans cet article, tu vas découvrir une méthode pas à pas pour lire un programme Arduino. On commence par les différentes parties d'un code et leur rôle, puis on décortique ligne par ligne le code d'une petite poubelle dont le couvercle s'ouvre quand on approche la main. Ensuite, on verra comment lire les variables, les conditions et les fonctions, comment adapter le code de quelqu'un d'autre à ton montage et comment le porter sur un ESP32 et un Raspberry Pi Pico. Pour finir, tu verras comment t'entraîner avec l'onglet « Comprendre le code » de BlueGrays.

Carte Arduino Uno et ses broches
Chaque numéro de broche du code correspond à un repère sur la carte : la ligne const int TRIG_PIN = 9 indique que le fil est branché dans le trou marqué D9.

L'anatomie d'un programme Arduino

Un programme Arduino (on dit aussi « sketch ») suit toujours le même ordre de haut en bas. Le compilateur lit le fichier du début à la fin, mais l'ordre d'exécution sur la carte est différent : les déclarations globales sont préparées d'abord, puis setup() s'exécute une fois, et enfin loop() se répète tant que la carte est alimentée. Le tableau résume les parties que tu verras en ouvrant un code et comment les reconnaître :

Partie du codeRôleLigne typiqueComment la reconnaître ?
CommentairesExpliquent le code, ignorés par le compilateur// explication ou /* ... */Commencent par //, en gris dans l'IDE
BibliothèquesAjoutent du code tout prêt (servo, écran, capteur)#include <Servo.h>Commencent par #, tout en haut
Broches et constantesDonnent un nom aux numéros de broche et aux seuilsconst int LED_PIN = 13;Noms souvent en MAJUSCULES
Variables globales et objetsDonnées accessibles partout dans le codeint count = 0; Servo lidServo;En dehors de toute fonction
setup()S'exécute une fois au démarragepinMode(LED_PIN, OUTPUT);void setup() { ... }
loop()Se répète sans fin, c'est là que tout se passeif (distance < 20) { ... }void loop() { ... }
Fonctions maisonRegroupent une tâche répétéelong readDistanceCm() { ... }Blocs à part, au-dessus ou en dessous de loop

Par où commencer ? Une méthode en cinq étapes

  1. Lis les commentaires et les bibliothèques. Les lignes #include trahissent le matériel utilisé : Servo.h signifie un servomoteur, LiquidCrystal_I2C.h un écran LCD I2C, DHT.h un capteur de température.
  2. Note les broches sur papier. Transforme chaque ligne const int ou #define en liste de câblage du type « TRIG = D9, ECHO = D10 » et compare-la à ton montage.
  3. Lis setup(). Tu y vois quelles broches sont des entrées ou des sorties, la vitesse du port série et l'état de départ de la carte (servo fermé, LED éteinte, etc.).
  4. Exécute loop() une fois à la main. Choisis une valeur de capteur (par exemple 45 cm) et suis le code ligne par ligne avec cette valeur ; note dans quel bloc if tu entres et quelle variable change.
  5. Plonge dans les fonctions quand il le faut. Quand tu vois un appel comme readDistanceCm() dans loop(), devine d'abord ce qu'il fait d'après son nom, puis ouvre la fonction pour vérifier.

Exemple de programme Arduino expliqué ligne par ligne

Pour l'exercice, on a choisi le code d'un vrai projet : un capteur à ultrasons HC-SR04 détecte une main qui approche, le servomoteur ouvre le couvercle, le referme trois secondes plus tard, une LED s'allume pendant ce temps et le nombre d'ouvertures s'affiche dans le moniteur série. On y trouve tout : bibliothèque, constantes, variable globale, objet, setup, loop, condition et fonction maison. Jette d'abord un œil à l'ensemble, puis on le reprend ligne par ligne avec le tableau.

C++ (Arduino IDE)
1// Akıllı çöp kutusu: el yaklaşınca kapak açılır / Smart bin: the lid opens when a hand comes close
2#include <Servo.h>                  // servo kütüphanesi / servo library
3
4const int TRIG_PIN = 9;             // HC-SR04 TRIG
5const int ECHO_PIN = 10;            // HC-SR04 ECHO
6const int SERVO_PIN = 6;            // servo sinyal kablosu / servo signal wire
7const int LED_PIN = 13;             // durum LED'i / status LED
8const int OPEN_DISTANCE = 20;       // bundan yakınsa aç (cm) / open if closer than this (cm)
9const int OPEN_ANGLE = 90;          // açık kapak açısı / open lid angle
10const int CLOSED_ANGLE = 0;         // kapalı kapak açısı / closed lid angle
11
12Servo lidServo;                     // servo nesnesi / servo object
13int openCount = 0;                  // kaç kez açıldı / how many times it opened
14
15void setup() {
16  Serial.begin(9600);
17  pinMode(TRIG_PIN, OUTPUT);
18  pinMode(ECHO_PIN, INPUT);
19  pinMode(LED_PIN, OUTPUT);
20  lidServo.attach(SERVO_PIN);
21  lidServo.write(CLOSED_ANGLE);     // açılışta kapalı / closed at power-up
22}
23
24void loop() {
25  long distance = readDistanceCm(); // mesafeyi ölç / measure the distance
26  Serial.print("Mesafe / Distance: ");
27  Serial.println(distance);
28
29  if (distance > 0 && distance < OPEN_DISTANCE) {
30    openCount++;                    // sayacı bir artır / add one to the counter
31    digitalWrite(LED_PIN, HIGH);
32    lidServo.write(OPEN_ANGLE);     // kapağı aç / open the lid
33    delay(3000);                    // 3 sn açık kal / stay open for 3 s
34    lidServo.write(CLOSED_ANGLE);   // kapağı kapat / close the lid
35    digitalWrite(LED_PIN, LOW);
36    Serial.print("Acilma sayisi / Times opened: ");
37    Serial.println(openCount);
38  }
39  delay(100);                       // saniyede yaklaşık 10 ölçüm / about 10 readings per second
40}
41
42// Mesafeyi santimetre olarak döndürür / returns the distance in centimetres
43long readDistanceCm() {
44  digitalWrite(TRIG_PIN, LOW);
45  delayMicroseconds(2);
46  digitalWrite(TRIG_PIN, HIGH);     // 10 µs tetik darbesi / 10 µs trigger pulse
47  delayMicroseconds(10);
48  digitalWrite(TRIG_PIN, LOW);
49  long duration = pulseIn(ECHO_PIN, HIGH, 30000);  // en fazla 30 ms bekle / wait at most 30 ms
50  return duration / 58;             // µs'yi cm'ye çevir / convert µs to cm
51}
LigneCe qu'elle faitEt si tu la modifies ?
#include <Servo.h>Ajoute la bibliothèque Servo au programmeSans elle, le compilateur affiche « 'Servo' does not name a type »
const int TRIG_PIN = 9;Donne le nom TRIG_PIN à la broche 9Si tu déplaces le fil, tu changes uniquement ce nombre
const int OPEN_DISTANCE = 20;Distance seuil d'ouverture du couvercleAvec 30, le couvercle s'ouvre de plus loin
Servo lidServo;Crée un objet servo nommé lidServoToutes les lignes suivantes doivent utiliser le même nom
int openCount = 0;Compteur global, à zéro au démarrageDéplacé dans loop(), il repart à zéro à chaque tour et affiche toujours 1
lidServo.attach(SERVO_PIN);Relie le servo à la broche 6Sans cette ligne, le servo ne bouge pas
long distance = readDistanceCm();Appelle la fonction et garde le résultatdistance n'existe qu'à l'intérieur de loop()
if (distance > 0 && distance < OPEN_DISTANCE)Entre dans le bloc si les deux conditions sont vraiesdistance > 0 écarte le 0 renvoyé quand l'écho ne revient pas
delay(3000);Fait attendre la carte 3 secondesPendant ce temps, l'Arduino ne surveille rien d'autre
return duration / 58;Convertit la durée de l'écho en centimètresLe son fait l'aller-retour : environ 58 µs par centimètre

Exécutons maintenant loop() à la main avec deux situations. Personne devant le capteur : il mesure 45 cm, distance vaut 45, le moniteur série affiche « Mesafe / Distance: 45 », la condition 45 < 20 est fausse donc le bloc est sauté, la carte attend 100 ms et loop() recommence. Cela se répète environ dix fois par seconde. Tu approches la main à 12 cm : les deux conditions sont vraies, openCount passe de 0 à 1, la LED s'allume, le servo tourne à 90 degrés, la carte attend trois secondes, le couvercle se referme, la LED s'éteint et le moniteur affiche « Acilma sayisi / Times opened: 1 ». Suivre un code avec de vrais nombres, c'est la façon la plus sûre de le comprendre.

Regarde aussi ce détail : si pulseIn() ne reçoit pas d'écho en 30 ms, il renvoie 0. Sans le test distance > 0, ce 0 mesuré face au vide serait « plus petit que 20 » et le couvercle s'ouvrirait sans raison. Les codes bien écrits sont pleins de petites vérifications comme celle-ci ; si tu ne comprends pas pourquoi une ligne est là, supprime-la temporairement et observe ce qui se passe. Le principe du capteur est expliqué dans notre article sur le capteur à ultrasons HC-SR04, et la version complète du projet avec deux capteurs dans celui sur la poubelle intelligente.

Variables et types : les étiquettes des boîtes

Une variable est une boîte étiquetée dans laquelle tu ranges un nombre ou un texte. Le mot en début de ligne donne le type de la boîte, c'est-à-dire ce qu'elle peut contenir. Sur l'Arduino Uno, un mauvais type provoque des erreurs silencieuses : si tu ranges millis() dans un int, par exemple, le nombre devient négatif au bout d'environ 32 secondes.

TypePlage (Arduino Uno)Usage typique
intde -32 768 à 32 767Numéros de broche, valeurs d'analogRead, compteurs
longenviron ±2,1 milliardsDurée de pulseIn, grands nombres
unsigned longde 0 à environ 4,29 milliardsTemps de millis() et micros()
floatNombres à virgule, 6 à 7 chiffres de précisionCalculs de température, de tension, de distance
booltrue ou falseQuelque chose est-il allumé ou éteint ?
bytede 0 à 255Valeurs PWM, petits nombres
char / StringUn caractère / du texteCommandes reçues sur le port série, textes d'écran

L'endroit où une variable est déclarée compte aussi : c'est sa portée. Dans l'exemple, openCount est déclarée en dehors de toute fonction, elle est donc globale : sa valeur est conservée à chaque tour de loop(). distance, elle, est déclarée dans loop() : elle est locale, elle naît à chaque tour et disparaît à la fin du tour. Une variable précédée de const est une constante que le programme ne peut pas modifier en cours de route. Pour aller plus loin, lis notre article sur les bases de la programmation Arduino et, pour ranger plusieurs valeurs dans une seule variable, celui sur les tableaux (array) Arduino.

Comment lire les conditions, les boucles et les fonctions

  • if / else if / else : lis « si ... alors fais ceci, sinon fais cela ». Les accolades { } montrent quelles lignes dépendent de la condition.
  • Comparaisons : == signifie « égal à », != « différent de », < « plus petit que », >= « plus grand ou égal ». && veut dire « et », || « ou », ! « non ».
  • Boucle for : lis for (int i = 0; i < 5; i++) comme « i part de 0, on répète tant que i est plus petit que 5, et on ajoute 1 à chaque tour » ; le bloc s'exécute 5 fois.
  • Boucle while : while (digitalRead(BUTTON_PIN) == HIGH) se lit « attends tant que le bouton n'est pas appuyé » ; si la condition ne change jamais, le code reste bloqué là.
  • switch / case : le programme prend un chemin différent selon la valeur d'une variable ; si tu oublies le break à la fin d'un case, le case suivant s'exécute aussi.
  • Définition de fonction : dans long readDistanceCm(), long est le type de la valeur renvoyée, readDistanceCm le nom et les parenthèses vides indiquent qu'il n'y a pas de paramètre. Une fonction qui commence par void ne renvoie rien, elle agit seulement.
Deux pièges passent souvent inaperçus à la lecture. if (x = 5) n'est pas une comparaison mais une affectation de 5 à x, et la condition est toujours vraie ; il faut écrire if (x == 5). Ensuite, le point-virgule à la fin de if (distance < 20); annule la condition, et le bloc en dessous s'exécute à chaque tour. Le compilateur ne signale aucune erreur dans les deux cas, alors sois particulièrement attentif à ces lignes.

Reconnaître les fonctions des bibliothèques

Dans une ligne comme lidServo.write(90), le point indique que la fonction write appartient à l'objet lidServo : « lidServo, va à 90 degrés ». Il y a trois façons simples de savoir ce que fait une fonction de bibliothèque : dans l'Arduino IDE 2, survoler la fonction pour lire sa description ou faire un clic droit puis Go to Definition ; ouvrir les exemples de la bibliothèque via Fichier > Exemples ; parcourir la liste des fonctions dans le fichier .h de la bibliothèque. On explique comment installer une bibliothèque dans l'article ajouter une bibliothèque Arduino. Voici les fonctions de base que tu croiseras dans presque tous les programmes :

FonctionCe qu'elle faitExemple
pinMode(broche, mode)Configure une broche en entrée ou en sortiepinMode(13, OUTPUT);
digitalWrite(broche, valeur)Met une sortie à 5 V (HIGH) ou à 0 V (LOW)digitalWrite(13, HIGH);
digitalRead(broche)Lit si une entrée est à HIGH ou à LOWdigitalRead(2)
analogRead(broche)Convertit 0–5 V en un nombre entre 0 et 1023analogRead(A0)
analogWrite(broche, 0–255)Règle la luminosité d'une LED ou la vitesse d'un moteur en PWManalogWrite(9, 128);
delay(ms)Met la carte en pause pendant la durée donnéedelay(1000);
millis()Millisecondes écoulées depuis le démarrageif (millis() - last > 500)
Serial.begin / print / printlnEnvoie du texte au moniteur sérieSerial.println(distance);
map(x, a, b, c, d)Transpose une plage de valeurs dans une autremap(value, 0, 1023, 0, 180)
pulseIn(broche, HIGH)Mesure la durée d'une impulsion en µspulseIn(10, HIGH, 30000)

Pour la liste complète avec des exemples détaillés, consulte notre article sur les commandes Arduino. Bien saisir la différence entre delay() et millis() est l'une des clés pour lire les programmes ; l'article millis et delay l'explique avec des exemples.

Adapter le code de quelqu'un d'autre à ton montage

  1. Tire un tableau de câblage du code. Écris toutes les constantes de broches les unes sous les autres : c'est le montage de la personne qui a écrit le code.
  2. Compare avec ton montage. Si tu as utilisé d'autres broches, ne touche pas aux fils : change seulement les nombres des lignes const et laisse le reste du code tel quel.
  3. Vérifie les différences de bibliothèques. Deux bibliothèques portant le même nom peuvent utiliser des fonctions différentes ; sur les écrans LCD I2C, l'adresse 0x27 ou 0x3F est aussi la source d'incompatibilité la plus fréquente.
  4. Attention à l'actif LOW et à l'actif HIGH. La plupart des modules relais s'activent sur LOW ; si le code allume avec HIGH, ton relais fera exactement l'inverse.
  5. Aligne la vitesse du port série. Si le code contient Serial.begin(115200), choisis aussi 115200 dans le moniteur série, sinon tu verras des caractères incompréhensibles.
  6. Teste morceau par morceau. Fais d'abord tourner uniquement la partie qui lit le capteur, puis ajoute le moteur et l'écran une fois les valeurs correctes.
Le moniteur série, c'est la lampe torche que tu glisses dans ton code. Si tu ne comprends pas pourquoi une condition ne se déclenche pas, ajoute juste avant le if une ligne comme Serial.println(distance) et regarde avec quelle valeur la comparaison se fait vraiment. Tous les détails sont dans l'article sur le moniteur série Arduino.

Porter le même code sur un ESP32

L'ESP32 se programme lui aussi avec l'Arduino IDE, donc l'essentiel du code fonctionne tel quel ; ce qui change, ce sont les numéros de broches, le niveau de tension et quelques bibliothèques. Le tableau liste ce qu'il faut vérifier quand tu passes un code d'Arduino Uno à l'ESP32 :

PointArduino UnoESP32Que faire ?
Noms des brochesD2–D13, A0–A5Numéros GPIORemplace les constantes par des numéros GPIO, attention à 6–11 et 34–39
Tension de fonctionnement5 V3,3 VMets un pont diviseur sur les capteurs qui sortent du 5 V (ECHO du HC-SR04)
analogRead10 bits, 0–102312 bits, 0–4095Recalcule les seuils et les plages de map() en les multipliant par 4
Bibliothèque servoServo.hESP32Servo.hChange de bibliothèque et indique la plage d'impulsion dans attach
Vitesse sériesouvent 9600souvent 115200Accorde Serial.begin et le moniteur série
Mémoire2 Ko de RAMenviron 320 Ko de RAMLes grands tableaux et les String ne posent plus de problème
C++ (Arduino IDE)
1// ESP32 sürümü: değişen satırlar işaretli / ESP32 version: changed lines are marked
2#include <ESP32Servo.h>             // DEĞİŞTİ: Servo.h yerine / CHANGED: instead of Servo.h
3
4const int TRIG_PIN = 26;            // DEĞİŞTİ / CHANGED
5const int ECHO_PIN = 27;            // DEĞİŞTİ: 1k/2k bölücüyle / CHANGED: through a 1k/2k divider
6const int SERVO_PIN = 18;           // DEĞİŞTİ / CHANGED
7const int LED_PIN = 2;              // DEĞİŞTİ: çoğu DevKit'te dahili LED / CHANGED: onboard LED on most DevKits
8const int OPEN_DISTANCE = 20;
9const int OPEN_ANGLE = 90;
10const int CLOSED_ANGLE = 0;
11
12Servo lidServo;
13int openCount = 0;
14
15void setup() {
16  Serial.begin(115200);             // DEĞİŞTİ: ESP32'de yaygın hız / CHANGED: common ESP32 speed
17  pinMode(TRIG_PIN, OUTPUT);
18  pinMode(ECHO_PIN, INPUT);
19  pinMode(LED_PIN, OUTPUT);
20  lidServo.setPeriodHertz(50);      // EKLENDİ: standart servo 50 Hz / ADDED: standard servo 50 Hz
21  lidServo.attach(SERVO_PIN, 500, 2400);  // DEĞİŞTİ: darbe aralığı µs / CHANGED: pulse range in µs
22  lidServo.write(CLOSED_ANGLE);
23}
24
25void loop() {
26  long distance = readDistanceCm();
27  Serial.print("Mesafe / Distance: ");
28  Serial.println(distance);
29
30  if (distance > 0 && distance < OPEN_DISTANCE) {
31    openCount++;
32    digitalWrite(LED_PIN, HIGH);
33    lidServo.write(OPEN_ANGLE);
34    delay(3000);
35    lidServo.write(CLOSED_ANGLE);
36    digitalWrite(LED_PIN, LOW);
37    Serial.print("Acilma sayisi / Times opened: ");
38    Serial.println(openCount);
39  }
40  delay(100);
41}
42
43long readDistanceCm() {
44  digitalWrite(TRIG_PIN, LOW);
45  delayMicroseconds(2);
46  digitalWrite(TRIG_PIN, HIGH);
47  delayMicroseconds(10);
48  digitalWrite(TRIG_PIN, LOW);
49  long duration = pulseIn(ECHO_PIN, HIGH, 30000);
50  return duration / 58;
51}

Comme tu le vois, loop() et la fonction readDistanceCm() sont passés sans changer une lettre ; tout ce qui change se trouve en haut du fichier et dans setup(). C'est le signe d'un code bien écrit : les détails liés au matériel sont regroupés en haut, la logique reste propre en dessous. Comme la broche ECHO du HC-SR04 sort du 5 V, il faut la relier à l'ESP32 à travers un pont diviseur de tension de 1 kΩ et 2 kΩ ; le servo, lui, s'alimente sur le 5 V de la broche VIN, pas sur le 3,3 V. Les autres différences entre les cartes sont comparées dans l'article Arduino ou ESP32.

La même logique sur Raspberry Pi Pico : MicroPython

Quand tu programmes le Pico en MicroPython, le code a une autre allure, mais la logique est la même. On écrit import au lieu de #include, et l'indentation remplace les accolades. Les mots setup() et loop() n'existent pas : les lignes du haut du fichier s'exécutent une fois (l'équivalent de setup) et le bloc while True: tourne sans fin (l'équivalent de loop). Les fonctions commencent par def au lieu de void ou long. Mets ce code à côté du code Arduino ci-dessus et tu retrouveras l'équivalent de chaque ligne :

MicroPython
1from machine import Pin, PWM, time_pulse_us   # #include karşılığı / the #include part
2import time
3
4TRIG = Pin(14, Pin.OUT)              # HC-SR04 TRIG
5ECHO = Pin(15, Pin.IN)               # HC-SR04 ECHO, bölücüyle / through a divider
6LED = Pin(25, Pin.OUT)               # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
7servo = PWM(Pin(16))
8servo.freq(50)                       # servo 50 Hz ister / servos need 50 Hz
9
10OPEN_DISTANCE = 20                   # cm
11
12
13def set_angle(angle):
14    pulse_us = 500 + angle * 2000 // 180            # 0 derece 0,5 ms, 180 derece 2,5 ms / 0 deg 0.5 ms, 180 deg 2.5 ms
15    servo.duty_u16(pulse_us * 65535 // 20000)       # 20 ms periyodun oranı / share of the 20 ms period
16
17
18def read_distance_cm():
19    TRIG.low()
20    time.sleep_us(2)
21    TRIG.high()                      # 10 µs tetik darbesi / 10 µs trigger pulse
22    time.sleep_us(10)
23    TRIG.low()
24    duration = time_pulse_us(ECHO, 1, 30000)        # zaman aşımında negatif / negative on timeout
25    if duration < 0:
26        return 0
27    return duration // 58
28
29
30set_angle(0)                         # setup() karşılığı / the setup() part
31open_count = 0
32
33while True:                          # loop() karşılığı / the loop() part
34    distance = read_distance_cm()
35    print("Mesafe / Distance:", distance)
36    if 0 < distance < OPEN_DISTANCE:
37        open_count += 1
38        LED.on()
39        set_angle(90)
40        time.sleep(3)
41        set_angle(0)
42        LED.off()
43        print("Acilma sayisi / Times opened:", open_count)
44    time.sleep_ms(100)

Comme il n'y a pas de bibliothèque Servo en Python, la fonction set_angle() convertit elle-même l'angle en durée d'impulsion : le servo se positionne selon une impulsion de 0,5 à 2,5 ms qui arrive toutes les 20 ms. L'écriture 0 < distance < OPEN_DISTANCE est la forme courte, en Python, de la condition C++ distance > 0 && distance < OPEN_DISTANCE. Si tu débutes en MicroPython, l'article sur les bases de MicroPython explique les règles d'indentation, de variables et de fonctions.

S'entraîner avec « Comprendre le code » dans BlueGrays

Dans l'application BlueGrays, l'écran du code de chaque projet comporte aussi un onglet « Comprendre le code ». La rubrique « Que fait ce code ? » résume d'abord en quelques phrases le rôle du programme. « Étape par étape » découpe ensuite le code en petits morceaux et explique sous chacun à quoi servent ces lignes et ce qui se passe si tu les modifies. « Si tu bloques » liste les problèmes les plus courants sous forme de symptôme et de solution, et « À toi de jouer » propose un petit défi avec un indice et sa solution, par exemple changer le seuil d'une veilleuse pour que la LED s'allume plus tôt. Tu peux y appliquer la méthode en cinq étapes de cet article : lis le résumé, associe chaque morceau à ton montage, puis relève le défi en modifiant le code toi-même.

Exercices pour apprendre à lire du code

  • Prédis, puis vérifie : avant de changer une constante, écris ce qui va se passer, puis téléverse le code et compare avec ta prédiction.
  • Mets une ligne en commentaire : ajoute // devant une ligne et téléverse à nouveau ; ce qui ne marche plus révèle le rôle de cette ligne.
  • Raconte-le avec tes mots : traduis chaque ligne de loop() en une phrase en français ; une ligne que tu n'arrives pas à traduire est une ligne que tu n'as pas encore comprise.
  • Dessine un organigramme : représente setup, loop, les if et les appels de fonctions avec des cases et des flèches ; c'est très utile pour les codes qui utilisent une machine à états.
  • Fais une erreur exprès : supprime un point-virgule et lis le message du compilateur ; l'article sur les erreurs de compilation Arduino explique les messages les plus fréquents.

Erreurs fréquentes quand on lit un code

ErreurPourquoi c'est un problèmeLa bonne approche
Croire que le code est une liste exécutée une seule foisloop() se répète sans fin et les variables changent d'un tour à l'autreSuis loop() sur plusieurs tours, avec des valeurs différentes
Confondre = et ==if (x = 5) est toujours vraiUtilise toujours == pour comparer
Oublier la division entière5 / 2 donne 2, la partie décimale est perdueSi tu as besoin de décimales, écris 5.0 / 2 ou utilise un float
Oublier que delay() bloque toutPendant l'attente, boutons et capteurs ne sont pas lusPour plusieurs tâches, gère le temps avec millis()
Ignorer les différences de version d'une bibliothèqueUne même fonction peut changer de nom dans une nouvelle versionCherche dans les commentaires avec quelle bibliothèque le code a été écrit
Changer une constante de broche et oublier le filLe code lit la bonne broche, mais le fil est ailleursMets à jour ton tableau de câblage après chaque modification
Devant un code difficile, commence par le réécrire en langage courant : « Mesure la distance. Si elle est supérieure à 0 et inférieure à 20, augmente le compteur, allume la LED, ouvre le couvercle, attends 3 secondes, referme le couvercle, éteins la LED. Attends 100 ms et recommence. » C'est ce qu'on appelle du pseudo-code, et c'est le moyen le plus rapide de saisir la pensée de la personne qui a écrit le programme.

Lire du code, comme lire un schéma électronique, devient plus rapide à chaque exemple que tu vois. Pour te lancer, ouvre dans l'application BlueGrays de petits projets comme allumer une LED, le feu tricolore, la LED commandée par un bouton ou la veilleuse avec LDR, et suis l'onglet « Comprendre le code » ligne par ligne ; chaque projet t'attend avec son schéma, l'explication du code morceau par morceau et un petit défi.

Questions fréquentes

Quel langage utilise Arduino ?

Les programmes Arduino reposent sur le C et le C++. Arduino ajoute des fonctions toutes prêtes comme pinMode ou digitalWrite pour simplifier le travail, mais les règles des if, des boucles for, des variables et des fonctions sont directement celles du C++. Connaître un peu le C++ facilite donc beaucoup la lecture des codes Arduino.

Quelle est la différence entre setup et loop ?

setup() s'exécute une seule fois, quand la carte démarre ou après un reset ; on l'utilise pour les préparatifs comme la configuration des broches et du port série. loop() se répète ensuite sans arrêt tant que la carte est alimentée ; c'est là que se fait le vrai travail : lire les capteurs, décider et piloter les moteurs.

Que veut dire void dans un programme Arduino ?

void indique que la fonction ne renvoie aucune valeur. void setup() et void loop() font des actions mais ne rendent pas de résultat. Une fonction comme long readDistanceCm(), au contraire, renvoie avec return une valeur du type écrit devant son nom.

Mon programme compile mais le montage ne marche pas, pourquoi ?

Le compilateur vérifie seulement la syntaxe ; un mauvais numéro de broche, un module branché à l'envers ou un seuil mal choisi ne provoquent aucune erreur de compilation. Compare les constantes de broches du code avec ton montage et affiche les valeurs avec Serial.println dans le moniteur série ; le problème vient le plus souvent du câblage ou d'un seuil.

Peut-on utiliser un code Arduino sur un ESP32 ?

Le plus souvent oui, car l'ESP32 se programme aussi avec l'Arduino IDE et les fonctions de base sont les mêmes. Il faut remplacer les numéros de broches par des numéros GPIO, ramener les signaux 5 V à 3,3 V et remplacer certaines bibliothèques comme Servo par leur version ESP32. N'oublie pas non plus qu'analogRead renvoie des valeurs entre 0 et 4095.

Où trouver des exemples de programmes Arduino ?

Le menu Fichier > Exemples de l'Arduino IDE est un très bon point de départ, avec les exemples fournis par chaque bibliothèque installée. Les projets de l'application BlueGrays arrivent aussi avec leur schéma et un code expliqué ligne par ligne. Quelle que soit la source, lire le code une fois avec la méthode de cet article avant de le téléverser permet de repérer les erreurs dès le départ.

Voir tous les projets
Clignotement d'une LED
AR-1Débutant

Clignotement d'une LED

Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

4.6(200)
1246
Feu de circulation
AR-3Débutant

Feu de circulation

Une copie miniature du feu tricolore que tu vois chaque jour dans la rue. Le rouge reste allumé deux secondes, l'orange brille un court instant, le vert reste deux secondes, puis on revient au rouge…

4.8(137)
440
Allumer une LED avec un bouton-poussoir (Push)
AR-9Débutant

Allumer une LED avec un bouton-poussoir (Push)

Comme une sonnette : la lumière reste allumée tant que tu appuies et s'éteint quand tu relâches.

4.8(114)
253
Veilleuse avec LDR
AR-12Débutant

Veilleuse avec LDR

Une petite veilleuse qui s'allume toute seule quand il fait nuit et s'éteint au matin.

4.7(105)
224
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

HC-SR04 Mesure de la distance (affichage en série)

Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

4.6(50)
82
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
Capteur de stationnement avec HC-SR04
AR-28Intermédiaire
Premium

Capteur de stationnement avec HC-SR04

Une version miniature du radar de recul des voitures : plus un objet s'approche, plus les bips s'accélèrent.

4.8(64)
86
Utilisation d'un servomoteur avec un potentiomètre
AR-36Débutant
Premium

Utilisation d'un servomoteur avec un potentiomètre

Quand tu tournes le bouton du potentiomètre, le bras du servomoteur tourne avec lui : un bout du bouton correspond à zéro degré, l'autre à un demi-tour.

4.6(37)
53