Progetti ESP8266: 15 idee Wi-Fi con NodeMCU e Wemos D1 mini
15 progetti ESP8266: relè Wi-Fi, stazione meteo, Alexa, WLED, Tasmota, sensore in deep sleep; limiti dell'ESP8266, quando passare all'ESP32 e due sketch pronti.
I progetti ESP8266 sfruttano il Wi-Fi integrato di questa scheda economica per accendere una lampada dal telefono, inviare la lettura di un sensore su internet o controllare una striscia LED dalla rete di casa. Tutto vale anche per il Wemos D1 mini, che monta lo stesso chip; le due schede si differenziano solo per dimensioni e per alcuni dettagli hardware. L'ESP8266 vive all'ombra dell'ESP32, ma per un solo relè, un solo sensore o un piccolo strumento di misura a batteria resta una delle opzioni più economiche e affidabili. L'importante è sapere fin dall'inizio dove basta e dove va in affanno.
In questa guida abbiamo raccolto 15 progetti, dal più facile al più difficile, in un'unica tabella con componenti, software usato e la risposta alla domanda: l'ESP8266 basta? Poi spieghiamo uno per uno progetti come il relè Wi-Fi, il controllo con Alexa, WLED, Tasmota, ESPHome e il sensore a batteria, e ti diamo due sketch pronti: un pannello relè da aprire sul telefono e un sensore che misura e va in deep sleep. Se usi la scheda per la prima volta, configurala prima con la guida NodeMCU ESP8266; per i dettagli dei pin consulta la guida alla piedinatura del Wemos D1 mini.

NodeMCU e Wemos D1 mini: stesso chip, due schede diverse
Entrambe le schede montano il chip ESP8266EX a 80 MHz (160 MHz se vuoi) con 4 MB di flash, ed entrambe si programmano con lo stesso codice nell'Arduino IDE. La NodeMCU è più grande, ha le etichette dei pin ben leggibili e sulla breadboard lascia una fila di fori libera su ogni lato: comoda per le prime prove. Il Wemos D1 mini è grande la metà e, con i suoi shield impilabili (relè, DHT, OLED, batteria), ti permette di costruire un dispositivo definitivo quasi senza saldare. In un progetto a batteria vince il D1 mini, perché la scheda assorbe meno in deep sleep. Se scrivi i pin con le etichette della scheda, come D1 e D2, lo stesso programma gira su entrambe senza modifiche.
| Caratteristica | NodeMCU V3 | Wemos D1 mini |
|---|---|---|
| Chip | ESP8266EX (modulo ESP-12E/F) | ESP8266EX |
| Dimensioni | Circa 58 × 31 mm | 34,2 × 25,6 mm |
| Pin utilizzabili | D0–D8, RX, TX, A0 | D0–D8, RX, TX, A0 |
| Chip USB-seriale | CH340 o CP2102 | Quasi sempre CH340 |
| Ingresso analogico | A0, 0–3,2 V sulla scheda | A0, 0–3,2 V sulla scheda |
| Corrente della scheda in deep sleep | Più alta per regolatore e chip USB | Circa 80–200 µA |
| Sistema di shield | Nessuno | Shield relè, DHT, SHT30, OLED, SD, batteria |
| Ideale per | Prove su breadboard, apprendimento | Piccoli dispositivi in scatola, sensori a batteria |
I limiti dell'ESP8266: un pin analogico, 3,3 V e memoria
- Un solo ingresso analogico: l'ESP8266 ha solo A0. Il chip misura 0–1 V e il partitore 220 kΩ / 100 kΩ della scheda estende la gamma a 0–3,2 V. Per un secondo sensore analogico serve un ADC I2C come l'ADS1115 oppure un ESP32. Per altre gamme di tensione usa lo strumento partitore di tensione.
- Logica a 3,3 V: ufficialmente i pin non tollerano i 5 V e non dovrebbero fornire più di circa 12 mA ciascuno. Abbassa il segnale dei sensori a 5 V come l'HC-SR04 con un partitore o un traslatore di livello.
- Memoria limitata: con il Wi-Fi connesso restano al programma circa 40–50 KB di RAM. Qualche richiesta HTTPS e una risposta JSON grande la riempiono in fretta.
- Un solo core e watchdog: Wi-Fi e codice condividono un core. Un ciclo di alcuni secondi dentro loop() o una lunga catena di delay() fa scattare il watchdog e la scheda si riavvia; inserisci yield() o brevi delay() nelle operazioni lunghe.
- Pin di avvio: D3 (GPIO 0) e D4 (GPIO 2) devono essere HIGH all'avvio e D8 (GPIO 15) LOW. Un pulsante o un modulo su questi pin può impedire l'avvio; i pin sicuri sono D1, D2, D5, D6 e D7.
- Niente Bluetooth: l'ESP8266 non ha hardware Bluetooth. Per parlare con il telefono via Bluetooth o leggere sensori BLE serve un ESP32.
| Di cosa hai bisogno | Basta l'ESP8266? | Perché |
|---|---|---|
| Dispositivo Wi-Fi con un relè o un sensore | Sì | La soluzione più economica e collaudata per questo tipo di lavoro |
| Sensore a batteria che invia ogni tanto | Sì | Con il deep sleep un D1 mini può durare mesi |
| Più sensori analogici | Con un ADC esterno | C'è un solo A0; l'ESP32 ha 18 canali analogici |
| Bluetooth o BLE | No | Manca l'hardware; usa un ESP32 |
| Fotocamera | No | Niente interfaccia camera né PSRAM; usa un ESP32-CAM |
| Molte richieste HTTPS, JSON grandi | Al limite | La RAM può non bastare; i 520 KB dell'ESP32 danno margine |
| Più di qualche centinaio di LED indirizzabili | Al limite | WLED consiglia un ESP32 per strisce lunghe e più uscite |
| Pin touch, molti canali PWM, dual core | No | Queste funzioni esistono solo sull'ESP32 |
15 progetti NodeMCU ed ESP8266 in una tabella
| # | Progetto | Componenti | Software / libreria | Livello |
|---|---|---|---|---|
| 1 | Pannello relè Wi-Fi | Modulo relè | ESP8266WebServer | Facile |
| 2 | Dimmer per striscia LED dal telefono | Striscia LED 12 V, MOSFET logic-level | ESP8266WebServer, analogWrite | Facile |
| 3 | Lampada a comando vocale con Alexa | Modulo relè | Espalexa | Medio |
| 4 | Sensore porta con notifiche Telegram | Reed switch, magnete | UniversalTelegramBot | Medio |
| 5 | LED indirizzabili (WLED) | Striscia WS2812B, alimentatore 5 V | WLED (firmware pronto) | Facile |
| 6 | Presa smart con Tasmota | Modulo relè | Tasmota (firmware pronto) | Facile |
| 7 | Sensore di temperatura ESPHome | DHT22 o BME280 | ESPHome | Facile |
| 8 | Stazione meteo con pagina web | BME280 | ESP8266WebServer, Adafruit BME280 | Medio |
| 9 | Sensore a batteria con deep sleep | DHT22, cella 18650 | ESP8266HTTPClient, ThingSpeak | Medio |
| 10 | Umidità del terreno e avviso di irrigazione | Sensore capacitivo di umidità del terreno | analogRead, Telegram o web | Facile |
| 11 | Orologio sincronizzato da internet | TM1637 o OLED | NTP (configTime) | Facile |
| 12 | Display meteo o tassi di cambio | OLED da 0,96 pollici | ESP8266HTTPClient, ArduinoJson | Medio |
| 13 | Telecomando IR universale Wi-Fi | LED IR, transistor, ricevitore IR | IRremoteESP8266 | Medio |
| 14 | Pulsante wireless ESP-NOW | Pulsante, secondo ESP8266 o ESP32 | espnow.h | Medio |
| 15 | Dispositivo Home Assistant via MQTT | Relè, sensore | PubSubClient | Medio |
Questi 15 punti sono idee di progetto realmente costruite e funzionanti con l'ESP8266; per ognuna indichiamo componenti e libreria necessari. I progetti Wi-Fi dell'app BlueGrays sono scritti per l'ESP32, ma insegnano gli stessi argomenti: puoi portare sull'ESP8266 il circuito e la logica di ESP32 Connessione Wi-Fi STA, ESP32 Async Web Server, ESP32 mDNS, ESP32 Ora reale da internet con NTP e ESP32 Aggiornamento OTA; nel codice cambiano i nomi delle librerie (per esempio ESP8266WiFi.h al posto di WiFi.h) e i numeri dei pin.
Progetti di controllo Wi-Fi (1–4): relè, dimmer, Alexa e Telegram
Il progetto 1 è la base della lista: la NodeMCU serve una propria pagina web, i cui pulsanti ON e OFF attivano o rilasciano il relè. Il codice qui sotto rende la scheda raggiungibile anche come role.local tramite mDNS, così nel browser del telefono scrivi sempre lo stesso indirizzo anche se l'IP cambia (alcune versioni di Android non risolvono i nomi .local; in quel caso usa l'IP). L'indirizzo /state restituisce lo stato del relè come testo semplice, che un altro dispositivo o un'automazione possono interrogare. Il progetto 2 aggiunge allo stesso server un cursore di luminosità: piloti una striscia LED monocolore a 12 V tramite un MOSFET logic-level come l'IRLZ44N, e l'uscita analogWrite() dell'ESP8266 regola la luminosità da 0 a 255.
| Collegamento | NodeMCU / D1 mini | Nota |
|---|---|---|
| IN del modulo relè | D1 (GPIO 5) | Sicuro all'avvio; sui moduli attivi LOW il codice lo attiva con LOW |
| VCC del modulo relè | VIN (5 V da USB) | La bobina del relè richiede 5 V |
| GND del modulo relè | GND | Massa comune |
| Lampada (lato 230 V) | Morsetti COM e NO del relè | Solo se hai esperienza e dentro una scatola chiusa |
1// NodeMCU / Wemos D1 mini: telefondan Wi-Fi röle (web panel + mDNS)
2// NodeMCU / Wemos D1 mini: Wi-Fi relay from your phone (web panel + mDNS)
3#include <ESP8266WiFi.h>
4#include <ESP8266WebServer.h>
5#include <ESP8266mDNS.h>
6
7const char* WIFI_SSID = "WIFI_ADIN"; // Wi-Fi adı / Wi-Fi name
8const char* WIFI_PASS = "WIFI_SIFRESI"; // Wi-Fi şifresi / Wi-Fi password
9
10#define RELAY_PIN D1 // GPIO 5, açılışta güvenli / GPIO 5, safe at boot
11#define RELAY_ON LOW // çoğu röle modülü LOW ile çeker / most relay modules are active LOW
12#define RELAY_OFF HIGH
13
14ESP8266WebServer server(80);
15bool relayState = false;
16
17void setRelay(bool on) {
18 relayState = on;
19 digitalWrite(RELAY_PIN, on ? RELAY_ON : RELAY_OFF);
20}
21
22void handleRoot() {
23 String html = F("<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width,initial-scale=1'>"
24 "<title>Role</title><style>body{font-family:sans-serif;text-align:center;margin-top:40px}"
25 "a{display:inline-block;padding:18px 34px;margin:8px;border-radius:10px;color:#fff;text-decoration:none;font-size:22px}"
26 ".on{background:#2e7d32}.off{background:#c62828}</style></head><body><h2>Role / Relay: ");
27 html += relayState ? "ON" : "OFF";
28 html += F("</h2><a class='on' href='/on'>ON</a><a class='off' href='/off'>OFF</a></body></html>");
29 server.send(200, "text/html", html);
30}
31
32void redirectHome() {
33 server.sendHeader("Location", "/"); // yenileyince komut tekrarlanmasın / avoid repeating on refresh
34 server.send(303);
35}
36
37void setup() {
38 Serial.begin(115200);
39 pinMode(RELAY_PIN, OUTPUT);
40 setRelay(false); // açılışta kapalı / off at power-up
41
42 WiFi.mode(WIFI_STA);
43 WiFi.begin(WIFI_SSID, WIFI_PASS);
44 Serial.print("Wi-Fi");
45 while (WiFi.status() != WL_CONNECTED) {
46 delay(500);
47 Serial.print(".");
48 }
49 Serial.println();
50 Serial.print("IP: ");
51 Serial.println(WiFi.localIP());
52
53 if (MDNS.begin("role")) Serial.println("http://role.local"); // ad ile erişim / access by name
54
55 server.on("/", handleRoot);
56 server.on("/on", []() { setRelay(true); redirectHome(); });
57 server.on("/off", []() { setRelay(false); redirectHome(); });
58 server.on("/state", []() { server.send(200, "text/plain", relayState ? "ON" : "OFF"); });
59 server.begin();
60}
61
62void loop() {
63 server.handleClient();
64 MDNS.update(); // ESP8266'da mDNS için gerekli / required for mDNS on ESP8266
65}Nel codice ci sono tre punti da notare. Il primo è la definizione RELAY_ON: la maggior parte dei moduli relè in commercio si attiva quando l'ingresso è LOW, quindi il valore predefinito è LOW; se il tuo modulo si attiva con HIGH, scambia le due righe. Secondo, setup() spegne prima il relè, così la lampada non si accende da sola quando torna la corrente dopo un blackout. Terzo, dopo /on e /off il browser viene reindirizzato alla pagina principale con il codice 303, quindi ricaricando la pagina lo stesso comando non viene inviato di nuovo. Sull'ESP8266 l'mDNS richiede la chiamata MDNS.update() dentro loop(); sull'ESP32 questa riga non serve.
Nel progetto 3 la libreria Espalexa fa sembrare la NodeMCU una lampadina smart riconosciuta da Alexa: dici "Alexa, accendi la lampada del soggiorno" e il relè scatta. Non servono altri account cloud né skill, ma Echo e scheda devono essere sulla stessa rete locale. Per Google Home entra in gioco un servizio cloud come Sinric Pro; le due strade sono confrontate nell'articolo ESP32 con Alexa e Google Home, ed entrambe le librerie supportano l'ESP8266. Nel progetto 4 monti un reed switch e un magnete su una porta; quando si apre, la NodeMCU ti invia un messaggio con un bot Telegram. Poiché Telegram usa HTTPS, la memoria è la risorsa più sotto pressione dell'ESP8266 in questo progetto; inviare messaggi non è un problema, ma non provare a servire contemporaneamente una pagina web pesante.
Progetti con firmware pronto (5–7): WLED, Tasmota ed ESPHome
Alcuni progetti non richiedono codice. Nel progetto 5 installi il firmware WLED dal browser e controlli una striscia WS2812B dall'app con centinaia di effetti, palette di colori e timer. Sull'ESP8266 WLED funziona bene fino a qualche centinaio di LED; per strisce più lunghe e più uscite si consiglia un ESP32. Collega la linea dati con una resistenza da 330 Ω e alimenta la striscia con un alimentatore 5 V separato, non attraverso la scheda (installare WLED). Nel progetto 6 Tasmota trasforma la NodeMCU in una presa smart con interfaccia web, timer, regole e MQTT; Tasmota è nato proprio per le prese smart basate su ESP8266. Nel progetto 7 scrivi poche righe di YAML in ESPHome e il sensore compare da solo in Home Assistant; per l'ESP8266 il nome della scheda è nodemcuv2 o d1_mini (installare ESPHome).
Progetti con sensori e misure (8–12)
Nel progetto 8 un sensore BME280 si collega a D1 (SCL) e D2 (SDA); temperatura, umidità e pressione si aggiornano ogni pochi secondi su una pagina web servita dalla NodeMCU. Alimenta il BME280 a 3,3 V e controlla con uno scanner I2C se il suo indirizzo è 0x76 o 0x77. Il progetto 9 è il più istruttivo della lista: la scheda si sveglia, legge il DHT22, invia i valori a ThingSpeak e va in deep sleep per 10 minuti. Perché l'ESP8266 possa svegliarsi dal deep sleep, D0 (GPIO 16) deve essere collegato a RST; allo scadere del tempo D0 dà un breve impulso LOW e la scheda riparte. Togli questo filo durante il caricamento, altrimenti la scheda può resettarsi da sola a metà.
1// NodeMCU + DHT22: ölç, ThingSpeak'e gönder, 10 dakika derin uyku
2// NodeMCU + DHT22: measure, send to ThingSpeak, deep sleep for 10 minutes
3// ÖNEMLİ: D0 (GPIO 16) ile RST'yi bir kabloyla bağla; yüklerken bu kabloyu çıkar
4// IMPORTANT: wire D0 (GPIO 16) to RST; remove the wire while uploading
5#include <ESP8266WiFi.h>
6#include <ESP8266HTTPClient.h>
7#include <DHT.h>
8
9const char* WIFI_SSID = "WIFI_ADIN";
10const char* WIFI_PASS = "WIFI_SIFRESI";
11const char* TS_WRITE_KEY = "WRITE_API_KEY"; // ThingSpeak kanal anahtarı / channel write key
12
13#define DHT_PIN D2 // GPIO 4
14#define SLEEP_MINUTES 10
15
16DHT dht(DHT_PIN, DHT22);
17
18void sleepNow() {
19 Serial.println("Uyku / Sleep");
20 ESP.deepSleep((uint64_t)SLEEP_MINUTES * 60ULL * 1000000ULL); // D0 -> RST darbesiyle uyanır / wakes via D0 -> RST
21}
22
23void setup() {
24 Serial.begin(115200);
25 dht.begin();
26 delay(2000); // DHT22 ilk ölçüm için hazırlansın / let the DHT22 settle
27
28 float t = dht.readTemperature();
29 float h = dht.readHumidity();
30 if (isnan(t) || isnan(h)) {
31 Serial.println("DHT okunamadi / DHT read failed");
32 sleepNow();
33 }
34
35 WiFi.mode(WIFI_STA);
36 WiFi.begin(WIFI_SSID, WIFI_PASS);
37 unsigned long t0 = millis();
38 while (WiFi.status() != WL_CONNECTED) {
39 if (millis() - t0 > 15000) sleepNow(); // 15 sn'de bağlanamazsa pili koru / give up after 15 s
40 delay(200);
41 }
42
43 WiFiClient client;
44 HTTPClient http;
45 String url = String("http://api.thingspeak.com/update?api_key=") + TS_WRITE_KEY +
46 "&field1=" + String(t, 1) + "&field2=" + String(h, 1) + "&field3=" + String(WiFi.RSSI());
47 if (http.begin(client, url)) {
48 int code = http.GET();
49 Serial.printf("HTTP %d, yanit / reply: %s\n", code, http.getString().c_str()); // 0 = reddedildi / 0 = rejected
50 http.end();
51 }
52 sleepNow();
53}
54
55void loop() {} // uyanınca setup() baştan çalışır / setup() runs again after each wakePrendiamo il D1 mini come esempio per il calcolo della batteria: ogni 10 minuti la scheda resta sveglia circa 4 secondi assorbendo in media 80 mA e passa i restanti 596 secondi a dormire a 0,15 mA. Un ciclo consuma 4 × 80 = 320 mAs e 596 × 0,15 ≈ 89 mAs; diviso per 600 secondi, la corrente media è di circa 0,68 mA e una cella 18650 da 2000 mAh dura sulla carta più di 120 giorni. Se il Wi-Fi non si collega entro 15 secondi, il codice torna a dormire senza inviare, così la batteria non si consuma quando il router è spento. ThingSpeak richiede almeno 15 secondi tra un invio e l'altro e risponde 0 alle richieste che non rispettano la regola. Per calcolare con i tuoi valori usa il calcolatore di durata della batteria.
Il progetto 10 è quello che si adatta meglio all'unico pin analogico: colleghi un sensore capacitivo di umidità del terreno ad A0 e, quando la terra si asciuga, compare un avviso sulla pagina web o su Telegram. Alimentato a 3,3 V, il sensore resta nella gamma 0–3,2 V di A0; annota i valori con terra asciutta e bagnata e metti la soglia a metà (sensore capacitivo di umidità del terreno). Nel progetto 11 prendi l'ora da internet con configTime() e la mostri su un TM1637 o un OLED; se imposti correttamente il fuso orario, anche il passaggio all'ora legale avviene da solo. Il progetto 12 scarica JSON da un servizio meteo o di cambio valuta e lo scrive sull'OLED. Sull'ESP8266 valgono due regole: scegli un'API con risposte leggere e usa un filtro di ArduinoJson per decodificare solo i campi che ti servono.
Progetti di comunicazione (13–15): telecomando IR, ESP-NOW e MQTT
Nel progetto 13 la libreria IRremoteESP8266, come dice il nome, è stata scritta per l'ESP8266 e conosce centinaia di protocolli di telecomandi di condizionatori, TV e proiettori. Prima leggi i codici del tuo telecomando con un ricevitore IR, poi invii gli stessi codici con un LED IR pilotato da un transistor; i pulsanti di una pagina web o Home Assistant controllano i tuoi apparecchi. Nel progetto 14 ESP-NOW trasporta messaggi direttamente tra due schede senza mai passare dal router: un pulsante a batteria in giardino avvisa la NodeMCU in casa in pochi millisecondi. ESP8266 ed ESP32 possono anche parlarsi tra loro via ESP-NOW (ESP-NOW). Il progetto 15 mette insieme tutto: una NodeMCU che si collega a MQTT con PubSubClient presenta relè e sensore a Home Assistant (il codice dell'articolo ESP32, MQTT e Home Assistant funziona anche sull'ESP8266 con piccole modifiche).
Errori comuni nei progetti NodeMCU e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| La scheda si riavvia ogni pochi secondi, wdt reset nel monitor seriale | Un ciclo lungo dentro loop() non lascia tempo al Wi-Fi | Aggiungi yield() o delay(1) nei cicli lunghi ed evita attese bloccanti |
| La scheda non si sveglia mai dal deep sleep | Manca il filo tra D0 e RST | Collega D0 a RST; toglilo durante il caricamento |
| La scheda non si avvia con un pulsante o un modulo collegato | D3, D4 o D8 al livello sbagliato all'avvio | Sposta quel componente su D1, D2, D5, D6 o D7 |
| Il relè non si rilascia mai | Un modulo a 5 V non considera spento il segnale HIGH a 3,3 V | Usa un modulo con comando a 3 V, un driver a transistor o lo shield relè |
| A0 segna sempre 1023 | La tensione in ingresso supera 3,2 V | Allarga la gamma con una resistenza in serie calcolata con lo strumento partitore |
| La richiesta HTTPS si blocca con errore di memoria | Connessione TLS e risposta grande riempiono la RAM | Scegli un'API con risposte più leggere, usa un filtro ArduinoJson o passa all'ESP32 |
Da quale progetto NodeMCU iniziare?
- Provi il Wi-Fi per la prima volta: costruisci il pannello del progetto 1 prima con un LED; quando funziona, aggiungi il relè.
- Vuoi risultati senza codice: installa WLED o Tasmota, poi prova a ottenere lo stesso con il tuo codice.
- Hai Home Assistant in casa: parti dal progetto 7 con ESPHome, poi scrivi tu l'MQTT nel progetto 15.
- Vuoi un dispositivo a batteria: usa un D1 mini per il progetto 9; la sua corrente in sleep è molto più bassa di quella della NodeMCU.
- Ti servono più sensori analogici, una fotocamera o il Bluetooth: passa all'ESP32 senza perdere tempo; la tabella sopra mostra dove l'ESP8266 si blocca.
Usato nel progetto giusto, l'ESP8266 resta una delle schede Wi-Fi con cui si arriva prima al risultato: per un relè, un sensore o una striscia LED non serve altro. Passare all'ESP32 quando i progetti crescono è facile, perché la logica di Wi-Fi, server web, NTP e MQTT è quasi identica sulle due schede. Nell'app BlueGrays trovi progetti ESP32 come la connessione Wi-Fi, un server web, mDNS, un orologio NTP, un'API meteo e gli aggiornamenti OTA, ognuno con schema del circuito, elenco dei componenti e codice pronto, e puoi applicare ciò che impari ai tuoi progetti con NodeMCU.
Domande frequenti
Cosa si può fare con un ESP8266?
Con un ESP8266 o una NodeMCU puoi realizzare un relè Wi-Fi controllato dal telefono, una lampada compatibile con Alexa, una striscia LED indirizzabile con WLED, una presa smart con Tasmota, una stazione meteo che invia dati su internet e un sensore a batteria. Grazie al Wi-Fi integrato non servono moduli aggiuntivi e la scheda si programma con l'Arduino IDE.
Che differenza c'è tra NodeMCU e Wemos D1 mini?
Entrambe usano lo stesso chip ESP8266 e lo stesso codice. La NodeMCU è più grande e comoda per le prove su breadboard; il Wemos D1 mini è grande la metà, ha shield impilabili e assorbe meno in deep sleep, quindi è migliore per i progetti a batteria.
Meglio ESP8266 o ESP32?
Per un relè, un sensore o un semplice dispositivo Wi-Fi a batteria l'ESP8266 basta e costa meno. Se ti servono più sensori analogici, Bluetooth, una fotocamera, molte richieste HTTPS o strisce LED lunghe, scegli l'ESP32.
L'ESP8266 tollera i 5 V?
Ufficialmente no: i pin funzionano a 3,3 V. Puoi alimentare un sensore a 5 V, ma non collegare il suo segnale di uscita direttamente a un pin dell'ESP8266; usa un partitore di tensione o un traslatore di livello.
Perché il mio ESP8266 non si sveglia dal deep sleep?
Perché l'ESP8266 si svegli con il timer, D0 (GPIO 16) deve essere collegato al pin RST; allo scadere del tempo D0 dà un breve impulso che resetta la scheda. Senza questo filo la scheda resta addormentata. Toglierlo durante il caricamento evita problemi di upload.
Quanti sensori analogici si possono collegare alla NodeMCU?
Direttamente solo uno, perché l'ESP8266 ha un unico ingresso analogico (A0), che sulla scheda misura 0–3,2 V. Per più sensori analogici puoi aggiungere un modulo ADC I2C come l'ADS1115 oppure passare all'ESP32, che ha molti ingressi analogici.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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 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/.

ESP32: ora reale da Internet tramite NTP
L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

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 HTTPClient + API meteo (con schermo LCD)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. La risposta JSON viene analizzata con ArduinoJson v7 e città, temperatura, umidità, condizioni meteo e vento compaiono su un display LCD I2C. wttr.in non richiede una chiave API: basta scrivere il nome di una città qualsiasi.

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.

Illuminazione automatica con sensore di movimento PIR ESP32
Un sensore di movimento PIR HC-SR501 rileva chi entra nella stanza e accende un LED in automatico. millis() misura quanto resta acceso: ogni lettura HIGH aggiorna l'ora dell'ultimo movimento e il LED si spegne almeno 10 secondi dopo l'ultimo HIGH. Il codice attende anche 50 ms con delay(50) a ogni ciclo, quindi il loop non è del tutto non bloccante. Ideale per scale, corridoi, bagni o l'interno degli armadi.
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

