Wemos D1 mini pinout: D0–D8 e GPIO, pin A0, shield e deep sleep
Pinout del Wemos D1 mini (ESP8266): corrispondenza D0–D8 e GPIO, pin critici all'avvio, limite di 3,2 V su A0, shield relè, DHT e OLED e deep sleep con D0–RST.
Il Wemos D1 mini porta il chip Wi-Fi ESP8266 su una schedina di 34 × 26 mm che si programma direttamente via USB e si espande con shield impilabili: per questo è una delle mini schede di sviluppo più diffuse in assoluto. È piccolo, economico e compatibile con l'Arduino IDE, quindi è la prima scelta per sensori Wi-Fi, prese smart e controller per strisce LED. Il problema è che le sigle D0–D8 stampate sulla scheda non sono i numeri GPIO, e alcuni pin, se usati male, impediscono alla scheda perfino di avviarsi: per questo la prima cosa da avere sotto mano è il pinout del Wemos D1 mini.
In questa guida trovi tutto il pinout del Wemos D1 mini in un'unica tabella, con il GPIO di ogni pin. Con codice di esempio vediamo quali pin sono critici all'avvio (boot), perché l'ingresso analogico A0 si ferma a 3,2 V, quali pin usano gli shield relè, DHT e OLED e perché per il deep sleep bisogna collegare D0 a RST. Alla fine diamo un'occhiata veloce ai fratelli con ESP32.

Cos'è il Wemos D1 mini? Caratteristiche tecniche
Il D1 mini è stato progettato da Wemos (oggi LOLIN) e, visto che lo schema è aperto, è stato clonato da moltissimi produttori. Nel modulo ESP-12 con schermatura metallica ci sono il processore ESP8266EX e 4 MB di flash; sulla scheda trovi in più un convertitore USB-seriale, un regolatore che porta i 5 V a 3,3 V e il pulsante RESET. Le versioni più diffuse sono la v3 con micro-USB e la v4 con USB-C; la disposizione dei pin è la stessa su tutte.
| Caratteristica | Valore |
|---|---|
| Chip | ESP8266EX, 32 bit, 80/160 MHz |
| Flash | 4 MB (D1 mini Pro: 16 MB) |
| RAM | 80 KB di memoria dati (circa 40–50 KB liberi con il Wi-Fi attivo) |
| Wi-Fi | 802.11 b/g/n, solo 2,4 GHz |
| Pin digitali | 11 (D0–D8, TX, RX) |
| Ingresso analogico | 1 (A0, 0–3,2 V, 10 bit) |
| Livello logico | 3,3 V (alimentazione da USB o dal pin 5V) |
| Chip USB-seriale | Quasi sempre CH340 |
| Dimensioni | 34,2 × 25,6 mm |
Pinout del Wemos D1 mini: D0–D8 e i GPIO corrispondenti
L'errore più comune è scrivere nel codice la sigla della scheda come se fosse un numero. Se nell'Arduino IDE scrivi pinMode(4, OUTPUT), la scheda non usa D4 ma il GPIO 4, cioè D2. Nel codice usa le costanti come D4 (sono definite se hai selezionato la scheda D1 mini) oppure il numero GPIO della tabella. Puoi vedere la mappa della tua scheda anche con lo strumento Pinout.
| Sigla | GPIO | Funzione speciale | Note d'uso |
|---|---|---|---|
| TX | GPIO 1 | UART TX (Monitor seriale) | All'avvio invia dati; lascialo libero se usi Serial |
| RX | GPIO 3 | UART RX | HIGH all'avvio; lascialo libero se usi Serial |
| D0 | GPIO 16 | Risveglio dal deep sleep (collegato a RST) | Niente PWM, interrupt né I2C; HIGH all'avvio |
| D1 | GPIO 5 | I2C SCL | Sicuro; pin predefinito dello shield relè |
| D2 | GPIO 4 | I2C SDA | Sicuro |
| D3 | GPIO 0 | FLASH, pull-up da 10 kΩ | Se è LOW all'avvio, la scheda entra in modalità programmazione |
| D4 | GPIO 2 | LED integrato (logica invertita), pull-up da 10 kΩ | Se è LOW all'avvio, la scheda non parte; pin dello shield DHT |
| D5 | GPIO 14 | SPI SCK | Sicuro |
| D6 | GPIO 12 | SPI MISO | Sicuro |
| D7 | GPIO 13 | SPI MOSI | Sicuro |
| D8 | GPIO 15 | SPI CS, pull-down da 10 kΩ | Se è HIGH all'avvio, la scheda non parte; CS dello shield SD |
| A0 | ADC0 | Ingresso analogico | 0–3,2 V; partitore 220 kΩ / 100 kΩ sulla scheda |
| RST | - | Reset (attivo LOW) | Si collega a D0 per il deep sleep |
| 3V3 | - | Uscita 3,3 V | Alimenta da qui i sensori |
| 5V | - | 5 V dell'USB / ingresso 5 V esterno | Con l'USB collegato è un'uscita, altrimenti un ingresso di alimentazione |
| G | - | GND | Massa comune |
In breve, i pin che puoi usare tranquillamente per qualsiasi cosa sono D1, D2, D5, D6 e D7. D0 va bene per uscite semplici e per il risveglio dal deep sleep, ma non ha PWM né interrupt. D3 e D4 vanno bene per pulsanti (purché non siano premuti all'avvio) e LED. Tutti i pin tranne D0 hanno una resistenza di pull-up interna (INPUT_PULLUP); D0 ha solo un pull-down interno. Con la versione 3.x del core ESP8266, analogWrite() lavora di default su 0–255 a 1 kHz. Ogni pin eroga al massimo circa 12 mA, quindi per relè, motori o strisce LED lunghe usa un transistor o un driver.
Installare il Wemos D1 mini nell'Arduino IDE
- In File > Impostazioni aggiungi http://arduino.esp8266.com/stable/package_esp8266com_index.json nel campo "URL aggiuntive per il Gestore schede"; se ci sono altri indirizzi, separali con una virgola.
- Cerca esp8266 nel Gestore schede e installa il pacchetto di ESP8266 Community.
- Scegli LOLIN(WEMOS) D1 R2 & mini in Strumenti > Scheda > ESP8266 Boards.
- Se la porta non compare, installa il driver CH340 e usa un cavo USB dati, non uno solo di ricarica.
- Se il caricamento a 921600 fallisce, abbassa Upload Speed a 115200.
Primo sketch: far lampeggiare il LED integrato
Il piccolo LED blu sul modulo ESP-12 è collegato al GPIO 2 (D4) e funziona a logica invertita: si accende quando il pin è LOW e si spegne quando è HIGH. LED_BUILTIN per il D1 mini vale 2, quindi il codice qui sotto funziona senza modifiche:
1// D1 mini dahili LED: D4 = GPIO 2, LOW'da yanar / onboard LED: D4 = GPIO 2, lights on LOW
2void setup() {
3 pinMode(LED_BUILTIN, OUTPUT); // LED_BUILTIN = 2 (D4)
4}
5
6void loop() {
7 digitalWrite(LED_BUILTIN, LOW); // LED yanar (ters mantık) / LED on (inverted logic)
8 delay(500);
9 digitalWrite(LED_BUILTIN, HIGH); // LED söner / LED off
10 delay(500);
11}L'ingresso analogico A0: il limite di 3,2 V e la misura di tensione
L'unico convertitore analogico-digitale (ADC) dell'ESP8266 in realtà misura solo 0–1,0 V con 10 bit (0–1023). Il D1 mini mette dietro il pin A0 un partitore di tensione da 220 kΩ e 100 kΩ: all'ADC arriva Vin × 100 / (220 + 100), quindi 3,2 V su A0 arrivano al chip come 1,0 V. Per questo la formula per convertire il valore grezzo in volt è V = grezzo × 3,2 / 1023. Per misurare tensioni più alte aggiungi una resistenza in serie prima di A0: con altri 100 kΩ il ramo superiore del partitore diventa 320 kΩ e il fondo scala sale a 1,0 × (320 + 100) / 100 = 4,2 V, proprio la tensione di una cella agli ioni di litio carica. Puoi calcolare altri rapporti con lo strumento Partitore di tensione.
| Tensione su A0 | Arriva al chip | analogRead() (circa) |
|---|---|---|
| 0 V | 0 V | 0 |
| 1,0 V | 0,31 V | 320 |
| 1,65 V | 0,52 V | 527 |
| 3,2 V | 1,0 V | 1023 |
| 3,3 V | 1,03 V | 1023 (saturo) |
1// A0: kartta 220k/100k bölücü, 0–3,2 V → 0–1023 / on-board 220k/100k divider, 0–3.2 V → 0–1023
2const float FULL_SCALE = 3.2; // ek 100 kΩ seri dirençle 4.2 olur / 4.2 with an extra 100 kΩ in series
3
4void setup() {
5 Serial.begin(115200);
6}
7
8void loop() {
9 long sum = 0;
10 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 readings
11 sum += analogRead(A0);
12 delay(10); // Wi-Fi'ye zaman bırak / leave time for Wi-Fi
13 }
14 float raw = sum / 16.0;
15 float volts = raw * FULL_SCALE / 1023.0;
16 Serial.print("A0 ham / raw: ");
17 Serial.print(raw, 0);
18 Serial.print(" gerilim / voltage: ");
19 Serial.print(volts, 2);
20 Serial.println(" V");
21 delay(1000);
22}Gli shield del Wemos D1 mini: relè, DHT, OLED e altri
Il punto forte del D1 mini sono gli shield dello stesso formato, che grazie ai connettori femmina si innestano direttamente sopra o sotto la scheda. Niente saldature né cavetti; però, visto che ogni shield usa un pin fisso, devi controllare che gli shield impilati non condividano pin. Ecco i più comuni e i pin che usano:
| Shield | Pin usato | Nota |
|---|---|---|
| Shield relè | D1 (GPIO 5) | Contatti di solito da 10 A / 250 V AC; va in conflitto con l'SCL dell'I2C |
| Shield DHT (DHT11 o DHT22 Pro) | D4 (GPIO 2) | Stesso pin del LED integrato; il sensore risente del calore della scheda |
| Shield SHT30 | D1, D2 (I2C) | Più preciso di un DHT; indirizzo I2C 0x45 |
| Shield OLED 0,66" | D1 (SCL), D2 (SDA) | 64×48 pixel, driver SSD1306, indirizzo 0x3C |
| Shield Micro SD | D5, D6, D7, D8 (CS) | SPI; D8 deve restare LOW all'avvio |
| Shield batteria | Nessun pin | Ricarica una LiPo e alimenta la scheda dal pin 5V |
La tabella mostra la trappola principale: lo shield relè usa di default D1, che è anche la linea di clock dell'I2C. Se impili il relè con lo shield OLED o SHT30, nessuno dei due funziona bene. Alcune versioni dello shield relè permettono di cambiare pin con un ponticello a saldare sul retro; se la tua no, collega il relè con un cavetto a uno dei pin D5–D7. Se innesti lo shield DHT direttamente sulla scheda, il calore dell'ESP8266 gli fa segnare 1–3 °C in più; allontana il sensore con una base doppia (dual base) o un cavo corto. Il codice seguente usa insieme lo shield DHT e lo shield relè come semplice termostato per una ventola:
1#include <DHT.h>
2
3const uint8_t DHT_PIN = 2; // D4 = GPIO 2 (DHT shield)
4const uint8_t RELAY_PIN = 5; // D1 = GPIO 5 (röle shield / relay shield)
5const float ON_ABOVE = 28.0; // bunun üstünde fan açılır / fan on above this
6const float OFF_BELOW = 26.5; // bunun altında kapanır (histerezis) / off below this (hysteresis)
7
8DHT dht(DHT_PIN, DHT11); // DHT Pro shield için DHT22 / DHT22 for the DHT Pro shield
9bool fanOn = false;
10
11void setup() {
12 Serial.begin(115200);
13 pinMode(RELAY_PIN, OUTPUT);
14 digitalWrite(RELAY_PIN, LOW); // röle kapalı başlasın / start with the relay off
15 dht.begin();
16}
17
18void loop() {
19 float t = dht.readTemperature();
20 if (!isnan(t)) { // hatalı ölçümü atla / skip failed readings
21 if (!fanOn && t > ON_ABOVE) fanOn = true;
22 if (fanOn && t < OFF_BELOW) fanOn = false;
23 digitalWrite(RELAY_PIN, fanOn ? HIGH : LOW); // HIGH = röle çeker / HIGH = relay on
24 Serial.print(t, 1);
25 Serial.println(fanOn ? " C fan ON" : " C fan OFF");
26 }
27 delay(2000);
28}Le due soglie nel codice (accensione a 28 °C, spegnimento a 26,5 °C) creano un'isteresi: con una sola soglia il relè scatterebbe ogni secondo mentre la temperatura oscilla tra 28,0 e 28,1, consumando relè e ventola. Per collegare un relè in sicurezza leggi Cos'è un modulo relè?. Lo shield OLED è un minuscolo display SSD1306 da 64×48 pixel; la libreria standard Adafruit SSD1306 non supporta questa dimensione, quindi la strada più semplice è la libreria U8g2. L'esempio mostra la tensione su A0 come numero e come barra:
1#include <Wire.h>
2#include <U8g2lib.h>
3
4// 0,66" OLED shield: 64×48, I2C D1 (SCL) / D2 (SDA) / 0.66" OLED shield: 64×48, I2C on D1/D2
5U8G2_SSD1306_64X48_ER_F_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
6
7void setup() {
8 oled.begin();
9}
10
11void loop() {
12 float volts = analogRead(A0) * 3.2 / 1023.0; // A0 → volt
13 oled.clearBuffer();
14 oled.setFont(u8g2_font_6x10_tf);
15 oled.drawStr(0, 10, "D1 mini");
16 oled.setCursor(0, 28);
17 oled.print(volts, 2);
18 oled.print(" V");
19 oled.drawFrame(0, 36, 64, 10); // çubuk çerçevesi / bar frame
20 oled.drawBox(2, 38, (int)(volts / 3.2 * 60), 6); // gerilim çubuğu / voltage bar
21 oled.sendBuffer();
22 delay(500);
23}Deep sleep: il ponticello D0–RST e il funzionamento a batteria
In deep sleep l'ESP8266 spegne completamente processore e Wi-Fi; resta acceso solo il suo timer RTC interno. Allo scadere del tempo, l'RTC porta per un attimo il GPIO 16 (D0) a LOW. Se D0 è collegato al pin RST, questo impulso resetta il chip e il codice riparte da setup(). Senza il ponticello la scheda non si risveglia mai. Visto che il risveglio è un riavvio, le variabili normali si perdono; i dati piccoli, come un contatore di letture, puoi salvarli nei 512 byte di memoria utente dell'RTC. Un singolo sonno dura al massimo circa 3,5 ore; per pause più lunghe rimetti a dormire la scheda più volte di seguito.
| Stato | Assorbimento indicativo |
|---|---|
| Invio dati via Wi-Fi | 70–170 mA |
| Wi-Fi connesso, a riposo (modem sleep) | 15–20 mA |
| Light sleep | Circa 1 mA |
| Deep sleep (solo il chip ESP8266) | Circa 20 µA |
| Deep sleep (intera scheda D1 mini) | 80–200 µA (per il regolatore e il chip USB-seriale) |
1// D0 (GPIO 16) ile RST arasına kablo tak / wire D0 (GPIO 16) to RST
2const uint64_t SLEEP_US = 10ULL * 60 * 1000000; // 10 dakika, mikrosaniye / 10 minutes in µs
3
4void setup() {
5 Serial.begin(115200);
6 delay(100);
7 float volts = analogRead(A0) * 3.2 / 1023.0; // ölç / measure
8 Serial.print("A0: ");
9 Serial.print(volts, 2);
10 Serial.println(" V");
11 // Wi-Fi ile gönderim burada yapılır / send the reading over Wi-Fi here
12 Serial.println("10 dk uyku / sleeping 10 min");
13 ESP.deepSleep(SLEEP_US); // uyanınca setup() baştan başlar / wakes up into setup()
14}
15
16void loop() {
17 // buraya hiç gelinmez / never reached
18}L'autonomia si stima con un calcolo veloce. Supponiamo che la scheda si svegli ogni 10 minuti, assorba in media 80 mA per 5 secondi mentre invia i dati e dorma a 0,15 mA per i restanti 595 secondi. Ogni ciclo consuma 5 × 80 = 400 mAs più 595 × 0,15 ≈ 89 mAs; in totale 489 mAs, cioè una media di 0,82 mA su 600 secondi. Una batteria 18650 da 2000 mAh dura quindi 2000 / 0,82 ≈ 2440 ore, circa 100 giorni. Fai il conto con i tuoi valori nello strumento Durata della batteria, e trovi l'equivalente per l'ESP32 in ESP32 Deep Sleep.
Wemos D1 mini, NodeMCU o D1 mini ESP32?
| Scheda | Chip | Punto di forza | Quando sceglierla? |
|---|---|---|---|
| Wemos D1 mini | ESP8266 | Piccolissima, sistema di shield | Piccoli sensori Wi-Fi, progetti con shield |
| NodeMCU V3 | ESP8266 | Più grande, pin serigrafati | Prototipi comodi su breadboard |
| D1 mini ESP32 (MiniKit) | ESP32-WROOM-32 | Piedinatura D1 mini + fila interna aggiuntiva | Bluetooth, più canali ADC e più memoria |
| LOLIN S2 mini / C3 mini | ESP32-S2 / ESP32-C3 | Formato D1 mini, compatibile con gli shield | USB nativa (S2), BLE e bassi consumi (C3) |
Sulle schede D1 mini ESP32 le file di pin esterne corrispondono agli shield del D1 mini, quindi puoi innestare così come sono lo shield relè o OLED. Sull'ESP32 però le sigle D corrispondono ad altri GPIO; i pin I2C, per esempio, sono D1 = GPIO 22 e D2 = GPIO 21. Nel codice usa WiFi.h al posto di ESP8266WiFi.h e adatta i numeri dei pin alla mappa della scheda. La versione ESP32 legge gli ingressi analogici a 12 bit (0–4095), ha il Bluetooth e molta più memoria. Se non sai quale scegliere, confronta Cos'è l'ESP32? con NodeMCU ESP8266.
Idee di progetto con il Wemos D1 mini
- Termometro Wi-Fi a batteria: Con uno shield SHT30 o DHT, lo shield batteria e il deep sleep, invia una lettura ogni 10 minuti.
- Presa smart: Accendi una lampada dal telefono con lo shield relè; per un cablaggio sicuro leggi la guida al modulo relè.
- Controller per strisce LED: Installa WLED e comanda una striscia WS2812B dal telefono.
- Sensore porta: Invia una notifica quando la porta si apre con un reed switch.
- Mini display da scrivania: Mostra ora, meteo o piccoli grafici sullo shield OLED, come su un display OLED più grande.
- Sensore per la casa smart: Invia i valori a Home Assistant via MQTT.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| La porta non compare | Manca il driver CH340 o il cavo è solo di ricarica | Installa il driver, usa un cavo dati |
| Risponde il pin sbagliato | Nel codice c'è 4 invece di D4 | Usa le costanti D o il GPIO della tabella |
| La scheda non si avvia, il codice non parte | Un circuito su D3, D4 o D8 altera il livello di avvio | Sposta il circuito su pin sicuri (D1, D2, D5–D7) |
| Il Wi-Fi cade spesso | analogRead() chiamato senza pause o alimentazione debole | Metti una pausa tra le letture, usa un buon alimentatore da 5 V |
| Non si risveglia dal deep sleep | D0 non è collegato a RST | Collega D0 a RST con un filo, una resistenza o un diodo |
| Relè e OLED insieme non funzionano | Usano entrambi D1 | Cambia il pin del relè o collegalo con un cavetto a un altro pin |
| Il LED funziona al contrario | Il LED integrato si accende con LOW | Inverti la logica: LOW = acceso, HIGH = spento |
Con le sue dimensioni minime, il sistema di shield e il Wi-Fi, il Wemos D1 mini è uno degli ingressi più facili alla domotica e ai progetti con sensori. Se tieni a mente la tabella dei pin e le regole di avvio, quasi ogni esempio per ESP8266 funziona al primo colpo. Nell'app BlueGrays trovi schemi e codice passo passo nei progetti ESP (LED lampeggiante, connessione Wi-Fi, web server, OTA e deep sleep), e puoi provarli anche sul D1 mini adattando i numeri dei pin con questa tabella.
Domande frequenti
A quale GPIO corrisponde D4 sul Wemos D1 mini?
D4 corrisponde al GPIO 2, a cui è collegato anche il LED blu integrato. Nel codice puoi scrivere pinMode(D4, OUTPUT) oppure pinMode(2, OUTPUT), mentre pinMode(4, OUTPUT) seleziona D2. Il LED funziona a logica invertita, quindi si accende con LOW.
Il Wemos D1 mini funziona a 5 V?
Sì, la scheda si può alimentare a 5 V dall'USB o dal pin 5V; il regolatore a bordo li porta a 3,3 V. I pin GPIO però lavorano con logica a 3,3 V: i sensori con uscita a 5 V vanno collegati tramite un partitore di tensione o un convertitore di livello.
Quanti volt legge il pin A0 del Wemos D1 mini?
Grazie al partitore da 220 kΩ / 100 kΩ sulla scheda, il pin A0 legge 0–3,2 V come 0–1023. Il chip ESP8266 da solo misura appena 0–1,0 V. Aggiungendo una resistenza da 100 kΩ in serie prima di A0 la portata sale a 4,2 V, sufficiente per leggere una batteria agli ioni di litio.
Perché il Wemos D1 mini non si risveglia dal deep sleep?
Per svegliarsi l'ESP8266 ha bisogno dell'impulso di reset che l'RTC invia su D0 (GPIO 16). Se non colleghi D0 a RST con un filo, una resistenza da 470 Ω–1 kΩ o un diodo Schottky, la scheda resta addormentata. Controlla anche di aver indicato il tempo in microsecondi.
Che differenza c'è tra Wemos D1 mini e NodeMCU?
Entrambi usano lo stesso chip ESP8266 e le sigle D0–D8 corrispondono agli stessi GPIO, quindi gli sketch funzionano senza modifiche. Il D1 mini è molto più piccolo e supporta gli shield impilabili, mentre il NodeMCU è più grande e più comodo su breadboard.
Il Wemos D1 mini ha il Bluetooth?
No, l'ESP8266 supporta solo il Wi-Fi. Se ti serve il Bluetooth usa un D1 mini ESP32 o la LOLIN C3 mini con ESP32-C3, che hanno lo stesso formato e funzionano anche con gli shield del D1 mini.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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.

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.

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

Aggiornamento OTA dell'ESP32 — Installazione wireless del firmware (con display LCD)
Imparerai a caricare un nuovo firmware sull'ESP32 via Wi-Fi, senza cavo USB. Con la libreria ArduinoOTA l'ESP32 diventa visibile in rete e compare automaticamente come bluegrays-ota nella scheda "Network port" dell'Arduino IDE. Il primo caricamento avviene via USB, poi tutti gli aggiornamenti sono wireless: una funzione fondamentale per i dispositivi installati sul campo.

ESP32 mDNS: accesso al dispositivo tramite bluegrays-esp.local (con schermo LCD)
Aggiungiamo all'ESP32 un servizio mDNS (Multicast DNS), così lo raggiungi con un nome host leggibile come bluegrays-esp.local invece che con un indirizzo IP. Anche se l'IP assegnato dal DHCP cambia, il dispositivo risponde sempre allo stesso nome. Un piccolo server web sulla scheda ti permette di controllare il LED dal browser all'indirizzo http://bluegrays-esp.local/.

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.
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

