LED bleue ESP32 : signification des LED d'Arduino, ESP32 et Pico
LED bleue ESP32 et LED rouge : signification, ON, L, TX et RX sur Arduino et le GP25 du Pico ; tableau carte par carte, causes du clignotement, LED_BUILTIN.
La LED bleue de l'ESP32 est, sur la plupart des cartes ESP32 DevKit V1, une LED utilisateur reliée au GPIO 2 et commandée uniquement par ton code ; sa signification est donc celle que ton programme lui donne, tandis que la LED rouge voisine indique seulement que la carte est alimentée. Les voyants ON, L, TX et RX de l'Arduino Uno et la petite LED verte du Raspberry Pi Pico fonctionnent de la même façon : chacun signale soit un état matériel, soit ce que fait ton programme. Une fois que tu sais les lire, tu vois d'un coup d'œil si la carte est alimentée, si des données passent pendant le téléversement et si ton programme tourne vraiment.
Dans ce guide, on a rassemblé dans un tableau la broche ou la ligne à laquelle est reliée chaque LED des cartes Arduino, ESP32 et Pico. On explique les vraies causes de situations courantes comme « la LED bleue de l'ESP32 reste allumée », « la LED bleue clignote » ou « la LED L de l'Arduino clignote toute seule », on montre vers quelle broche pointe LED_BUILTIN sur chaque carte et, avec du code, on transforme la LED intégrée en indicateur d'état pour tes projets.

À quoi servent les LED de la carte ?
Les LED des cartes de développement se rangent en trois groupes. Les LED d'alimentation sont reliées directement à une ligne d'alimentation par une résistance ; elles restent allumées tant que la carte est alimentée et ne s'éteignent pas par logiciel. Les LED de communication (TX et RX) sont pilotées par la puce de conversion USB-série et clignotent dès que des données s'échangent avec l'ordinateur. Les LED utilisateur sont reliées à une broche du microcontrôleur et ne font que ce que dit ton code ; la L de l'Arduino, la LED bleue de l'ESP32 et la LED verte du Pico en font partie. Le tableau résume les cartes les plus courantes :
| Carte | LED | Reliée à | Signification |
|---|---|---|---|
| Arduino Uno R3 | ON (verte) | Ligne 5 V | La carte est alimentée |
| Arduino Uno R3 | L (jaune/orange) | D13 (via un tampon à ampli-op) | LED commandée par ton code ; le bootloader la fait aussi clignoter après un reset |
| Arduino Uno R3 | TX / RX (jaunes) | Puce USB-série (ATmega16U2) | Échange de données avec le PC ; clignotent vite pendant le téléversement |
| Arduino Nano / Mega | POW ou ON, L, TX, RX | 5 V, D13, puce USB-série | Même signification que sur l'Uno |
| ESP32 DevKit V1 | LED rouge | Ligne 3,3 V | La carte est alimentée ; impossible à éteindre par code |
| ESP32 DevKit V1 | LED bleue | GPIO 2 | LED commandée par ton code |
| ESP32-DevKitC (Espressif) | LED rouge | Ligne 3,3 V | Alimentation seulement ; pas de LED utilisateur |
| ESP32-S3-DevKitC | LED RGB (WS2812) | GPIO 48 (38 sur certaines révisions) | Couleur au choix par code |
| ESP32-CAM | LED rouge / flash blanc | GPIO 33 / GPIO 4 | LED d'état (allumée à LOW) / flash de la caméra |
| Wemos D1 mini, NodeMCU | LED bleue | GPIO 2 (D4) | LED utilisateur ; allumée à LOW |
| Raspberry Pi Pico | LED verte | GP25 | LED commandée par ton code ; pas de LED d'alimentation |
| Raspberry Pi Pico W | LED verte | Puce Wi-Fi (WL_GPIO0) | Se commande avec Pin("LED") |
Les LED de l'Arduino Uno : ON, L, TX et RX
La LED ON est reliée à la ligne 5 V et s'allume dès que la carte est alimentée par l'USB ou par la prise jack. Si elle reste éteinte, la carte n'est pas alimentée : le câble peut être défectueux, le port USB ne pas fournir de courant, ou un court-circuit dans ton montage a déclenché le fusible réarmable (polyfuse) de la carte. La LED L est reliée à la broche numérique 13 ; sur l'Uno R3, un tampon à amplificateur opérationnel est placé entre les deux, si bien que la LED ne charge pas la broche. Les LED TX et RX sont allumées par la puce USB-série ATmega16U2 : TX clignote pendant le téléversement et quand tu envoies des données au PC avec Serial.print(), RX quand des données arrivent du PC. Détail important : sur l'Uno R3, ces deux LED ne montrent que le trafic USB ; elles ne clignotent pas quand tu dialogues avec un module Bluetooth branché sur les broches 0 et 1.
Pourquoi la LED L de l'Arduino clignote-t-elle toute seule ?
- Le programme Blink d'usine : La plupart des Uno et Nano neufs sont livrés avec l'exemple Blink chargé pour les tests ; L clignote alors une fois par seconde. Ça s'arrête dès que tu téléverses ton propre code.
- Les clignotements de démarrage du bootloader : Quand tu appuies sur reset, branches l'USB ou ouvres le moniteur série, la carte redémarre et le bootloader fait clignoter L rapidement quelques fois avant de lancer ton code.
- L faiblement allumée ou allumée toute seule : Si ton code n'utilise pas D13, la broche reste en entrée flottante, et comme l'entrée du tampon de l'Uno R3 est alors en l'air, L peut s'allumer faiblement ou complètement. Ce n'est pas une panne.
- Scintillement avec un module SPI : D13 est la ligne d'horloge (SCK) du bus SPI. L scintille pendant qu'un lecteur RFID RC522, une carte SD ou un module Ethernet travaille ; c'est normal aussi.
- Clignotement rapide permanent et code qui ne tourne pas : La carte redémarre en boucle. Une alimentation trop faible, un court-circuit entre 5 V et GND ou un code qui provoque une boucle de reset peuvent en être la cause.
1// Uno, Nano, Mega: L LED'i D13'tedir, LED_BUILTIN = 13 / the L LED is on D13, LED_BUILTIN = 13
2void setup() {
3 pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7 digitalWrite(LED_BUILTIN, HIGH); // L yanar / L on
8 delay(1000);
9 digitalWrite(LED_BUILTIN, LOW); // L söner / L off
10 delay(1000);
11}Que signifient la LED rouge et la LED bleue de l'ESP32 ?
La LED rouge de l'ESP32 DevKit V1 et des cartes similaires est reliée à la ligne 3,3 V en sortie du régulateur. Elle s'allume quand la carte est alimentée par l'USB ou la broche VIN, et aucun code ne peut l'éteindre. Si elle ne s'allume pas du tout, la carte n'est pas alimentée ; si elle scintille ou reste faible, l'alimentation est insuffisante. La LED bleue est une LED utilisateur sur le GPIO 2 : elle s'allume quand la broche est à HIGH et s'éteint à LOW. Toutes les cartes ESP32 n'en ont pas ; l'ESP32-DevKitC d'Espressif n'a qu'une LED d'alimentation, et les cartes ESP32-S3 et ESP32-C3 portent le plus souvent une LED RGB adressable au lieu d'une LED d'une seule couleur.
Pour la plupart de ceux qui se demandent pourquoi la LED bleue de l'ESP32 reste allumée, la raison est simple : le programme chargé a mis le GPIO 2 à HIGH et l'y a laissé, ou un montage relié au GPIO 2 tire la broche vers le haut. Sur une carte neuve, une LED bleue qui clignote toute seule vient presque toujours d'un programme de test de type Blink chargé par le vendeur. Si ton code ne touche pas la LED et qu'elle clignote quand même vite et de façon irrégulière, la carte redémarre très probablement en boucle : ouvre le moniteur série à 115200 bauds et cherche un message comme « Brownout detector was triggered » ou « Guru Meditation Error ». Si la LED bleue ne s'allume jamais, ta carte n'a peut-être pas de LED utilisateur, ou ton code pilote une autre broche.
Faire de la LED bleue de l'ESP32 un indicateur Wi-Fi
Le rôle le plus utile d'une LED intégrée, c'est d'indiquer l'état d'un appareil qui n'a pas d'écran. Le code ci-dessous fait clignoter la LED bleue cinq fois par seconde pendant que l'ESP32 cherche à se connecter au Wi-Fi, puis émet un court « battement de cœur » toutes les deux secondes une fois connecté. Même si l'appareil est fixé au mur, tu vois de loin s'il est sur le réseau et si le programme n'est pas bloqué. Comme le code n'utilise pas delay(), tu peux ajouter d'autres tâches dans loop() :
1#include <WiFi.h>
2
3const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
4const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
5const int LED_PIN = 2; // DevKit V1 mavi LED / blue LED on DevKit V1
6
7void setup() {
8 pinMode(LED_PIN, OUTPUT);
9 WiFi.mode(WIFI_STA);
10 WiFi.begin(ssid, password);
11}
12
13void loop() {
14 unsigned long t = millis();
15 if (WiFi.status() == WL_CONNECTED) {
16 digitalWrite(LED_PIN, (t % 2000) < 80); // bağlı: 2 sn'de bir kısa çakma / connected: short flash every 2 s
17 } else {
18 digitalWrite(LED_PIN, (t % 200) < 100); // bağlanıyor: hızlı yanıp sönme / connecting: fast blink
19 }
20}L'astuce, c'est millis() % période : millis() renvoie le nombre de millisecondes depuis le démarrage, et le modulo transforme ce nombre en compteur qui tourne entre 0 et la période. Tant que le compteur est sous une valeur fixée, la LED est allumée, au-dessus elle est éteinte ; une fois connecté, par exemple, la LED n'est allumée que pendant les 80 premières ms de chaque période de 2000 ms. On détaille la différence entre delay() et millis() dans millis() et delay() sur Arduino ; si la carte ne se connecte jamais, suis la liste de contrôle de L'ESP32 ne se connecte pas au Wi-Fi.
La LED RGB des cartes ESP32-S3 et ESP32-C3
Sur les cartes Espressif récentes, la LED utilisateur est généralement une LED RGB adressable de type WS2812. Sur l'ESP32-S3-DevKitC, elle est reliée au GPIO 48 (au GPIO 38 sur certaines révisions de la carte), et sur l'ESP32-C3-DevKitM au GPIO 8. Impossible de lui donner une couleur avec digitalWrite(), car elle reçoit ses couleurs sous forme d'une suite de bits au timing très précis. Le core Arduino pour ESP32 fournit une fonction toute prête : rgbLedWrite() dans les versions 3.x et neopixelWrite() dans les versions 2.x. Le code ci-dessous compile avec les deux et fait passer la LED par le rouge, le vert et le bleu. Les cartes ESP32-C3 SuperMini bon marché ont en revanche, à la place d'une LED RGB, une seule LED bleue sur le GPIO 8 qui s'allume à LOW.
1// ESP32-S3-DevKitC dahili RGB LED (WS2812): GPIO 48, bazı sürümlerde 38 / onboard RGB LED: GPIO 48 (38 on some revisions)
2const uint8_t RGB_PIN = 48;
3
4void setColor(uint8_t r, uint8_t g, uint8_t b) {
5#if ESP_ARDUINO_VERSION_MAJOR >= 3
6 rgbLedWrite(RGB_PIN, r, g, b); // ESP32 çekirdeği 3.x / ESP32 core 3.x
7#else
8 neopixelWrite(RGB_PIN, r, g, b); // ESP32 çekirdeği 2.x / ESP32 core 2.x
9#endif
10}
11
12void setup() {
13}
14
15void loop() {
16 setColor(40, 0, 0); delay(500); // kırmızı / red
17 setColor(0, 40, 0); delay(500); // yeşil / green
18 setColor(0, 0, 40); delay(500); // mavi / blue
19 setColor(0, 0, 0); delay(500); // kapalı / off
20}La LED intégrée du Raspberry Pi Pico et du Pico W
Le Raspberry Pi Pico a une seule LED verte à côté de la prise USB, reliée à la broche GP25. Le Pico n'a pas de LED d'alimentation : sans programme, il semble complètement mort même branché en USB, et beaucoup de débutants croient la carte en panne. Sur le Pico W et le Pico 2 W, la LED n'est pas reliée au microcontrôleur mais à une broche de la puce Wi-Fi, et le GP25 sert à dialoguer avec la puce sans fil. C'est pourquoi Pin(25) n'allume pas la LED d'un Pico W ; en MicroPython, il faut écrire Pin("LED"). Les versions récentes de MicroPython acceptent aussi cette écriture sur le Pico classique, ce qui permet d'écrire un seul code pour les deux cartes :
1from machine import Pin, Timer
2
3led = Pin("LED", Pin.OUT) # Pico, Pico W, Pico 2 ve Pico 2 W'de çalışır / works on all Pico boards
4# Çok eski Pico yazılımında / on very old Pico firmware: led = Pin(25, Pin.OUT)
5
6timer = Timer()
7timer.init(freq=2, mode=Timer.PERIODIC, callback=lambda t: led.toggle()) # saniyede bir yanıp sönme / one blink per secondSur un Pico W, installe toujours le firmware MicroPython compilé pour le Pico W ; celui du Pico classique ne connaît pas la puce Wi-Fi et ne peut donc pas atteindre la LED. Si tu programmes le Pico depuis l'Arduino IDE (avec le core Raspberry Pi Pico/RP2040 d'Earle Philhower), LED_BUILTIN désigne la bonne LED sur les deux cartes. Un Pico branché en maintenant BOOTSEL n'allume aucune LED ; s'il apparaît sur ton ordinateur comme un lecteur nommé RPI-RP2, la carte va bien. Pour découvrir la carte, lis Qu'est-ce que le Raspberry Pi Pico ?.
Qu'est-ce que LED_BUILTIN, et quelle broche sur chaque carte ?
LED_BUILTIN est une constante écrite dans le fichier de définition de la carte, qui contient le numéro de broche de sa LED utilisateur. Si tu utilises LED_BUILTIN au lieu de 13 ou 2, le même programme allume la bonne LED sur des cartes différentes. Deux points à surveiller : la carte choisie dans l'Arduino IDE doit correspondre à celle que tu as en main, et certaines définitions génériques n'ont tout simplement pas cette constante. Sur l'ESP32, par exemple, avec ESP32 Dev Module sélectionné, le compilateur peut afficher « 'LED_BUILTIN' was not declared in this scope » ; choisis alors la carte DOIT ESP32 DEVKIT V1 ou écris const int LED_PIN = 2; en tête de ton code.
| Carte | LED_BUILTIN | Remarque |
|---|---|---|
| Arduino Uno, Nano, Mega, Leonardo, Uno R4 | 13 | HIGH allume |
| Wemos D1 mini, NodeMCU (ESP8266) | 2 | LOW allume (logique inversée) |
| ESP32 (avec DOIT ESP32 DEVKIT V1) | 2 | HIGH allume |
| ESP32 Dev Module | Parfois non définie | Définis-la toi-même : const int LED_PIN = 2; |
| ESP32-S3-DevKitC | RGB_BUILTIN (GPIO 48) | Couleur avec rgbLedWrite() ou neopixelWrite() |
| Raspberry Pi Pico (core Arduino) | 25 | HIGH allume |
| Raspberry Pi Pico W (core Arduino) | Broche virtuelle spéciale | Il suffit d'écrire LED_BUILTIN |
Que t'indique chaque LED ? Tableau des symptômes
| Symptôme | Signification probable | Que faire ? |
|---|---|---|
| La L de l'Arduino clignote une fois par seconde | Le Blink d'usine est chargé | Normal ; s'arrête quand tu téléverses ton code |
| L clignote vite quelques fois après un reset | Le bootloader démarre, puis ton code | Normal |
| L clignote vite sans arrêt, le code ne tourne pas | La carte redémarre en boucle | Vérifie l'alimentation et les courts-circuits, téléverse à nouveau |
| L faiblement allumée ou allumée seule | D13 flottante, entrée du tampon en l'air | Normal ; mets D13 en OUTPUT à LOW si tu veux |
| La LED ON ne s'allume pas | Pas d'alimentation, câble défectueux ou fusible déclenché | Essaie un autre câble et un autre port, supprime le court-circuit, attends quelques minutes |
| TX/RX ne clignotent jamais au téléversement | Mauvais port, pilote ou carte | Choisis le bon port et la bonne carte, installe le pilote CH340 |
| La LED bleue de l'ESP32 reste allumée | Le programme a laissé le GPIO 2 à HIGH | Vérifie le GPIO 2 dans ton code |
| La LED bleue de l'ESP32 clignote vite et irrégulièrement | La carte redémarre en boucle ou un programme de test est chargé | Lis l'erreur dans le moniteur série, renforce l'alimentation |
| La LED bleue de l'ESP32 ne s'allume jamais | Pas de LED utilisateur ou le code pilote une autre broche | Vérifie le numéro de broche ou branche une LED externe |
| La LED rouge de l'ESP32 scintille | Alimentation insuffisante (chute de tension à l'émission Wi-Fi) | Utilise un bon câble et un chargeur 5 V d'au moins 1 A |
| Aucune LED ne s'allume sur le Pico | Le Pico n'a pas de LED d'alimentation et aucun programme ne tourne | Normal ; vérifie avec BOOTSEL si le lecteur RPI-RP2 apparaît |
Utiliser la LED intégrée dans tes projets
- Codes d'erreur : Fais clignoter la LED deux fois si un capteur est introuvable et trois fois s'il n'y a pas de Wi-Fi, puis marque une pause ; tu comprends le problème sans ouvrir le moniteur série.
- Battement de cœur : Fais un bref éclat toutes les quelques secondes tant que le programme va bien ; si la LED s'arrête, tu sais que le code est bloqué quelque part.
- Signal d'événement : Fais clignoter la LED une fois à l'arrivée d'un message MQTT ou d'une requête web ; le débogage des serveurs web ESP32 devient bien plus simple.
- Effet respiration : Sur l'ESP32 et le Pico, allume et éteins doucement la LED intégrée en PWM ; sur l'Uno, ça ne marche pas car D13 n'a pas de PWM. Détails dans Qu'est-ce que le PWM ?.
- Projets sur batterie : Sur un appareil en deep sleep, éteins toujours la LED intégrée avant la mise en veille ; ESP32 Deep Sleep montre comment descendre à quelques µA.
- Passer à une LED externe : Pour un voyant plus lumineux ou d'une autre couleur, ajoute une LED et sa résistance comme dans Qu'est-ce qu'une LED ?.
Les LED intégrées sont le premier outil de diagnostic en électronique, et le moins cher : elles répondent en quelques secondes aux questions « y a-t-il du courant ? », « les données passent-elles ? » et « le programme tourne-t-il ? ». Pour faire le premier pas, l'application BlueGrays propose les projets Allumer une LED avec Arduino, LED intégrée de l'ESP32 et LED intégrée du Raspberry Pi Pico, avec schémas de câblage et code pas à pas.
Questions fréquentes
Que signifie la LED bleue de l'ESP32 ?
Sur l'ESP32 DevKit V1 et les cartes similaires, la LED bleue est une LED utilisateur reliée au GPIO 2 : seul le code que tu téléverses l'allume ou l'éteint. C'est la LED rouge qui indique que la carte est alimentée. Toutes les cartes ESP32 n'ont pas de LED bleue ; la DevKitC d'Espressif n'a qu'une LED d'alimentation.
Pourquoi la LED bleue de mon ESP32 reste-t-elle allumée ?
Le plus souvent, un programme chargé sur la carte met le GPIO 2 à HIGH. Un module relié au GPIO 2 peut aussi tirer la broche vers le haut et allumer la LED. Mets le GPIO 2 à LOW dans ton code ou déplace le montage sur une autre broche ; une LED bleue allumée n'est pas une panne en soi.
Pourquoi la LED bleue de l'ESP32 clignote-t-elle ?
Si ton programme ne fait pas clignoter le GPIO 2, un clignotement rapide et irrégulier indique en général une boucle de redémarrage, souvent due à une alimentation trop faible ou à un plantage. Ouvre le moniteur série à 115200 bauds et cherche des messages de brownout ou de Guru Meditation. Un clignotement régulier sur une carte neuve vient le plus souvent du programme de test du vendeur.
Quelle broche correspond à LED_BUILTIN sur l'ESP32 ?
Dans la définition de carte DOIT ESP32 DEVKIT V1, LED_BUILTIN correspond au GPIO 2. Avec ESP32 Dev Module sélectionné, la constante peut ne pas exister et le compilateur affiche une erreur ; écrire const int LED_PIN = 2; dans ton code règle le problème. Sur les cartes ESP32-S3, on utilise RGB_BUILTIN pour la LED RGB.
Pourquoi la LED intégrée du Raspberry Pi Pico W ne s'allume-t-elle pas ?
Sur le Pico W, la LED est reliée à la puce Wi-Fi et non au microcontrôleur, elle ne se commande donc pas avec Pin(25). En MicroPython, écris Pin("LED", Pin.OUT) et utilise le firmware MicroPython prévu pour le Pico W.
Pourquoi la LED L de l'Arduino clignote-t-elle toute seule ?
Les cartes neuves sont en général livrées avec le programme Blink préchargé, d'où un clignotement par seconde. Les quelques éclats rapides après un reset viennent du bootloader. Si D13 n'est pas utilisée, L peut luire faiblement, et avec un module SPI branché elle scintille ; tout cela est normal.
Projets à réaliser après cet article
Voir tous les projets
Clignotement de la LED interne de l'ESP32
Faire clignoter la LED bleue intégrée à l'ESP32 DevKit V1. Aucun composant externe n'est nécessaire ! Le premier projet que vous devriez essayer lorsque vous achetez un ESP32. Le GPIO 2 est connecté à la LED interne.

Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W)
Le projet d'ouverture de la série Raspberry Pi Pico ! On fait clignoter la LED verte intégrée du Pico pour vérifier que la carte fonctionne : le classique premier essai façon "Hello World". Aucun composant externe, juste le Pico et un câble USB. Le code est écrit en MicroPython, le langage officiellement pris en charge par la Raspberry Pi Foundation.

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.

Clignotement LED avec ESP32
Enseigne l'utilisation de base des sorties GPIO avec l'ESP32. Nous obtenons un effet de clignotement en allumant et éteignant une LED à partir de la broche numérique. Version ESP32 du projet blink classique sur Arduino UNO ; les commandes de base de blink dans l'environnement Arduino restent les mêmes, mais le brochage et les niveaux GPIO de 3,3 V de l'ESP32 diffèrent de ceux de l'Arduino UNO.

Allumage d'une LED externe sur le Raspberry Pi Pico (plaque d'essai)
L'étape suivante après la LED intégrée du Pico : brancher une LED externe sur une plaque d'essai et la piloter par la broche GP14. Tu apprends à utiliser n'importe quelle broche GPIO du Pico en sortie, la polarité de la LED (patte longue = anode/+, patte courte = cathode/–) et pourquoi une résistance de limitation (220Ω) est indispensable. Sans elle, trop de courant traverse la LED, qui peut griller.

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.

ESP32 Contrôle de LED avec bouton poussoir (Push)
La LED s'allume lorsque le bouton est enfoncé et s'éteint lorsqu'il est relâché. Montre comment la broche d'entrée numérique de l'ESP32 et la résistance pull-up interne sont utilisées. Grâce au mode INPUT_PULLUP, aucune résistance externe n'est nécessaire.

Feu de circulation ESP32
Simulation d'un vrai feu de circulation avec 3 LED rouge-jaune-vert. Les temps sont proches de la logique du trafic réel : rouge long, jaune court, vert long. Exemple classique de contrôle séquentiel GPIO.
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

