Guides · 11 min de lecture

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.

Carte de développement ESP32 et ses LED intégrées
Carte ESP32 DevKit : la LED rouge indique l'alimentation 3,3 V et la LED bleue l'état du GPIO 2 ; les boutons EN et BOOT sont juste à côté.

À 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 :

CarteLEDReliée àSignification
Arduino Uno R3ON (verte)Ligne 5 VLa carte est alimentée
Arduino Uno R3L (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 R3TX / RX (jaunes)Puce USB-série (ATmega16U2)Échange de données avec le PC ; clignotent vite pendant le téléversement
Arduino Nano / MegaPOW ou ON, L, TX, RX5 V, D13, puce USB-sérieMême signification que sur l'Uno
ESP32 DevKit V1LED rougeLigne 3,3 VLa carte est alimentée ; impossible à éteindre par code
ESP32 DevKit V1LED bleueGPIO 2LED commandée par ton code
ESP32-DevKitC (Espressif)LED rougeLigne 3,3 VAlimentation seulement ; pas de LED utilisateur
ESP32-S3-DevKitCLED RGB (WS2812)GPIO 48 (38 sur certaines révisions)Couleur au choix par code
ESP32-CAMLED rouge / flash blancGPIO 33 / GPIO 4LED d'état (allumée à LOW) / flash de la caméra
Wemos D1 mini, NodeMCULED bleueGPIO 2 (D4)LED utilisateur ; allumée à LOW
Raspberry Pi PicoLED verteGP25LED commandée par ton code ; pas de LED d'alimentation
Raspberry Pi Pico WLED vertePuce 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.
C++ (Arduino IDE)
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}
Si la lueur de L te gêne, ajoute simplement pinMode(13, OUTPUT); digitalWrite(13, LOW); dans setup(). Sur les cartes anciennes (Uno antérieurs au R3 et beaucoup de Nano), la LED L est reliée directement à D13 par une résistance ; sur ces cartes, utiliser D13 comme entrée de bouton avec INPUT_PULLUP n'est pas fiable, car la LED tire la broche vers le bas. Pour une LED externe, calcule la résistance avec l'outil Résistance de LED.

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.

Le GPIO 2 est l'une des broches de configuration au démarrage (strapping) de l'ESP32 : pour que la carte passe en mode programmation et reçoive le code, le GPIO 2 doit être à LOW ou flottant. La LED intégrée et sa résistance le maintiennent déjà au niveau bas, mais si tu branches un module avec résistance de rappel ou un capteur qui met le GPIO 2 à HIGH, le téléversement peut échouer avec « Failed to connect » ou « Wrong boot mode detected ». Réserve le GPIO 2 à la LED et aux sorties simples, et branche les entrées sur d'autres broches.

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() :

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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 :

MicroPython
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 second

Sur 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.

CarteLED_BUILTINRemarque
Arduino Uno, Nano, Mega, Leonardo, Uno R413HIGH allume
Wemos D1 mini, NodeMCU (ESP8266)2LOW allume (logique inversée)
ESP32 (avec DOIT ESP32 DEVKIT V1)2HIGH allume
ESP32 Dev ModuleParfois non définieDéfinis-la toi-même : const int LED_PIN = 2;
ESP32-S3-DevKitCRGB_BUILTIN (GPIO 48)Couleur avec rgbLedWrite() ou neopixelWrite()
Raspberry Pi Pico (core Arduino)25HIGH allume
Raspberry Pi Pico W (core Arduino)Broche virtuelle spécialeIl suffit d'écrire LED_BUILTIN

Que t'indique chaque LED ? Tableau des symptômes

SymptômeSignification probableQue faire ?
La L de l'Arduino clignote une fois par secondeLe Blink d'usine est chargéNormal ; s'arrête quand tu téléverses ton code
L clignote vite quelques fois après un resetLe bootloader démarre, puis ton codeNormal
L clignote vite sans arrêt, le code ne tourne pasLa carte redémarre en boucleVérifie l'alimentation et les courts-circuits, téléverse à nouveau
L faiblement allumée ou allumée seuleD13 flottante, entrée du tampon en l'airNormal ; mets D13 en OUTPUT à LOW si tu veux
La LED ON ne s'allume pasPas 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éversementMauvais port, pilote ou carteChoisis le bon port et la bonne carte, installe le pilote CH340
La LED bleue de l'ESP32 reste alluméeLe programme a laissé le GPIO 2 à HIGHVérifie le GPIO 2 dans ton code
La LED bleue de l'ESP32 clignote vite et irrégulièrementLa 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 jamaisPas de LED utilisateur ou le code pilote une autre brocheVérifie le numéro de broche ou branche une LED externe
La LED rouge de l'ESP32 scintilleAlimentation 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 PicoLe Pico n'a pas de LED d'alimentation et aucun programme ne tourneNormal ; 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 ?.
La LED d'alimentation paraît minuscule, mais dans un projet sur batterie elle peut être le plus gros consommateur avec 1 à 5 mA. Sur un montage qui ne consomme que quelques microampères en veille, dessouder la résistance de la LED d'alimentation peut faire passer l'autonomie de quelques semaines à plusieurs mois ; c'est une astuce très répandue dans les projets sur batterie avec l'Arduino Pro Mini.

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.

Voir tous les projets
Clignotement de la LED interne de l'ESP32
ES-4Débutant

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.

4.8(29)
54
Clignotement LED Intégrée Raspberry Pi Pico (Pico et Pico W)
PI-1Débutant

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.

5.0(1)
10
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
Clignotement LED avec ESP32
ES-1Débutant

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.

4.7(37)
108
Allumage d'une LED externe sur le Raspberry Pi Pico (plaque d'essai)
PI-2Débutant

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.

4.5(2)
7
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
ESP32 Contrôle de LED avec bouton poussoir (Push)
ES-2Débutant

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.

4.6(36)
57
Feu de circulation ESP32
ES-5Débutant

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.

4.4(22)
45