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.

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 code | Rôle | Ligne typique | Comment la reconnaître ? |
|---|---|---|---|
| Commentaires | Expliquent le code, ignorés par le compilateur | // explication ou /* ... */ | Commencent par //, en gris dans l'IDE |
| Bibliothèques | Ajoutent du code tout prêt (servo, écran, capteur) | #include <Servo.h> | Commencent par #, tout en haut |
| Broches et constantes | Donnent un nom aux numéros de broche et aux seuils | const int LED_PIN = 13; | Noms souvent en MAJUSCULES |
| Variables globales et objets | Données accessibles partout dans le code | int count = 0; Servo lidServo; | En dehors de toute fonction |
| setup() | S'exécute une fois au démarrage | pinMode(LED_PIN, OUTPUT); | void setup() { ... } |
| loop() | Se répète sans fin, c'est là que tout se passe | if (distance < 20) { ... } | void loop() { ... } |
| Fonctions maison | Regroupent une tâche répétée | long readDistanceCm() { ... } | Blocs à part, au-dessus ou en dessous de loop |
Par où commencer ? Une méthode en cinq étapes
- 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.
- 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.
- 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.).
- 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.
- 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.
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}| Ligne | Ce qu'elle fait | Et si tu la modifies ? |
|---|---|---|
| #include <Servo.h> | Ajoute la bibliothèque Servo au programme | Sans elle, le compilateur affiche « 'Servo' does not name a type » |
| const int TRIG_PIN = 9; | Donne le nom TRIG_PIN à la broche 9 | Si tu déplaces le fil, tu changes uniquement ce nombre |
| const int OPEN_DISTANCE = 20; | Distance seuil d'ouverture du couvercle | Avec 30, le couvercle s'ouvre de plus loin |
| Servo lidServo; | Crée un objet servo nommé lidServo | Toutes les lignes suivantes doivent utiliser le même nom |
| int openCount = 0; | Compteur global, à zéro au démarrage | Déplacé dans loop(), il repart à zéro à chaque tour et affiche toujours 1 |
| lidServo.attach(SERVO_PIN); | Relie le servo à la broche 6 | Sans cette ligne, le servo ne bouge pas |
| long distance = readDistanceCm(); | Appelle la fonction et garde le résultat | distance n'existe qu'à l'intérieur de loop() |
| if (distance > 0 && distance < OPEN_DISTANCE) | Entre dans le bloc si les deux conditions sont vraies | distance > 0 écarte le 0 renvoyé quand l'écho ne revient pas |
| delay(3000); | Fait attendre la carte 3 secondes | Pendant ce temps, l'Arduino ne surveille rien d'autre |
| return duration / 58; | Convertit la durée de l'écho en centimètres | Le 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.
| Type | Plage (Arduino Uno) | Usage typique |
|---|---|---|
| int | de -32 768 à 32 767 | Numéros de broche, valeurs d'analogRead, compteurs |
| long | environ ±2,1 milliards | Durée de pulseIn, grands nombres |
| unsigned long | de 0 à environ 4,29 milliards | Temps de millis() et micros() |
| float | Nombres à virgule, 6 à 7 chiffres de précision | Calculs de température, de tension, de distance |
| bool | true ou false | Quelque chose est-il allumé ou éteint ? |
| byte | de 0 à 255 | Valeurs PWM, petits nombres |
| char / String | Un caractère / du texte | Commandes 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.
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 :
| Fonction | Ce qu'elle fait | Exemple |
|---|---|---|
| pinMode(broche, mode) | Configure une broche en entrée ou en sortie | pinMode(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 à LOW | digitalRead(2) |
| analogRead(broche) | Convertit 0–5 V en un nombre entre 0 et 1023 | analogRead(A0) |
| analogWrite(broche, 0–255) | Règle la luminosité d'une LED ou la vitesse d'un moteur en PWM | analogWrite(9, 128); |
| delay(ms) | Met la carte en pause pendant la durée donnée | delay(1000); |
| millis() | Millisecondes écoulées depuis le démarrage | if (millis() - last > 500) |
| Serial.begin / print / println | Envoie du texte au moniteur série | Serial.println(distance); |
| map(x, a, b, c, d) | Transpose une plage de valeurs dans une autre | map(value, 0, 1023, 0, 180) |
| pulseIn(broche, HIGH) | Mesure la durée d'une impulsion en µs | pulseIn(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
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
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 :
| Point | Arduino Uno | ESP32 | Que faire ? |
|---|---|---|---|
| Noms des broches | D2–D13, A0–A5 | Numéros GPIO | Remplace les constantes par des numéros GPIO, attention à 6–11 et 34–39 |
| Tension de fonctionnement | 5 V | 3,3 V | Mets un pont diviseur sur les capteurs qui sortent du 5 V (ECHO du HC-SR04) |
| analogRead | 10 bits, 0–1023 | 12 bits, 0–4095 | Recalcule les seuils et les plages de map() en les multipliant par 4 |
| Bibliothèque servo | Servo.h | ESP32Servo.h | Change de bibliothèque et indique la plage d'impulsion dans attach |
| Vitesse série | souvent 9600 | souvent 115200 | Accorde Serial.begin et le moniteur série |
| Mémoire | 2 Ko de RAM | environ 320 Ko de RAM | Les grands tableaux et les String ne posent plus de problème |
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 :
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
| Erreur | Pourquoi c'est un problème | La bonne approche |
|---|---|---|
| Croire que le code est une liste exécutée une seule fois | loop() se répète sans fin et les variables changent d'un tour à l'autre | Suis loop() sur plusieurs tours, avec des valeurs différentes |
| Confondre = et == | if (x = 5) est toujours vrai | Utilise toujours == pour comparer |
| Oublier la division entière | 5 / 2 donne 2, la partie décimale est perdue | Si tu as besoin de décimales, écris 5.0 / 2 ou utilise un float |
| Oublier que delay() bloque tout | Pendant l'attente, boutons et capteurs ne sont pas lus | Pour plusieurs tâches, gère le temps avec millis() |
| Ignorer les différences de version d'une bibliothèque | Une même fonction peut changer de nom dans une nouvelle version | Cherche dans les commentaires avec quelle bibliothèque le code a été écrit |
| Changer une constante de broche et oublier le fil | Le code lit la bonne broche, mais le fil est ailleurs | Mets à jour ton tableau de câblage après chaque modification |
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.
Projets à réaliser après cet article
Voir tous les projets
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.

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…

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.

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

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…

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…

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.

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.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

