ArduinoEmbedded & IoT

ESP32: guida introduttiva, scelta della scheda e primo progetto Wi-Fi con Arduino IDE

Famiglia ESP32, S3, C3 e C6, scelta della scheda di sviluppo, pin da evitare, installazione del core 3.x in Arduino IDE 2.x e un web server che comanda un LED e legge sensori.

L’ESP32 è una famiglia di microcontrollori prodotta da Espressif che integra nello stesso chip una CPU a 32 bit, la radio Wi-Fi e, a seconda del modello, Bluetooth Low Energy e IEEE 802.15.4 (Thread e Zigbee). Una scheda di sviluppo costa pochi euro, si programma con lo stesso Arduino IDE usato per la UNO e permette di realizzare in un pomeriggio un dispositivo che si collega alla rete di casa, pubblica una pagina web e comanda uscite o legge sensori. Per molti progetti IoT semplici, come un sensore di temperatura, un comando a distanza o un contatore, è una soluzione più adatta di un computer a scheda singola: non c’è un sistema operativo da aggiornare, si avvia in una frazione di secondo e può funzionare per mesi a batteria.

In questa guida si parte dalla famiglia di chip attuale (ESP32 classico, S3, C3, C6, H2 e P4) e dai criteri per scegliere la scheda di sviluppo, si analizzano le differenze pratiche rispetto ad Arduino UNO, che sono la causa della maggior parte dei malfunzionamenti dei principianti, e si installa il core arduino-esp32 3.x in Arduino IDE 2.x. Si arriva poi a un progetto completo: un piccolo web server che accende un LED e legge un pulsante e un potenziometro, seguito da un esempio di deep sleep per l’uso a batteria e da una rassegna degli errori più comuni.

Perché l’ESP32 per i progetti IoT

Un microcontrollore e un computer a scheda singola come il Raspberry Pi risolvono problemi diversi. Il Raspberry Pi esegue Linux, ha gigabyte di RAM ed è adatto a server, interfacce grafiche ed elaborazioni pesanti. L’ESP32 esegue un solo programma, scritto in C/C++ o MicroPython, con qualche centinaio di kilobyte di RAM: ha però il Wi-Fi integrato, consuma decine di milliampere in funzionamento e pochi microampere in deep sleep, e non ha una scheda SD che può corrompersi in caso di mancanza di alimentazione.

Nel 2026 anche la questione economica si è fatta sentire. Raspberry Pi ha annunciato a febbraio aumenti di prezzo per i modelli con 2 GB o più di memoria, motivati dal forte rincaro delle memorie LPDDR4 (da +10 a +60 dollari secondo il taglio di RAM), e a ottobre un ulteriore rincaro dei modelli da 2 GB, con il Raspberry Pi 5 2 GB portato a 77,50 dollari (fonti in fondo all’articolo). Per un dispositivo che deve solo leggere un sensore e inviare un dato in rete, una scheda ESP32 è quindi spesso la scelta più sensata, mentre il Raspberry Pi resta lo strumento giusto quando servono Linux, un database locale o un’interfaccia grafica. Chi conosce già la Raspberry Pi Pico troverà nell’ESP32 un concetto simile, con in più la radio integrata su tutti i modelli più diffusi.

La famiglia ESP32 oggi

Con il nome “ESP32” si indicano ormai molti chip diversi. Il capostipite (2016) usa core Xtensa LX6; i modelli successivi si dividono tra la serie S (Xtensa LX7, più prestazioni e USB) e le serie C e H basate su core RISC-V. La tabella riassume i dati principali tratti dai datasheet Espressif.

SoC CPU SRAM Radio GPIO ADC Note
ESP32 Xtensa LX6, 2 core, 240 MHz 520 KB Wi-Fi 802.11b/g/n, Bluetooth 4.2 BR/EDR + BLE 34 (6 solo ingresso) 2 × SAR 12 bit, 18 canali 2 DAC a 8 bit, unico con Bluetooth Classic
ESP32-S3 Xtensa LX7, 2 core, 240 MHz 512 KB Wi-Fi 802.11b/g/n, Bluetooth 5 (LE) 45 2 × SAR 12 bit, 20 canali USB OTG e USB Serial/JTAG, PSRAM opzionale
ESP32-C3 RISC-V, 1 core, 160 MHz 400 KB Wi-Fi 802.11b/g/n, Bluetooth 5 (LE) 22 2 × SAR 12 bit, 6 canali USB Serial/JTAG, molto economico
ESP32-C6 RISC-V 160 MHz + core LP 20 MHz 512 KB Wi-Fi 6 (802.11ax) 2,4 GHz, BLE 5.3, 802.15.4 30 (QFN40) SAR 12 bit, 7 canali Thread 1.3 e Zigbee 3.0
ESP32-H2 RISC-V, 96 MHz 320 KB BLE 5.3 e 802.15.4, niente Wi-Fi 19 SAR 12 bit, 5 canali Nodi Thread/Zigbee/Matter a basso consumo
ESP32-P4 RISC-V, 2 core, 400 MHz + core LP 40 MHz 768 KB nessuna radio integrata 55 2 ADC (8 + 6 canali) USB 2.0 high-speed, MIPI CSI/DSI, Ethernet MAC

Per iniziare con il Wi-Fi i candidati sono tre. L’ESP32 classico è il più documentato: quasi tutti gli esempi in rete sono scritti per lui ed è l’unico con Bluetooth Classic, utile per esempio per l’audio A2DP. L’ESP32-S3 è la scelta per progetti più pesanti (display, telecamere, riconoscimento vocale) e per chi vuole la USB nativa con funzioni di tastiera o mouse. L’ESP32-C3 è il più economico e compatto, adatto a sensori e comandi semplici. Il C6 aggiunge Wi-Fi 6 e la radio 802.15.4, mentre H2 e P4 sono chip specializzati: il primo per le reti Thread/Zigbee senza Wi-Fi, il secondo per applicazioni multimediali che richiedono un chip radio esterno. Tutti sono supportati dal core Arduino 3.x.

Come scegliere la scheda di sviluppo

Il chip da solo non si usa: si acquista una scheda di sviluppo che contiene il modulo (chip, memoria flash, quarzo e antenna sotto uno schermo metallico), il regolatore a 3,3 V, i pulsanti EN (reset) e BOOT e il connettore USB. Le schede ufficiali Espressif hanno il suffisso DevKitC; in commercio si trovano anche moltissimi cloni con piedinature diverse, per cui conviene sempre fare riferimento alla serigrafia della propria scheda.

Confronto illustrato tra le schede ESP32-DevKitC V4, ESP32-S3-DevKitC-1, ESP32-C3 SuperMini ed ESP32-C6-DevKitC-1 con tipo di porta USB e caratteristiche principali

USB tramite bridge o USB nativa

La differenza pratica più importante tra le schede riguarda il collegamento USB. L’ESP32 classico non ha una periferica USB: la scheda monta un bridge USB-UART (tipicamente Silicon Labs CP210x o WCH CH340) che converte la USB del PC nella seriale UART0 del chip e, tramite le linee DTR e RTS, comanda automaticamente EN e GPIO0 per entrare in modalità di programmazione. Sul PC compare come porta seriale (/dev/ttyUSB0 su Linux, una porta COM su Windows) e richiede eventualmente il driver del convertitore.

S3, C3 e C6 integrano invece una USB nativa (USB Serial/JTAG, e sull’S3 anche USB OTG): la scheda può fare a meno del bridge, come la C3 SuperMini, oppure offrire entrambe le porte, come le S3- e C6-DevKitC-1. La USB nativa non richiede driver, compare come /dev/ttyACM0 su Linux e permette anche il debug JTAG; in compenso, se lo sketch si blocca o va in deep sleep, la porta scompare e per ricaricare il programma bisogna forzare manualmente la modalità download (vedi gli errori comuni). Per chi inizia, una scheda con bridge USB-UART è la più tollerante agli errori; una scheda con le due porte offre il meglio di entrambe.

Le schede consigliate per iniziare

  • ESP32-DevKitC V4 (o un buon clone a 38 pin): ESP32 classico, modulo WROOM-32, bridge USB-UART. È la scheda a cui si riferiscono la piedinatura e gli esempi di questa guida.
  • ESP32-S3-DevKitC-1: due porte USB (bridge e nativa) e LED RGB indirizzabile su GPIO38 nella revisione 1.1 (GPIO48 nella prima versione). Nelle varianti con PSRAM ottale i GPIO35–37 sono riservati.
  • ESP32-C3 SuperMini: scheda non ufficiale molto diffusa, minuscola, solo USB-C nativa, LED su GPIO8. Nel core Arduino ha una definizione dedicata (“Nologo ESP32C3 Super Mini”).
  • ESP32-C6-DevKitC-1: due porte USB-C e LED RGB su GPIO8, per chi vuole sperimentare Wi-Fi 6, Thread o Zigbee.

Differenze pratiche rispetto ad Arduino UNO

Chi arriva dalla programmazione di Arduino UNO ritrova le stesse funzioni (pinMode(), digitalWrite(), analogRead()), ma l’hardware sottostante è molto diverso. Le differenze seguenti spiegano la maggior parte dei problemi che si incontrano nelle prime prove.

Aspetto Arduino UNO R3 ESP32 (DevKitC)
Tensione dei GPIO 5 V 3,3 V, ingressi non tolleranti a 5 V
Corrente dei GPIO 20 mA consigliati per pin 40 mA (source) e 28 mA (sink) tipici a massima forza di pilotaggio: limiti, non valori di lavoro
Pin con vincoli D0/D1 per la seriale strapping (0, 2, 5, 12, 15), solo ingresso (34–39), flash (6–11), UART0 (1, 3)
ADC 10 bit, 0–5 V, buona linearità 12 bit, fondo scala con attenuatore, non lineare agli estremi; ADC2 non usabile con Wi-Fi
PWM analogWrite() su 6 pin periferica LEDC su quasi tutti i GPIO di uscita
Tipo int 16 bit 32 bit

Livelli a 3,3 V e corrente dei GPIO

Il chip si alimenta a 3,3 V e i suoi ingressi accettano al massimo la tensione di alimentazione più 0,3 V. Un sensore o un modulo che emette segnali a 5 V va collegato con un partitore resistivo o un traslatore di livello; molti moduli “per Arduino” funzionano anche a 3,3 V, ma va verificato sul datasheet. Per la corrente, il datasheet indica 40 mA erogati con uscita ad almeno 2,64 V e 28 mA assorbiti con uscita a 0,495 V, misurati con la massima forza di pilotaggio: sono valori caratteristici, non correnti da usare in progetto. Un LED si accende bene con 2–5 mA; per relè, motori e carichi più impegnativi si usa un transistor come interruttore.

Pin di strapping, pin solo ingresso e pin della flash

All’accensione e a ogni reset il chip legge il livello di alcuni pin, detti di strapping, per decidere come avviarsi. Sull’ESP32 classico sono cinque: GPIO0 (pull-up interno; se è basso al reset il chip entra in modalità download invece di eseguire il programma), GPIO2 (pull-down; deve essere basso o flottante per la programmazione seriale), GPIO12 (MTDI: se è alto all’avvio imposta a 1,8 V la tensione della flash, e con i moduli a 3,3 V il chip non si avvia), GPIO15 (MTDO, abilita i messaggi di boot sulla seriale) e GPIO5 (temporizzazione SDIO). Questi pin si possono usare dopo l’avvio, ma non vanno collegati a circuiti che ne forzano il livello al momento del reset, come un pull-up esterno su GPIO12 o un pulsante su GPIO0 premuto all’accensione.

I GPIO34–39 sono solo ingresso e non hanno resistenze di pull-up o pull-down interne: vanno benissimo per segnali analogici o digitali già definiti, ma un pulsante richiede un pull-up esterno. I GPIO6–11 sono collegati internamente alla memoria flash SPI del modulo e non vanno mai usati; GPIO1 e GPIO3 sono la UART0 usata per il caricamento e il monitor seriale. Sui chip più recenti cambiano i numeri ma non il principio: gli strapping sono GPIO0, 3, 45 e 46 sull’S3, GPIO2, 8 e 9 sul C3, GPIO8, 9 e 15 più MTMS e MTDI sul C6.

Piedinatura semplificata della ESP32-DevKitC V4 con i GPIO liberi, i pin di strapping, i pin solo ingresso, i pin della flash e i canali ADC1 e ADC2

ADC: attenuazione, non linearità e conflitto con il Wi-Fi

L’ADC dell’ESP32 ha un riferimento interno di circa 1,1 V; per misurare tensioni più alte si usa un attenuatore programmabile. Con l’attenuazione di 11 dB, la predefinita nel core Arduino, l’intervallo misurabile dichiarato dalla documentazione Arduino-ESP32 va da circa 150 mV a 3100 mV: sotto e sopra questi valori la lettura si appiattisce, e anche all’interno la risposta non è perfettamente lineare. Il datasheet, più prudente, garantisce l’accuratezza con calibrazione (±60 mV) solo tra 150 mV e 2450 mV. Inoltre, secondo le FAQ Espressif, senza calibrazione la differenza tra un chip e l’altro può arrivare a ±6%. Per questo nel core 3.x conviene usare analogReadMilliVolts(), che restituisce un valore in millivolt corretto con i dati di calibrazione memorizzati nel chip, invece del valore grezzo di analogRead().

Il secondo vincolo è più subdolo: sull’ESP32 classico il convertitore ADC2 è usato anche dal driver Wi-Fi, che ha la priorità. Con il Wi-Fi attivo i pin ADC2 (GPIO0, 2, 4, 12–15, 25–27) non forniscono letture valide. Nei progetti in rete gli ingressi analogici vanno quindi presi tra i pin ADC1: GPIO32–39. Per le basi su campionamento e risoluzione si veda la guida su ingressi analogici e uscite PWM con Arduino.

Esempio di calcolo: risoluzione teorica dell'ADC a 12 bit con attenuazione 11 dB

  passo = fondo scala utile / (2^12 - 1)
        = 3100 mV / 4095
        ≈ 0,76 mV per conteggio

  In pratica l'accuratezza è limitata dalla non linearità e dalla
  dispersione tra chip, non dalla risoluzione: per misure precise
  si usa un ADC esterno (es. su bus I2C).

Installare il core arduino-esp32 in Arduino IDE 2.x

Il supporto ESP32 per l’IDE Arduino è sviluppato direttamente da Espressif (progetto arduino-esp32). La serie 3.x, basata su ESP-IDF 5 (la 3.3.12 usa ESP-IDF 5.5), supporta ESP32, S2, S3, C3, C5, C6, H2 e P4; al momento della stesura la versione stabile è la 3.3.12. Rispetto alla 2.x alcune API sono cambiate, in particolare quelle del PWM (LEDC): ledcSetup() e ledcAttachPin() sono state sostituite da ledcAttach(pin, frequenza, risoluzione) e ledcWrite(pin, duty), per cui molti esempi datati non si compilano più. Se l’IDE non è ancora installato, su Linux si può seguire la guida Arduino IDE 2.x su Linux Mint e Fedora.

Procedura di installazione del core ESP32 (Arduino IDE 2.x)

 1. File > Preferenze (Arduino IDE > Impostazioni su macOS).
 2. Nel campo "URL aggiuntive per il Gestore schede" incollare:
      https://espressif.github.io/arduino-esp32/package_esp32_index.json
    (più URL si separano con una virgola).
 3. OK, poi aprire il Gestore schede dalla barra laterale.
 4. Cercare "esp32" e installare il pacchetto "esp32 by Espressif Systems"
    (versione 3.x). Non confonderlo con "Arduino ESP32 Boards", che
    serve per le schede Arduino Nano ESP32.
 5. Strumenti > Scheda > esp32: scegliere il modello, ad esempio
      ESP32 Dev Module          (DevKitC e cloni con ESP32 classico)
      ESP32S3 Dev Module        (S3-DevKitC-1)
      ESP32C3 Dev Module        (schede C3 generiche)
      Nologo ESP32C3 Super Mini (C3 SuperMini)
      ESP32C6 Dev Module        (C6-DevKitC-1)
 6. Strumenti > Porta: selezionare la porta della scheda.
 7. Solo per le schede programmate dalla USB nativa: impostare
    Strumenti > USB CDC On Boot = Enabled, altrimenti Serial.print()
    esce sulla UART0 e il monitor seriale resta vuoto.

Il pacchetto scarica le toolchain per Xtensa e RISC-V e le librerie precompilate di ogni chip: occupa più di un gigabyte e il primo download richiede qualche minuto. La prima compilazione è lenta perché viene generata la cache; le successive sono molto più rapide.

Driver USB: CP210x e CH340

Le schede con USB nativa non richiedono driver. Per quelle con bridge si legge la sigla del chip vicino al connettore: CP2102/CP2102N (Silicon Labs) o CH340/CH9102 (WCH). Su Linux i driver cp210x e ch341 sono già nel kernel: basta che l’utente appartenga al gruppo dialout e, sulle distribuzioni che lo installano, che il servizio brltty non si impadronisca del convertitore, come spiegato nella guida sull’IDE per Linux. Su Windows e macOS, se la scheda non compare tra le porte, si installa il driver VCP dal sito Silicon Labs o il driver CH340 dal sito del produttore WCH. Se non compare nulla nemmeno con lsusb, il primo sospettato è il cavo.

Verifica rapida su Linux

  lsusb                  # 10c4:ea60 = CP210x, 1a86:7523 = CH340,
                         # 303a:xxxx = USB nativa Espressif
  dmesg | tail           # cp210x converter now attached to ttyUSB0
  groups                 # deve comparire dialout

Primo sketch: Blink con LED esterno

La ESP32-DevKitC ufficiale non ha un LED programmabile (il LED rosso indica solo la presenza dei 5 V) e il core, per la variante “ESP32 Dev Module”, non definisce LED_BUILTIN. Molti cloni hanno un LED su GPIO2, ma non tutti. Per non dipendere dalla scheda si collega un LED esterno su GPIO25, un pin libero che non partecipa al boot, con una resistenza da 330 Ω. Nello stesso schema compaiono già il pulsante e il potenziometro usati nel progetto Wi-Fi.

Schema di collegamento ESP32: LED con resistenza da 330 ohm su GPIO25, pulsante verso massa su GPIO27 con pull-up interno, potenziometro da 10 kilohm su GPIO34 con condensatore da 100 nF

La resistenza del LED si dimensiona come per Arduino, ma con 3,3 V al posto di 5 V:

\(I_{LED} = \frac{V_{OH} – V_F}{R_1} = \frac{3{,}3\ \text{V} – 2{,}0\ \text{V}}{330\ \Omega} \approx 3{,}9\ \text{mA}\)

Il valore di V_F = 2,0 V è tipico di un LED rosso; con un LED blu o bianco (V_F intorno a 3 V) a 3,3 V la corrente diventa molto piccola e conviene ridurre la resistenza a 47–100 Ω, oppure pilotare il LED con un transistor dalla linea a 5 V. Il pulsante collega GPIO27 a massa e usa il pull-up interno; il potenziometro forma un partitore tra 3V3 e GND con il cursore su GPIO34, ingresso ADC1. Il condensatore da 100 nF riduce il rumore della lettura analogica.

// Blink per ESP32 (core arduino-esp32 3.x)
// LED esterno con resistenza da 330 ohm su GPIO25 (vedi schema).
// Su schede con LED integrato si puo' usare LED_BUILTIN.

const int LED_PIN = 25;        // GPIO25: non e' un pin di strapping

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  Serial.println("Blink avviato");
}

void loop() {
  digitalWrite(LED_PIN, HIGH);  // LED acceso
  delay(500);
  digitalWrite(LED_PIN, LOW);   // LED spento
  delay(500);
}

Si seleziona “ESP32 Dev Module”, la porta corretta e si carica. Se l’IDE resta fermo su Connecting........_____, la scheda non entra da sola in modalità download: si tiene premuto BOOT finché non inizia la scrittura. Al termine si apre il monitor seriale a 115200 baud. Sulle schede con LED integrato si può sostituire 25 con LED_BUILTIN: sulla C3 SuperMini corrisponde a GPIO8, mentre sulla C6-DevKitC-1 è un LED RGB indirizzabile che digitalWrite() accende in bianco. Sulla S3-DevKitC-1 attenzione alla revisione: la definizione generica “ESP32S3 Dev Module” colloca il LED RGB su GPIO48, valido per la prima versione della scheda, mentre sulla v1.1 il LED è su GPIO38 e LED_BUILTIN non lo accende.

Progetto Wi-Fi: web server con LED, pulsante e lettura analogica

Il passo successivo è collegare la scheda alla rete di casa e pubblicare una pagina web raggiungibile da qualsiasi browser della stessa rete. L’ESP32 lavora in modalità station (STA), come un normale client: ottiene un indirizzo IP dal router via DHCP e mette in ascolto un server HTTP sulla porta 80. Il progetto usa due librerie incluse nel core: WiFi.h per la connessione e WebServer.h per il server.

Schema a blocchi del progetto: browser, router Wi-Fi, ESP32 con WiFi.h e WebServer.h, percorsi /, /led e /api, LED, pulsante e potenziometro

Il server risponde a tre percorsi: / restituisce la pagina HTML con lo stato di LED, pulsante e tensione letta su GPIO34; /led?stato=1 e /led?stato=0 accendono e spengono il LED e poi rimandano il browser alla pagina principale con una risposta HTTP 303; /api restituisce gli stessi dati in formato JSON, utile per leggerli da uno script o da un altro dispositivo. La pagina si aggiorna da sola ogni 2 secondi.

// Web server minimo per ESP32 - core arduino-esp32 3.x
// LED su GPIO25, pulsante su GPIO27 (verso GND, pull-up interno),
// potenziometro o sensore analogico su GPIO34 (ADC1, utilizzabile con Wi-Fi attivo).

#include <WiFi.h>
#include <WebServer.h>

const char *WIFI_SSID = "NOME_RETE";       // da modificare
const char *WIFI_PASS = "PASSWORD_RETE";   // da modificare

const int LED_PIN = 25;
const int BUTTON_PIN = 27;
const int ANALOG_PIN = 34;   // ingresso solo-input, canale ADC1_CH6

WebServer server(80);
bool ledOn = false;

// Pagina HTML con stato e due pulsanti; si aggiorna da sola ogni 2 s
String paginaHtml() {
  String s;
  s.reserve(1200);
  s += F("<!DOCTYPE html><html lang='it'><head><meta charset='utf-8'>"
         "<meta name='viewport' content='width=device-width,initial-scale=1'>"
         "<meta http-equiv='refresh' content='2'>"
         "<title>ESP32</title><style>body{font-family:sans-serif;margin:2em}"
         "a{display:inline-block;padding:.6em 1.2em;margin:.3em;border:1px solid #333;"
         "text-decoration:none;color:#000}</style></head><body><h1>ESP32 web server</h1>");
  s += "<p>LED: <b>" + String(ledOn ? "ACCESO" : "SPENTO") + "</b></p>";
  s += "<p>Pulsante: <b>" + String(digitalRead(BUTTON_PIN) == LOW ? "PREMUTO" : "RILASCIATO") + "</b></p>";
  s += "<p>Tensione su GPIO34: <b>" + String(analogReadMilliVolts(ANALOG_PIN)) + " mV</b></p>";
  s += F("<p><a href='/led?stato=1'>Accendi</a><a href='/led?stato=0'>Spegni</a></p>"
         "<p><small>Dati in JSON: <a href='/api'>/api</a></small></p></body></html>");
  return s;
}

void handleRoot() {
  server.send(200, "text/html", paginaHtml());
}

void handleLed() {
  if (server.hasArg("stato")) {
    ledOn = (server.arg("stato") == "1");
    digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
  }
  server.sendHeader("Location", "/");   // torna alla pagina principale
  server.send(303);
}

void handleApi() {
  String json = "{\"led\":" + String(ledOn ? "true" : "false") +
                ",\"pulsante\":" + String(digitalRead(BUTTON_PIN) == LOW ? "true" : "false") +
                ",\"mV\":" + String(analogReadMilliVolts(ANALOG_PIN)) +
                ",\"rssi\":" + String(WiFi.RSSI()) + "}";
  server.send(200, "application/json", json);
}

void handleNotFound() {
  server.send(404, "text/plain", "Pagina non trovata");
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  analogSetPinAttenuation(ANALOG_PIN, ADC_11db);   // fondo scala circa 0,15-3,1 V

  WiFi.setHostname("esp32-mst");   // va chiamata PRIMA di WiFi.mode()/begin()
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  Serial.print("Connessione a ");
  Serial.print(WIFI_SSID);
  unsigned long t0 = millis();
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if (millis() - t0 > 20000) {            // 20 s senza connessione: riavvio
      Serial.println("\nConnessione fallita, riavvio");
      ESP.restart();
    }
  }
  Serial.print("\nConnesso, indirizzo IP: ");
  Serial.println(WiFi.localIP());

  server.on("/", HTTP_GET, handleRoot);
  server.on("/led", HTTP_GET, handleLed);
  server.on("/api", HTTP_GET, handleApi);
  server.onNotFound(handleNotFound);
  server.begin();
  Serial.println("Server HTTP avviato");
}

void loop() {
  server.handleClient();
  delay(2);   // lascia tempo agli altri task
}

Alcuni dettagli del codice meritano attenzione. La connessione è attesa con un timeout di 20 s, dopo il quale la scheda si riavvia invece di restare bloccata. server.handleClient() deve essere chiamata di continuo nel loop(): per questo non vanno usati delay() lunghi, ma la gestione del tempo con millis() già vista negli sketch Arduino. Il pulsante è letto con INPUT_PULLUP, quindi premuto vale LOW; se lo si usa per contare eventi va aggiunto un debouncing. La lettura analogica è su GPIO34, canale ADC1, e funziona anche con il Wi-Fi attivo; spostandola su GPIO25–27 (ADC2) si otterrebbero letture non valide.

Caricato lo sketch, il monitor seriale mostra l’indirizzo ottenuto, per esempio 192.168.1.50: lo si digita nel browser di un PC o di uno smartphone collegato alla stessa rete. L’ESP32 lavora solo sulla banda a 2,4 GHz: se il router usa lo stesso nome di rete per 2,4 e 5 GHz di solito non ci sono problemi, ma una rete solo 5 GHz non è visibile.

Il server di questo esempio non ha autenticazione né cifratura ed è pensato per la rete locale: non va esposto su Internet aprendo porte sul router. Per l’accesso da remoto si usano una VPN o un sistema domotico come Home Assistant. Per lo stesso motivo le credenziali Wi-Fi scritte nello sketch non vanno pubblicate insieme al codice.

Alimentazione, consumi e deep sleep

La scheda di sviluppo si alimenta dalla USB (5 V, abbassati a 3,3 V dal regolatore della scheda) oppure dai pin 5V o 3V3, uno solo alla volta. Il datasheet raccomanda un’alimentazione a 3,3 V in grado di fornire almeno 500 mA: il consumo medio con Wi-Fi connesso è di qualche decina di milliampere, ma durante la trasmissione il chip assorbe fino a circa 240 mA (802.11b a 1 Mbps, +19,5 dBm). Questi picchi sono la causa del brownout descritto negli errori comuni.

Per l’uso a batteria l’ESP32 offre il deep sleep: CPU, gran parte della RAM e periferiche digitali vengono spente, restano attivi solo il controller RTC, le sue periferiche e la memoria RTC. Il datasheet indica circa 10 µA per l’ESP32 classico con timer RTC e memoria RTC attivi (5 µA per il C3, 7 µA per il C6, 8 µA per l’S3). Al risveglio il programma riparte da setup() come dopo un reset; le variabili dichiarate con RTC_DATA_ATTR conservano il loro valore.

// Deep sleep con risveglio a tempo e da pulsante - ESP32 classico, core 3.x
#include "driver/rtc_io.h"

#define uS_TO_S 1000000ULL
const uint64_t SLEEP_S = 60;              // dorme 60 s
const gpio_num_t WAKE_PIN = GPIO_NUM_27;  // pulsante verso GND (RTC_GPIO17)
const int ANALOG_PIN = 34;

RTC_DATA_ATTR uint32_t bootCount = 0;     // sopravvive al deep sleep

void setup() {
  Serial.begin(115200);
  delay(200);
  bootCount++;

  esp_sleep_wakeup_cause_t causa = esp_sleep_get_wakeup_cause();
  Serial.printf("Risveglio n. %lu, causa: %s\n", (unsigned long)bootCount,
                causa == ESP_SLEEP_WAKEUP_TIMER ? "timer" :
                causa == ESP_SLEEP_WAKEUP_EXT0  ? "pulsante" : "accensione/reset");

  // Lavoro utile: una misura (qui si potrebbe inviare il dato via Wi-Fi)
  Serial.printf("GPIO34 = %lu mV\n", (unsigned long)analogReadMilliVolts(ANALOG_PIN));

  // Sorgenti di risveglio
  esp_sleep_enable_timer_wakeup(SLEEP_S * uS_TO_S);
  esp_sleep_enable_ext0_wakeup(WAKE_PIN, 0);       // risveglio con livello BASSO
  rtc_gpio_pullup_en(WAKE_PIN);                     // pull-up RTC attivo nel sonno
  rtc_gpio_pulldown_dis(WAKE_PIN);

  Serial.println("Vado in deep sleep");
  Serial.flush();
  esp_deep_sleep_start();                           // non ritorna
}

void loop() {}

Lo sketch si risveglia ogni 60 secondi oppure quando si preme il pulsante su GPIO27 (che è anche un pin RTC, condizione necessaria per il risveglio ext0). Il pull-up digitale impostato con pinMode() non resta attivo durante il sonno: per questo si abilita il pull-up del dominio RTC con rtc_gpio_pullup_en().

Quanto dura la batteria dipende soprattutto da quanto consuma la scheda mentre dorme. Una DevKit ha il LED di alimentazione, il bridge USB-UART e un regolatore lineare con corrente di riposo non trascurabile: anche con il chip in deep sleep l’assorbimento resta tipicamente nell’ordine dei milliampere. Il calcolo seguente, con valori indicativi, mostra l’effetto.

\(I_{media} = \frac{t_{on} \cdot I_{on} + (T – t_{on}) \cdot I_{sleep}}{T} \qquad t_{aut} = \frac{C}{I_{media}}\)

Esempio di calcolo: risveglio ogni 10 minuti, batteria da 2000 mAh

  Ipotesi (indicative): t_on = 3 s a I_on = 120 mA medi
  (connessione Wi-Fi e invio di un dato), T = 600 s

  a) scheda ottimizzata, I_sleep = 15 µA = 0,015 mA
     I_media = (3·120 + 597·0,015) / 600 = 0,615 mA
     t_aut   = 2000 / 0,615 ≈ 3252 h ≈ 135 giorni

  b) DevKit con LED e bridge, I_sleep = 10 mA
     I_media = (3·120 + 597·10) / 600 = 10,55 mA
     t_aut   = 2000 / 10,55 ≈ 190 h ≈ 8 giorni

  Non sono considerati autoscarica, capacità reale della cella
  e rendimento del regolatore.

Grafico dell'autonomia teorica in giorni in funzione dell'intervallo di risveglio per una scheda ottimizzata a 15 microampere e una DevKit a 10 milliampere in deep sleep

La conclusione pratica è che il deep sleep rende solo se tutta la scheda è progettata per il basso consumo: regolatore a bassa corrente di riposo, nessun LED sempre acceso, bridge USB scollegato dalla batteria. Per un prototipo a batteria conviene scegliere una scheda dichiarata per il basso consumo e misurare la corrente reale con un multimetro in serie all’alimentazione, sulla portata dei milliampere e poi dei microampere.

Passi successivi: MicroPython, ESPHome e Home Assistant

L’Arduino IDE non è l’unico modo per programmare l’ESP32. MicroPython è disponibile per ESP32, S3, C3 e C6: si carica il firmware con esptool o direttamente da Thonny e si lavora con il REPL e i moduli machine e network già visti nella guida sulla Raspberry Pi Pico; il codice per la connessione Wi-Fi è praticamente identico a quello della Pico W. È ideale per sperimentare, a costo di più memoria occupata e prestazioni inferiori rispetto al C++.

Chi usa la domotica può invece non scrivere codice affatto. ESPHome genera e carica il firmware a partire da un file di configurazione YAML in cui si dichiarano sensori, uscite e pulsanti, e lo integra automaticamente in Home Assistant, con aggiornamenti successivi via Wi-Fi. Il circuito di questa guida, LED, pulsante e potenziometro, si descrive in poche righe di configurazione e diventa un dispositivo di casa comandabile dall’app. Per comandare carichi a 230 V, infine, si rimanda alla guida sulla gestione dei carichi AC.

Errori comuni

Boot loop o scheda che non si avvia dopo aver collegato un circuito. Quasi sempre è un pin di strapping forzato al livello sbagliato all’accensione: un pull-up o un modulo su GPIO12 (flash impostata a 1,8 V), un circuito che tiene basso GPIO0 (il chip resta in attesa in modalità download) o alto GPIO2. Si scollega il circuito, si verifica che la scheda si avvii e si spostano le connessioni su pin liberi. Il monitor seriale a 115200 baud mostra il messaggio di boot del ROM, utile per capire in che modalità si è avviato il chip.

“Brownout detector was triggered” e riavvii ciclici. La tensione a 3,3 V scende sotto la soglia durante i picchi di corrente del Wi-Fi. Le cause tipiche sono una porta USB debole, un hub non alimentato, un cavo lungo e sottile o un regolatore sottodimensionato. Si prova un’altra porta o un alimentatore USB di qualità; è pratica comune aggiungere un condensatore elettrolitico da qualche centinaio di microfarad tra 3V3 e GND vicino al modulo. Disattivare il rilevatore di brownout nasconde il sintomo, non risolve il problema.

Nessuna porta seriale. Molti cavi USB in circolazione sono di sola ricarica e non hanno i conduttori dati: la scheda si accende ma il PC non la vede. Si prova con un cavo sicuramente dati prima di cercare driver; poi si verificano il driver del bridge, i permessi e, su Linux, il servizio brltty.

Caricamento che si ferma su “Connecting…”. La scheda non entra da sola in modalità download (circuito di reset automatico assente o lento, oppure USB nativa non attiva perché lo sketch è bloccato o in deep sleep). Procedura manuale: tenere premuto BOOT, premere e rilasciare EN (o RST), rilasciare BOOT e avviare il caricamento; al termine premere EN per eseguire il nuovo programma. Sulle schede con USB nativa la porta può cambiare nome quando il chip entra in modalità download, quindi va controllata e, se serve, riselezionata nell’IDE.

Letture analogiche fisse o casuali con il Wi-Fi attivo. Il sensore è su un pin ADC2: va spostato su GPIO32–39. Letture bloccate a 0 o al massimo indicano invece una tensione fuori dall’intervallo dell’attenuatore.

Esempi trovati in rete che non compilano. Sono scritti per il core 2.x: le funzioni LEDC e alcune API di rete sono cambiate. Conviene partire dagli esempi inclusi nel core installato (File > Esempi, sezione della scheda), sempre allineati alla versione in uso.

Checklist per il primo progetto ESP32

 1. Scheda e cavo dati verificati, porta visibile (lsusb / Gestione dispositivi).
 2. Core "esp32 by Espressif Systems" 3.x installato, scheda corretta selezionata.
 3. USB nativa: "USB CDC On Boot" abilitato per vedere Serial.
 4. Segnali a 3,3 V; moduli a 5 V tramite partitore o traslatore di livello.
 5. Nessun circuito su GPIO6-11; strapping (0, 2, 5, 12, 15) liberi al reset.
 6. GPIO34-39 solo ingresso, senza pull-up interni.
 7. Ingressi analogici su ADC1 (GPIO32-39) se il Wi-Fi è attivo.
 8. Correnti dei GPIO di pochi mA; carichi tramite transistor o MOSFET.
 9. Alimentazione capace di almeno 500 mA; un'unica sorgente.
10. Nel loop() niente delay() lunghi: chiamare spesso server.handleClient().
11. Per la batteria: misurare la corrente reale in deep sleep.

Fonti e approfondimenti

Articoli collegati

Admin | MST-Tutorial

Appassionato di elettronica, elettrotecnica e programmazione. Fondatore di MST-Tutorial, condivido con entusiasmo conoscenze, esperienze e progetti legati all’innovazione tecnologica, con l’obiettivo di rendere accessibili concetti tecnici complessi attraverso tutorial chiari e pratici.

Articoli Correlati

Pulsante per tornare all'inizio