Guide · 10 min di lettura

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.

Scheda di sviluppo ESP32 e i suoi LED integrati
Scheda ESP32 DevKit: il LED rosso indica l'alimentazione a 3,3 V e quello blu lo stato del GPIO 2; accanto ci sono i pulsanti EN e BOOT.

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:

SchedaLEDCollegato aSignificato
Arduino Uno R3ON (verde)Linea 5 VLa scheda è alimentata
Arduino Uno R3L (giallo/arancione)D13 (tramite un buffer con amplificatore operazionale)LED comandato dal codice; dopo un reset lo fa lampeggiare anche il bootloader
Arduino Uno R3TX / RX (gialli)Chip USB-seriale (ATmega16U2)Scambio di dati con il PC; lampeggiano veloci durante il caricamento
Arduino Nano / MegaPOW o ON, L, TX, RX5 V, D13, chip USB-serialeStesso significato dell'Uno
ESP32 DevKit V1LED rossoLinea 3,3 VLa scheda è alimentata; non si spegne da codice
ESP32 DevKit V1LED bluGPIO 2LED comandato dal codice
ESP32-DevKitC (Espressif)LED rossoLinea 3,3 VSolo alimentazione; niente LED utente
ESP32-S3-DevKitCLED RGB (WS2812)GPIO 48 (38 in alcune revisioni)Colore a scelta da codice
ESP32-CAMLED rosso / flash biancoGPIO 33 / GPIO 4LED di stato (acceso con LOW) / flash della fotocamera
Wemos D1 mini, NodeMCULED bluGPIO 2 (D4)LED utente; acceso con LOW
Raspberry Pi PicoLED verdeGP25LED comandato dal codice; niente LED di alimentazione
Raspberry Pi Pico WLED verdeChip 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.
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}
Se la luce debole di L ti dà fastidio, basta scrivere pinMode(13, OUTPUT); digitalWrite(13, LOW); in setup(). Sulle schede più vecchie (Uno precedenti alla R3 e molte Nano) il LED L è collegato direttamente a D13 con una resistenza; su queste schede usare D13 come ingresso per un pulsante con INPUT_PULLUP non è affidabile, perché il LED tira il pin verso il basso. Se colleghi un LED esterno, calcola la resistenza con lo strumento Resistenza per LED.

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.

Il GPIO 2 è uno dei pin di strapping (avvio) dell'ESP32: perché la scheda entri in modalità programmazione e riceva il codice, il GPIO 2 deve essere LOW o scollegato. Il LED integrato con la sua resistenza lo tiene già basso, ma se colleghi un modulo con pull-up o un sensore che porta il GPIO 2 a HIGH, il caricamento può fallire con "Failed to connect" o "Wrong boot mode detected". Usa il GPIO 2 per il LED e per uscite semplici, e collega gli ingressi ad altri 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():

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}

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.

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}

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:

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

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

SchedaLED_BUILTINNota
Arduino Uno, Nano, Mega, Leonardo, Uno R413HIGH accende
Wemos D1 mini, NodeMCU (ESP8266)2LOW accende (logica invertita)
ESP32 (con DOIT ESP32 DEVKIT V1 selezionata)2HIGH accende
ESP32 Dev ModulePuò non essere definitaDefiniscila tu: const int LED_PIN = 2;
ESP32-S3-DevKitCRGB_BUILTIN (GPIO 48)Colore con rgbLedWrite() o neopixelWrite()
Raspberry Pi Pico (core Arduino)25HIGH accende
Raspberry Pi Pico W (core Arduino)Pin virtuale specialeBasta scrivere LED_BUILTIN

Cosa ti dice ogni LED? Tabella dei sintomi

SintomoSignificato probabileCosa fare
Il LED L di Arduino lampeggia una volta al secondoÈ caricato il Blink di fabbricaNormale; smette quando carichi il tuo codice
L lampeggia veloce qualche volta dopo il resetParte il bootloader, poi il tuo codiceNormale
L lampeggia veloce senza sosta, il codice non parteLa scheda si resetta di continuoControlla alimentazione e cortocircuiti, ricarica il codice
L acceso debole o acceso da soloD13 flottante, ingresso del buffer scollegatoNormale; se vuoi imposta D13 come OUTPUT a LOW
Il LED ON non si accendeNiente alimentazione, cavo difettoso o fusibile intervenutoProva un altro cavo e un'altra porta, elimina il corto, aspetta qualche minuto
TX/RX non lampeggiano mai durante il caricamentoPorta, driver o scheda sbagliatiScegli la porta e la scheda giuste, installa il driver CH340
Il LED blu dell'ESP32 resta accesoLo sketch ha lasciato il GPIO 2 a HIGHControlla il GPIO 2 nel codice
Il LED blu dell'ESP32 lampeggia veloce e irregolareLa scheda si riavvia di continuo o c'è un programma di provaLeggi l'errore nel Monitor seriale, migliora l'alimentazione
Il LED blu dell'ESP32 non si accende maiManca il LED utente o il codice pilota un altro pinControlla il numero del pin o collega un LED esterno
Il LED rosso dell'ESP32 sfarfallaAlimentazione 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 LEDIl Pico non ha LED di alimentazione e nessun programma giraNormale; 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?.
Il LED di alimentazione sembra piccolo, ma nei progetti a batteria può essere il consumo più grande con 1–5 mA. In un circuito che in sleep assorbe pochi microampere, togliere la resistenza del LED di alimentazione può allungare la durata della batteria da settimane a mesi; è un trucco molto usato nei progetti a batteria con l'Arduino Pro Mini.

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.

Vedi tutti i progetti
Lampeggio del LED interno dell'ESP32
ES-4Principiante

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.

4.8(29)
54
Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
PI-1Principiante

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.

5.0(1)
10
LED lampeggiante
AR-1Principiante

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.

4.6(200)
1245
LED Lampeggiante con ESP32
ES-1Principiante

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.

4.7(37)
108
Accensione di un LED esterno con Raspberry Pi Pico (breadboard)
PI-2Principiante

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.

4.5(2)
7
Accendere un LED con un pulsante (Push)
AR-9Principiante

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.

4.8(114)
253
Controllo LED ESP32 con pulsante (Push)
ES-2Principiante

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.

4.6(36)
57
Semaforo ESP32
ES-5Principiante

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.

4.4(22)
45