LED blu ESP32 significato: i LED di Arduino, ESP32 e Pico
LED blu ESP32 significato, LED rosso, ON, L, TX e RX su Arduino e LED GP25 del Pico: tabella scheda per scheda, perché lampeggiano e come usare LED_BUILTIN.
Il LED blu dell'ESP32 è, sulla maggior parte delle schede ESP32 DevKit V1, un LED utente collegato al GPIO 2 e comandato soltanto dal tuo codice: il suo significato è quello che gli dà il tuo programma, mentre il LED rosso accanto indica solo che la scheda è alimentata. Le spie ON, L, TX e RX di Arduino Uno e il piccolo LED verde del Raspberry Pi Pico funzionano allo stesso modo: ognuna segnala uno stato dell'hardware oppure quello che sta facendo il tuo programma. Quando impari a leggerle, capisci a colpo d'occhio se la scheda è alimentata, se durante il caricamento passano dati e se il tuo sketch sta davvero girando.
In questa guida abbiamo raccolto in una tabella a quale pin o linea è collegato ogni LED delle schede Arduino, ESP32 e Pico. Spieghiamo le vere cause di situazioni comuni come "il LED blu dell'ESP32 resta acceso", "il LED blu lampeggia" e "il LED L di Arduino lampeggia da solo", vediamo a quale pin punta LED_BUILTIN su ogni scheda e, con il codice, trasformiamo il LED integrato in un indicatore di stato per i tuoi progetti.

A cosa servono i LED sulla scheda?
I LED delle schede di sviluppo si dividono in tre gruppi. I LED di alimentazione sono collegati direttamente a una linea di alimentazione tramite una resistenza: restano accesi finché la scheda è alimentata e non si spengono via software. I LED di comunicazione (TX e RX) sono pilotati dal chip convertitore USB-seriale e lampeggiano quando ci sono scambi di dati con il computer. I LED utente sono collegati a un pin del microcontrollore e fanno solo quello che dice il tuo codice; il LED L di Arduino, quello blu dell'ESP32 e quello verde del Pico appartengono a questo gruppo. La tabella riassume le schede più diffuse:
| Scheda | LED | Collegato a | Significato |
|---|---|---|---|
| Arduino Uno R3 | ON (verde) | Linea 5 V | La scheda è alimentata |
| Arduino Uno R3 | L (giallo/arancione) | D13 (tramite un buffer con amplificatore operazionale) | LED comandato dal codice; dopo un reset lo fa lampeggiare anche il bootloader |
| Arduino Uno R3 | TX / RX (gialli) | Chip USB-seriale (ATmega16U2) | Scambio di dati con il PC; lampeggiano veloci durante il caricamento |
| Arduino Nano / Mega | POW o ON, L, TX, RX | 5 V, D13, chip USB-seriale | Stesso significato dell'Uno |
| ESP32 DevKit V1 | LED rosso | Linea 3,3 V | La scheda è alimentata; non si spegne da codice |
| ESP32 DevKit V1 | LED blu | GPIO 2 | LED comandato dal codice |
| ESP32-DevKitC (Espressif) | LED rosso | Linea 3,3 V | Solo alimentazione; niente LED utente |
| ESP32-S3-DevKitC | LED RGB (WS2812) | GPIO 48 (38 in alcune revisioni) | Colore a scelta da codice |
| ESP32-CAM | LED rosso / flash bianco | GPIO 33 / GPIO 4 | LED di stato (acceso con LOW) / flash della fotocamera |
| Wemos D1 mini, NodeMCU | LED blu | GPIO 2 (D4) | LED utente; acceso con LOW |
| Raspberry Pi Pico | LED verde | GP25 | LED comandato dal codice; niente LED di alimentazione |
| Raspberry Pi Pico W | LED verde | Chip Wi-Fi (WL_GPIO0) | Si comanda con Pin("LED") |
I LED di Arduino Uno: ON, L, TX e RX
Il LED ON è collegato alla linea 5 V e si accende appena la scheda riceve corrente dall'USB o dal jack di alimentazione. Se resta spento la scheda non è alimentata: il cavo può essere difettoso, la porta USB può non erogare corrente oppure un cortocircuito nel tuo circuito ha fatto intervenire il fusibile autoripristinante (polyfuse) della scheda. Il LED L è collegato al pin digitale 13; sull'Uno R3 tra i due c'è un buffer con amplificatore operazionale, quindi il LED non carica il pin. I LED TX e RX li accende il chip USB-seriale ATmega16U2: TX lampeggia mentre carichi il codice o invii dati al PC con Serial.print(), RX quando arrivano dati dal PC. Un dettaglio importante: sull'Uno R3 questi due LED mostrano solo il traffico USB, quindi non lampeggiano quando comunichi con un modulo Bluetooth collegato ai pin 0 e 1.
Perché il LED L di Arduino lampeggia da solo?
- Il programma Blink di fabbrica: Gran parte delle Uno e delle Nano nuove arriva con l'esempio Blink caricato per il collaudo, quindi L lampeggia una volta al secondo. Smette appena carichi il tuo codice.
- I lampi di avvio del bootloader: Quando premi reset, colleghi l'USB o apri il Monitor seriale, la scheda si riavvia e il bootloader fa lampeggiare L velocemente qualche volta prima di avviare il tuo codice.
- L acceso debole o acceso da solo: Se il tuo codice non usa D13, il pin resta un ingresso flottante e, visto che anche l'ingresso del buffer dell'Uno R3 rimane scollegato, L può accendersi debolmente o del tutto. Non è un guasto.
- Sfarfallio con un modulo SPI collegato: D13 è la linea di clock (SCK) del bus SPI. L sfarfalla mentre lavorano un lettore RFID RC522, una scheda SD o un modulo Ethernet; anche questo è normale.
- Lampeggio veloce continuo e codice che non parte: La scheda si resetta di continuo. Le cause possono essere un'alimentazione debole, un corto tra 5 V e GND o un codice che provoca un ciclo di reset.
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}Cosa significano il LED rosso e il LED blu dell'ESP32?
Il LED rosso dell'ESP32 DevKit V1 e delle schede simili è collegato alla linea a 3,3 V in uscita dal regolatore. Si accende quando la scheda è alimentata dall'USB o dal pin VIN e nessun codice può spegnerlo. Se non si accende per niente, la scheda non è alimentata; se sfarfalla o resta debole, l'alimentazione è insufficiente. Il LED blu è un LED utente sul GPIO 2: si accende quando il pin è HIGH e si spegne con LOW. Non tutte le schede ESP32 ce l'hanno; la ESP32-DevKitC della stessa Espressif ha solo il LED di alimentazione, e le schede ESP32-S3 ed ESP32-C3 di solito montano un LED RGB indirizzabile al posto di uno monocolore.
Per la maggior parte di chi chiede perché il LED blu dell'ESP32 resta sempre acceso, il motivo è semplice: lo sketch caricato ha messo il GPIO 2 a HIGH e l'ha lasciato così, oppure un circuito collegato al GPIO 2 tira il pin verso l'alto. Sulle schede nuove, un LED blu che lampeggia da solo dipende quasi sempre da un programma di prova tipo Blink caricato dal venditore. Se il tuo codice non tocca il LED e lui lampeggia comunque in modo veloce e irregolare, molto probabilmente la scheda si sta riavviando di continuo: apri il Monitor seriale a 115200 baud e cerca messaggi come "Brownout detector was triggered" o "Guru Meditation Error". Se il LED blu non si accende mai, la tua scheda potrebbe non avere un LED utente, oppure il tuo codice sta pilotando un altro pin.
Usare il LED blu dell'ESP32 come indicatore del Wi-Fi
Il compito più utile di un LED integrato è dirti in che stato si trova un dispositivo senza display. Il codice seguente fa lampeggiare il LED blu cinque volte al secondo mentre l'ESP32 prova a collegarsi al Wi-Fi e, una volta connesso, dà un breve "battito" ogni due secondi. Così, anche con il dispositivo montato a parete, vedi da lontano se è in rete e se il programma non si è bloccato. Visto che il codice non usa delay(), puoi aggiungere altre attività in 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}Il trucco è millis() % periodo: millis() restituisce i millisecondi trascorsi dall'avvio e l'operazione modulo trasforma quel numero in un contatore che gira tra 0 e il periodo. Finché il contatore è sotto un certo valore il LED è acceso, sopra è spento; da connesso, per esempio, il LED resta acceso solo nei primi 80 ms di ogni periodo di 2000 ms. La differenza tra delay() e millis() la spieghiamo nel dettaglio in millis() e delay() su Arduino; se la scheda non si connette mai, segui la checklist di L'ESP32 non si connette al Wi-Fi.
Il LED RGB delle schede ESP32-S3 ed ESP32-C3
Sulle schede Espressif più recenti il LED utente è di solito un LED RGB indirizzabile di tipo WS2812. Sulla ESP32-S3-DevKitC è collegato al GPIO 48 (in alcune revisioni della scheda al GPIO 38) e sulla ESP32-C3-DevKitM al GPIO 8. Non puoi dargli un colore con digitalWrite(), perché riceve i colori come una sequenza di bit con temporizzazione molto precisa. Il core Arduino per ESP32 offre una funzione pronta: rgbLedWrite() nelle versioni 3.x e neopixelWrite() nelle 2.x. Il codice qui sotto compila con entrambe e fa passare il LED da rosso a verde a blu. Le economiche schede ESP32-C3 SuperMini invece, al posto del LED RGB, hanno un singolo LED blu sul GPIO 8 che si accende con 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}Il LED integrato del Raspberry Pi Pico e del Pico W
Il Raspberry Pi Pico ha un unico LED verde accanto al connettore USB, collegato al pin GP25. Il Pico non ha un LED di alimentazione, quindi senza un programma in esecuzione sembra completamente morto anche collegato all'USB, e chi lo usa per la prima volta pensa spesso che sia guasto. Sul Pico W e sul Pico 2 W il LED non è collegato al microcontrollore ma a un pin del chip Wi-Fi, e il GP25 serve per comunicare con il chip wireless. Per questo sul Pico W Pin(25) non accende il LED; in MicroPython devi scrivere Pin("LED"). Le versioni recenti di MicroPython accettano questa forma anche sul Pico normale, così puoi scrivere un solo codice per entrambe le schede:
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 secondSul Pico W carica sempre il firmware MicroPython compilato per il Pico W: quello del Pico normale non conosce il chip Wi-Fi e quindi non raggiunge nemmeno il LED. Se programmi il Pico dall'Arduino IDE (con il core Raspberry Pi Pico/RP2040 di Earle Philhower), LED_BUILTIN indica il LED giusto su entrambe le schede. Un Pico collegato tenendo premuto BOOTSEL non accende nessun LED; se sul computer compare come unità chiamata RPI-RP2, la scheda è a posto. Per conoscere meglio la scheda leggi Cos'è il Raspberry Pi Pico?.
Cos'è LED_BUILTIN e a quale pin corrisponde su ogni scheda?
LED_BUILTIN è una costante scritta nel file di definizione della scheda che contiene il numero di pin del suo LED utente. Se nel codice usi LED_BUILTIN al posto di 13 o 2, lo stesso sketch accende il LED giusto su schede diverse. Devi fare attenzione a due cose: la scheda scelta nell'Arduino IDE deve essere quella che hai in mano, e alcune definizioni generiche questa costante non ce l'hanno proprio. Sull'ESP32, per esempio, con ESP32 Dev Module selezionato il compilatore può segnalare "'LED_BUILTIN' was not declared in this scope"; in quel caso scegli la scheda DOIT ESP32 DEVKIT V1 oppure scrivi const int LED_PIN = 2; all'inizio del codice.
| Scheda | LED_BUILTIN | Nota |
|---|---|---|
| Arduino Uno, Nano, Mega, Leonardo, Uno R4 | 13 | HIGH accende |
| Wemos D1 mini, NodeMCU (ESP8266) | 2 | LOW accende (logica invertita) |
| ESP32 (con DOIT ESP32 DEVKIT V1 selezionata) | 2 | HIGH accende |
| ESP32 Dev Module | Può non essere definita | Definiscila tu: const int LED_PIN = 2; |
| ESP32-S3-DevKitC | RGB_BUILTIN (GPIO 48) | Colore con rgbLedWrite() o neopixelWrite() |
| Raspberry Pi Pico (core Arduino) | 25 | HIGH accende |
| Raspberry Pi Pico W (core Arduino) | Pin virtuale speciale | Basta scrivere LED_BUILTIN |
Cosa ti dice ogni LED? Tabella dei sintomi
| Sintomo | Significato probabile | Cosa fare |
|---|---|---|
| Il LED L di Arduino lampeggia una volta al secondo | È caricato il Blink di fabbrica | Normale; smette quando carichi il tuo codice |
| L lampeggia veloce qualche volta dopo il reset | Parte il bootloader, poi il tuo codice | Normale |
| L lampeggia veloce senza sosta, il codice non parte | La scheda si resetta di continuo | Controlla alimentazione e cortocircuiti, ricarica il codice |
| L acceso debole o acceso da solo | D13 flottante, ingresso del buffer scollegato | Normale; se vuoi imposta D13 come OUTPUT a LOW |
| Il LED ON non si accende | Niente alimentazione, cavo difettoso o fusibile intervenuto | Prova un altro cavo e un'altra porta, elimina il corto, aspetta qualche minuto |
| TX/RX non lampeggiano mai durante il caricamento | Porta, driver o scheda sbagliati | Scegli la porta e la scheda giuste, installa il driver CH340 |
| Il LED blu dell'ESP32 resta acceso | Lo sketch ha lasciato il GPIO 2 a HIGH | Controlla il GPIO 2 nel codice |
| Il LED blu dell'ESP32 lampeggia veloce e irregolare | La scheda si riavvia di continuo o c'è un programma di prova | Leggi l'errore nel Monitor seriale, migliora l'alimentazione |
| Il LED blu dell'ESP32 non si accende mai | Manca il LED utente o il codice pilota un altro pin | Controlla il numero del pin o collega un LED esterno |
| Il LED rosso dell'ESP32 sfarfalla | Alimentazione insufficiente (la tensione cala quando trasmette il Wi-Fi) | Usa un buon cavo e un alimentatore da 5 V di almeno 1 A |
| Sul Pico non si accende nessun LED | Il Pico non ha LED di alimentazione e nessun programma gira | Normale; con BOOTSEL controlla se compare l'unità RPI-RP2 |
Usare il LED integrato nei tuoi progetti
- Codici di errore: Fai lampeggiare il LED due volte se un sensore non risponde e tre volte se manca il Wi-Fi, poi fai una pausa; capisci il problema senza aprire il Monitor seriale.
- Battito: Dai un breve lampo ogni pochi secondi finché il programma funziona bene; se il LED si ferma, sai che il codice si è bloccato da qualche parte.
- Segnale di evento: Fai lampeggiare il LED una volta quando arriva un messaggio MQTT o una richiesta web; il debug dei web server su ESP32 diventa molto più semplice.
- Effetto respiro: Su ESP32 e Pico accendi e spegni dolcemente il LED integrato con il PWM; sull'Uno non funziona perché D13 non ha il PWM. Dettagli in Cos'è il PWM?.
- Progetti a batteria: In un dispositivo con deep sleep spegni sempre il LED integrato prima di dormire; in ESP32 Deep Sleep trovi come scendere a pochi µA.
- Passare a un LED esterno: Per un indicatore più luminoso o di un altro colore, aggiungi un LED con la sua resistenza come in Cos'è un LED?.
I LED integrati sono il primo strumento di diagnosi in elettronica, e il più economico: rispondono in pochi secondi a "c'è alimentazione?", "passano i dati?" e "il programma sta girando?". Se vuoi fare il primo passo, nell'app BlueGrays trovi i progetti Accendere un LED con Arduino, LED integrato dell'ESP32 e LED integrato del Raspberry Pi Pico, con schemi di collegamento e codice passo passo.
Domande frequenti
Cosa significa il LED blu dell'ESP32?
Sull'ESP32 DevKit V1 e sulle schede simili il LED blu è un LED utente collegato al GPIO 2: lo accende o lo spegne solo il codice che carichi. Il LED che indica l'alimentazione è quello rosso. Non tutte le schede ESP32 hanno il LED blu; la DevKitC di Espressif ha solo il LED di alimentazione.
Perché il LED blu dell'ESP32 resta sempre acceso?
Di solito sulla scheda c'è uno sketch che mette il GPIO 2 a HIGH. Anche un modulo collegato al GPIO 2 può tirare su il pin e accendere il LED. Metti il GPIO 2 a LOW nel codice o sposta il circuito su un altro pin; un LED blu acceso di per sé non è un guasto.
Perché il LED blu dell'ESP32 lampeggia?
Se il tuo sketch non fa lampeggiare il GPIO 2, un lampeggio veloce e irregolare di solito indica un ciclo di riavvii, spesso per un'alimentazione debole o un crash. Apri il Monitor seriale a 115200 baud e cerca messaggi di brownout o Guru Meditation. Un lampeggio regolare su una scheda nuova è quasi sempre il programma di prova del venditore.
Qual è il pin di LED_BUILTIN sull'ESP32?
Nella definizione di scheda DOIT ESP32 DEVKIT V1, LED_BUILTIN è il GPIO 2. Con ESP32 Dev Module selezionato la costante può mancare e il compilatore dà errore; basta scrivere const int LED_PIN = 2; nel codice. Sulle schede ESP32-S3 per il LED RGB si usa RGB_BUILTIN.
Perché il LED integrato del Raspberry Pi Pico W non si accende?
Sul Pico W il LED è collegato al chip Wi-Fi e non al microcontrollore, quindi non si comanda con Pin(25). In MicroPython scrivi Pin("LED", Pin.OUT) e usa il firmware MicroPython preparato per il Pico W.
Perché il LED L di Arduino lampeggia da solo?
Le schede nuove di solito arrivano con lo sketch Blink già caricato, quindi L lampeggia una volta al secondo. I lampi veloci dopo un reset sono del bootloader. Se D13 non è usato, L può restare acceso debolmente, e con un modulo SPI collegato può sfarfallare; è tutto normale.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Lampeggio del LED interno dell'ESP32
Far lampeggiare il LED blu integrato nell'ESP32 DevKit V1. Non sono necessari componenti esterni! Il primo progetto da provare quando si acquista un ESP32. Il GPIO 2 è collegato al LED interno.

Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
Il progetto d'apertura della serie Raspberry Pi Pico! Facciamo lampeggiare il LED verde integrato del Pico per verificare che la scheda funzioni: il classico primo esperimento in stile "Hello World". Niente componenti esterni, bastano il Pico e un cavo USB. Il codice è scritto in MicroPython, il linguaggio supportato ufficialmente dalla Raspberry Pi Foundation.

LED lampeggiante
Il primissimo ciao dell'elettronica: accendere e spegnere un solo LED. L'Arduino accende e spegne il LED a intervalli brevissimi, così la luce lampeggia veloce.

LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Accensione di un LED esterno con Raspberry Pi Pico (breadboard)
Il passo successivo al LED integrato del Pico: collegare un LED esterno sulla breadboard e controllarlo dal pin GP14. Impari a usare qualsiasi pin GPIO del Pico come uscita, la polarità del LED (gamba lunga = anodo/+, gamba corta = catodo/–) e perché una resistenza di limitazione della corrente (220Ω) è indispensabile. Senza di essa nel LED passa troppa corrente e può bruciarsi.

Accendere un LED con un pulsante (Push)
Come un campanello: la luce resta accesa finché premi e si spegne quando lasci. L'Arduino ascolta il pulsante di continuo; mentre è premuto accende il LED, e appena togli il dito lo spegne.

Controllo LED ESP32 con pulsante (Push)
Il LED si accende quando il pulsante viene premuto e si spegne quando viene rilasciato. Mostra come vengono utilizzati il pin di ingresso digitale dell'ESP32 e la resistenza di pull-up interna. Grazie alla modalità INPUT_PULLUP, non è necessaria alcuna resistenza esterna.

Semaforo ESP32
Simulazione di un vero semaforo con 3 LED rosso-giallo-verde. I tempi si avvicinano alla logica del traffico reale: rosso lungo, giallo corto, verde lungo. Classico esempio di controllo GPIO sequenziale.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

