ESPDuino-32: piedinatura, compatibilità shield Uno e primo Wi-Fi
ESPDuino-32 spiegato: corrispondenza dei pin con l'Uno, la trappola dei 3,3 V, shield che non funzionano, la scheda nell'IDE Arduino e il primo sketch Wi-Fi.
L'ESPDuino-32 è una scheda di sviluppo che porta un ESP32 nelle dimensioni e nella disposizione dei pin di un Arduino Uno: da fuori sembra un Uno, ma monta un processore dual core a 240 MHz, Wi-Fi e Bluetooth. È un progetto di DOIT e una scheda quasi identica si vende come WEMOS D1 R32. In questa guida abbiniamo uno per uno i pin dell'ESPDuino-32 a quelli dell'Uno, vediamo quali shield dell'Uno funzionano e quali no e spieghiamo come selezionare la scheda nell'IDE Arduino.
Il suo grande vantaggio è che puoi montare gli shield dell'Uno che hai già e aggiungere il Wi-Fi al tuo progetto. Ma c'è una trappola importante: l'Uno lavora a 5 V, mentre tutti i pin di segnale dell'ESPDuino-32 lavorano a 3,3 V e non tollerano i 5 V. Shield e sensori non conoscono questa differenza, e con un collegamento sbagliato puoi bruciare un pin o addirittura tutta la scheda. Prima conosciamo meglio la scheda.

Cos'è l'ESPDuino-32? Confronto con Uno ed ESP32 DevKit
Il cuore dell'ESPDuino-32 è il modulo ESP32-WROOM-32, lo stesso delle schede ESP32 classiche. Dal punto di vista del software è quindi un normalissimo ESP32: tutti gli sketch e le librerie scritte per l'ESP32 funzionano anche qui. La differenza sta nel disegno della scheda: i pin arrivano su connettori in formato Uno e la scheda aggiunge una presa jack, un regolatore da 3,3 V e un convertitore USB-seriale (quasi sempre un CH340). Se non hai mai usato un ESP32, trovi le basi in Cos'è l'ESP32?
| Caratteristica | Arduino Uno R3 | ESPDuino-32 | ESP32 DevKit |
|---|---|---|---|
| Processore | ATmega328P, 8 bit, 16 MHz | ESP32, dual core, 240 MHz | ESP32, dual core, 240 MHz |
| RAM | 2 KB | 520 KB | 520 KB |
| Memoria flash | 32 KB | 4 MB | 4 MB |
| Livello logico | 5 V | 3,3 V | 3,3 V |
| Wireless | Nessuno | Wi-Fi + Bluetooth | Wi-Fi + Bluetooth |
| Ingressi analogici | 6 canali, 10 bit | 6 canali sul connettore Uno, 12 bit | Fino a 18 canali, 12 bit |
| Formato e shield | 68,6 × 53,4 mm, shield per Uno | Stesso formato dell'Uno, accetta shield | Si inserisce nella breadboard, niente shield |
| Chip USB | ATmega16U2 | Quasi sempre CH340 | CP2102 o CH340 |
Quale conviene comprare? Se hai degli shield per Uno, vuoi avvitare la scheda in una scatola usando i fori di fissaggio dell'Uno o stai seguendo un libro o un corso pensato per l'Uno, l'ESPDuino-32 ti semplifica la vita. Se lavori su breadboard, ti servono pin dell'ESP32 che non arrivano sul connettore Uno, come GPIO 32 e 33, oppure il dispositivo deve essere piccolo, l'ESP32 DevKit classico è la scelta migliore. Il codice è lo stesso su entrambe; cambiano solo i numeri dei pin.
Piedinatura dell'ESPDuino-32: quale GPIO c'è dietro ogni pin dell'Uno?
Anche se la scheda è serigrafata D2, D3, A0 come un Uno, nel codice ti serve quasi sempre il numero del GPIO. La tabella qui sotto mostra il GPIO dell'ESP32 dietro ogni pin dell'Uno e a cosa fare attenzione. Puoi anche consultare l'elenco completo dei pin dell'ESP32 nello strumento Pinout.
| Pin Uno | GPIO ESP32 | Stato | Nota |
|---|---|---|---|
| D0 (RX) | GPIO 3 | Da evitare | Linea seriale dell'USB |
| D1 (TX) | GPIO 1 | Da evitare | Linea seriale dell'USB |
| D2 | GPIO 26 | Sicuro | Utilizzabile anche come uscita DAC2 |
| D3 | GPIO 25 | Sicuro | Utilizzabile anche come uscita DAC1 |
| D4 | GPIO 17 | Sicuro | Usato anche come TX di Serial2 |
| D5 | GPIO 16 | Sicuro | Usato anche come RX di Serial2 |
| D6 | GPIO 27 | Sicuro | Ingresso touch (T7) |
| D7 | GPIO 14 | Con cautela | All'avvio emette un breve segnale PWM |
| D8 | GPIO 12 | Con cautela | Pin di avvio: se è HIGH all'accensione, la scheda non parte |
| D9 | GPIO 13 | Sicuro | Ingresso e uscita di uso generale |
| D10 | GPIO 5 | Con cautela | SPI SS; all'avvio emette un breve segnale PWM |
| D11 | GPIO 23 | Sicuro | SPI MOSI |
| D12 | GPIO 19 | Sicuro | SPI MISO |
| D13 | GPIO 18 | Sicuro | SPI SCK; a differenza dell'Uno qui non c'è un LED |
| A0 | GPIO 2 | Con cautela | ADC2 (non legge con il Wi-Fi attivo), LED integrato, pin di avvio |
| A1 | GPIO 4 | Con cautela | ADC2 (non legge con il Wi-Fi attivo) |
| A2 | GPIO 35 | Solo ingresso | ADC1, funziona insieme al Wi-Fi |
| A3 | GPIO 34 | Solo ingresso | ADC1, funziona insieme al Wi-Fi |
| A4 | GPIO 36 (VP) | Solo ingresso | ADC1; non è SDA come sull'Uno |
| A5 | GPIO 39 (VN) | Solo ingresso | ADC1; non è SCL come sull'Uno |
| SDA | GPIO 21 | Sicuro | Linea dati I2C |
| SCL | GPIO 22 | Sicuro | Linea di clock I2C |
Sul lato analogico ci sono altre due trappole. La prima: A0 (GPIO 2) e A1 (GPIO 4) appartengono all'unità ADC2 dell'ESP32, che non può leggere quando il Wi-Fi è attivo; nei progetti Wi-Fi collega i sensori analogici ad A2–A5 (ADC1). La seconda: l'ADC dell'ESP32 è a 12 bit, quindi analogRead() restituisce 0–4095 invece di 0–1023 e il fondo scala è di circa 3,3 V, non 5 V. I calcoli come "valore × 5,0 / 1023" degli sketch per Uno vanno adattati; meglio ancora, usa analogReadMilliVolts(), che restituisce un risultato calibrato in millivolt.
La trappola dei 3,3 V: gli shield per Uno funzionano sull'ESPDuino-32?
Il fatto che uno shield si incastri non vuol dire che funzioni. Sull'ESPDuino-32 uno shield crea problemi in tre modi: manda un segnale a 5 V nell'ESP32 e danneggia il pin, si aspetta una logica a 5 V e non sempre riconosce 3,3 V come HIGH, oppure affida ai pin A2–A5, che sono solo ingressi, un compito che richiede un'uscita. Siccome il pin 5V della scheda fornisce 5 V come sull'Uno, lo shield in sé viene alimentato; i problemi compaiono sempre sui pin di segnale. Ecco come si comportano gli shield più diffusi:

| Shield | Stato | Perché |
|---|---|---|
| CNC Shield V3 (A4988 / DRV8825) | Di solito funziona | STEP e DIR cadono su GPIO che possono fare da uscita; le versioni di GRBL per ESP32 hanno già pronta la mappa dei pin di questa scheda |
| Shield relè | Di solito funziona | I relè sono alimentati dal pin 5V e il transistor che li comanda conduce anche con un segnale a 3,3 V |
| Shield data logger (scheda SD + RTC) | In parte | Una SD su D10–D13 funziona, perché sono i pin SPI dell'ESP32; l'RTC non funziona se il suo I2C arriva solo ad A4/A5 |
| Shield motori L293D | Instabile | Il 74HC595 a 5 V legge a fatica ingressi a 3,3 V e la sua linea dati su D8 (GPIO 12) può anche impedire l'avvio |
| Shield LCD Keypad | Rischioso | I pulsanti arrivano ad A0 tramite una scala di resistenze collegata ai 5 V, quindi senza pulsanti premuti GPIO 2 riceve 5 V |
| Shield TFT parallelo da 2,4 pollici | Non funziona | Le linee di controllo sono su A0–A4; A2, A3 e A4 sono solo ingressi e non possono pilotare il display |
| Vecchi shield che prendono l'I2C solo da A4/A5 | Non funziona | Sull'ESPDuino-32 l'I2C è sui pin SDA/SCL separati (GPIO 21/22) |
Pin di avvio (strapping): attenzione a D8 e A0
All'accensione l'ESP32 controlla il livello di alcuni pin per decidere come avviarsi. Sull'ESPDuino-32 due di questi arrivano sul connettore Uno. Se D8 (GPIO 12) è HIGH all'avvio, l'ESP32 prova ad avviare la memoria flash con la tensione sbagliata e la scheda non parte. A0 (GPIO 2) deve restare libero o a LOW durante il caricamento del codice. Se hai collegato a D8 un modulo o uno shield con una resistenza di pull-up e la scheda non parte, è il primo indiziato. Anche D7 (GPIO 14) e D10 (GPIO 5) emettono un breve segnale PWM all'avvio: un relè su questi pin può fare un breve clic all'accensione.
Installare l'ESPDuino-32 e scegliere la scheda nell'IDE Arduino
- Installa nell'IDE Arduino il pacchetto schede esp32 di Espressif; i passaggi sono in Cos'è l'ESP32?
- Collega la scheda via USB. Se la porta non compare, installa il driver del suo chip USB (quasi sempre un CH340) e verifica che il cavo trasmetta dati.
- In Strumenti > Scheda > esp32 scegli WEMOS D1 R32: in questa definizione i nomi D2–D13 e A0–A5 corrispondono esattamente alla serigrafia della scheda. Funzionano anche DOIT ESPduino32 o ESP32 Dev Module, ma in quel caso devi usare solo i numeri dei GPIO.
- Seleziona la porta della scheda; se il caricamento fallisce con Upload Speed a 921600, scendi a 115200.
- Premi Carica e apri il Monitor seriale a 115200 baud. Se la scheda non entra in modalità di caricamento, guarda le soluzioni di ESP32 Failed to Connect.
Primo test: LED integrato, D13 e una lettura analogica
Il LED blu integrato della scheda è collegato a GPIO 2, non a D13 come sull'Uno. Lo sketch qui sotto accende a turno il LED integrato e un LED collegato a D13 (GPIO 18) tramite una resistenza da 220 Ω, e scrive nel Monitor seriale il valore di un potenziometro collegato ad A2 (GPIO 35). Collega i piedini esterni del potenziometro a 3V3 e GND, non al 5V; il cursore va su A2.
1// ESPDuino-32: Uno adları yerine GPIO numaraları / GPIO numbers instead of Uno pin names
2const int ONBOARD_LED = 2; // kart üstü mavi LED (A0 ile aynı pin) / onboard blue LED (same pin as A0)
3const int LED_D13 = 18; // Uno D13 = GPIO 18
4const int POT_A2 = 35; // Uno A2 = GPIO 35 (ADC1, yalnız giriş / input only)
5
6void setup() {
7 Serial.begin(115200);
8 pinMode(ONBOARD_LED, OUTPUT);
9 pinMode(LED_D13, OUTPUT);
10 analogReadResolution(12); // 0–4095 (varsayılan / default)
11}
12
13void loop() {
14 int raw = analogRead(POT_A2); // 0–4095, Uno'daki gibi 0–1023 değil / not 0–1023 like the Uno
15 int mv = analogReadMilliVolts(POT_A2); // kalibre edilmiş mV / calibrated millivolts
16 Serial.printf("A2 ham / raw: %d gerilim / voltage: %d mV\n", raw, mv);
17
18 digitalWrite(ONBOARD_LED, HIGH); // LED'ler sırayla / LEDs take turns
19 digitalWrite(LED_D13, LOW);
20 delay(500);
21 digitalWrite(ONBOARD_LED, LOW);
22 digitalWrite(LED_D13, HIGH);
23 delay(500);
24}Primo progetto Wi-Fi: comandare un LED dal telefono
Ora vediamo cosa distingue davvero questa scheda dall'Uno. Lo sketch qui sotto collega l'ESPDuino-32 alla rete di casa e avvia un piccolo server web. Scrivi l'indirizzo IP mostrato nel Monitor seriale nel browser di un telefono collegato alla stessa rete e vedrai un pulsante che accende e spegne il LED su D13 e la lettura del potenziometro su A2 in millivolt. Abbiamo messo il potenziometro su A2 di proposito: con il Wi-Fi attivo, A0 e A1 non possono leggere valori analogici.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
5const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
6
7const int LED_PIN = 18; // Uno D13 = GPIO 18
8const int POT_PIN = 35; // Uno A2 = GPIO 35 (ADC1: Wi-Fi ile çalışır / works with Wi-Fi)
9
10WebServer server(80);
11bool ledOn = false;
12
13String page() {
14 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
15 html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
16 html += "<title>ESPDuino-32</title></head>";
17 html += "<body style='font-family:sans-serif;text-align:center'><h1>ESPDuino-32</h1>";
18 html += "<p>LED (D13): <b>" + String(ledOn ? "ON" : "OFF") + "</b></p>";
19 html += "<p><a href='/toggle'><button style='font-size:24px;padding:12px 32px'>LED</button></a></p>";
20 html += "<p>A2: " + String(analogReadMilliVolts(POT_PIN)) + " mV</p>";
21 html += "</body></html>";
22 return html;
23}
24
25void handleRoot() {
26 server.send(200, "text/html", page());
27}
28
29void handleToggle() {
30 ledOn = !ledOn;
31 digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
32 server.sendHeader("Location", "/"); // ana sayfaya dön / back to the main page
33 server.send(303);
34}
35
36void setup() {
37 Serial.begin(115200);
38 pinMode(LED_PIN, OUTPUT);
39
40 WiFi.mode(WIFI_STA);
41 WiFi.begin(WIFI_SSID, WIFI_PASS);
42 Serial.print("Baglaniyor / Connecting");
43 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
44 delay(500);
45 Serial.print(".");
46 }
47 Serial.println();
48 Serial.print("IP: ");
49 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
50
51 server.on("/", handleRoot);
52 server.on("/toggle", handleToggle);
53 server.begin();
54}
55
56void loop() {
57 server.handleClient(); // gelen istekleri işle / handle incoming requests
58}Lo sketch definisce due indirizzi: / invia la pagina principale, mentre /toggle cambia lo stato del LED e rimanda il browser alla pagina principale. A ogni ricarica della pagina il potenziometro viene letto di nuovo. Per un'interfaccia che si aggiorna in tempo reale senza ricaricare, usa il metodo di ESP32 Async Web Server e WebSocket. Se la scheda non si collega, controlla che la tua rete sia a 2,4 GHz; l'ESP32 non vede le reti a 5 GHz.
Alimentazione: USB, presa jack e pin 3V3
| Sorgente | Tensione | Nota |
|---|---|---|
| USB | 5 V | Sufficiente per lo sviluppo e per piccoli circuiti |
| Presa jack | Di solito 7–12 V (controlla la scritta sulla tua scheda) | Il regolatore si scalda; a 9 V lavora più fresco che a 12 V |
| Pin VIN | La tensione della presa jack | Per alimentare la scheda da una sorgente esterna |
| Pin 5V | Uscita a 5 V | Alimenta shield e moduli a 5 V; ricordati di abbassare i loro segnali a 3,3 V |
| Pin 3V3 | Uscita a 3,3 V | Per i sensori; non collegare motori né lunghe strisce LED |
Quando trasmette via Wi-Fi, l'ESP32 può assorbire picchi di quasi 250 mA. Un cavo o una porta USB deboli fanno calare la tensione in quei momenti e la scheda si riavvia con "Brownout detector was triggered". In questo caso usa un cavo corto e di buona qualità oppure alimenta la scheda dalla presa jack; i dettagli sono in ESP32 Brownout e Guru Meditation.
Errori comuni e come risolverli
- Uno sketch per Uno non funziona: i numeri dei pin sono pensati per l'Uno. Sull'ESPDuino-32 pinMode(13, OUTPUT) comanda GPIO 13, cioè D9 e non D13; cerca il numero del GPIO nella tabella.
- analogRead dà sempre 4095 o sempre 0: il sensore è alimentato a 5 V e la sua uscita supera i 3,3 V, oppure è su un pin ADC2 (A0, A1) con il Wi-Fi attivo.
- Il display I2C non viene rilevato: è collegato ad A4/A5; sposta i fili sui pin SDA/SCL (GPIO 21/22).
- La scheda non parte o si riavvia di continuo: qualcosa collegato a D8 (GPIO 12) porta il pin a HIGH all'accensione; sposta quel componente su un altro pin.
- Con lo shield montato si scalda la scheda o un componente: lo shield sta mandando 5 V su un pin; scollega subito la scheda e abbassa quella linea con un partitore o un traslatore di livello.
- SoftwareSerial o la libreria Servo non compilano: al posto delle librerie solo per AVR usa gli equivalenti per ESP32: la porta seriale hardware Serial2 ed ESP32Servo.
L'ESPDuino-32 è il passaggio più familiare dall'Uno all'ESP32: stesso formato, stessi connettori, ma una frequenza di clock 15 volte più alta e la connessione wireless. Tieni a portata di mano Piedinatura dell'Arduino Uno per ricordare le differenze. Tutti i progetti ESP32 dell'app BlueGrays funzionano anche su questa scheda, quindi puoi realizzare passo passo il LED, il semaforo, la connessione Wi-Fi e il server web con il loro schema di collegamento e il loro codice; ti basta abbinare i pin con la tabella qui sopra.
Domande frequenti
L'ESPDuino-32 è uguale alla WEMOS D1 R32?
In pratica sì. Entrambe montano un modulo ESP32-WROOM-32 su una scheda in formato Uno, con la stessa corrispondenza dei pin sui connettori Uno. L'IDE Arduino ha una definizione per ciascuna; quella della WEMOS D1 R32 è più comoda perché collega le etichette D e A della scheda ai GPIO giusti.
Si possono usare gli shield per Arduino Uno sull'ESPDuino-32?
Si incastrano, ma il funzionamento dipende dallo shield. Quelli che non mandano segnali a 5 V all'ESP32, non usano A2–A5 come uscite e non prendono l'I2C solo da A4/A5 di solito funzionano; gli shield LCD Keypad e TFT parallelo non funzionano senza modifiche.
L'ESPDuino-32 funziona a 5 V?
La scheda si alimenta a 5 V dall'USB o dal pin 5V e accetta una tensione più alta dalla presa jack. I pin di segnale invece lavorano a 3,3 V e non tollerano i 5 V, quindi i sensori con uscita a 5 V richiedono un partitore di tensione o un traslatore di livello.
Su quale pin si trova il LED integrato dell'ESPDuino-32?
Il LED blu integrato è collegato a GPIO 2, che sulla scheda compare anche come A0. A differenza dell'Uno, su D13 non c'è nessun LED e la costante LED_BUILTIN vale 2.
Quale scheda scelgo nell'IDE Arduino per l'ESPDuino-32?
Scegli WEMOS D1 R32 se nel codice vuoi usare le etichette dell'Uno come D2 o A0. DOIT ESPduino32 o ESP32 Dev Module caricano il codice altrettanto bene, ma con queste devi scrivere i pin come numeri di GPIO.
Perché analogRead non funziona sul mio ESPDuino-32?
Il motivo più frequente è che il sensore è su A0 o A1 con il Wi-Fi attivo; questi pin appartengono all'ADC2, che non può leggere insieme al Wi-Fi. Sposta il sensore su A2–A5 (ADC1) e ricorda che il risultato va da 0 a 4095 con un fondo scala di circa 3,3 V.
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.

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.

Lettura dell'intensità luminosa con il modulo LDR ESP32
Monitoraggio in tempo reale sul Serial Monitor del valore grezzo dell'ADC del modulo LDR e della percentuale relativa di luce calcolata dai valori di riferimento al buio e alla luce. Questa percentuale non è una misurazione in lux. Spiega il principio di calibrazione del modulo. È consigliabile eseguirlo prima del Progetto 10, poiché serve a determinare il valore di soglia.

Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
In questo progetto controlliamo in modo analogico la luminosità di un LED tramite un potenziometro. Il pin ADC dell'ESP32 legge la tensione tra 0 e 3,3 V dal potenziometro; il valore viene convertito in un segnale PWM (Pulse Width Modulation) e inviato al LED. Ruotando il potenziometro, il LED si accende e si spegne gradualmente. Con Arduino Core 3.0+ si usa direttamente analogWrite(); su ESP32-S2/S3 la risoluzione dell'ADC è fissata a 12 bit.

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

