Componenti · 8 min di lettura

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.

Scheda di sviluppo ESPDuino-32
ESPDuino-32: un modulo ESP32-WROOM-32 su una scheda in formato Uno, con chip USB-seriale, presa jack di alimentazione e connettori nella stessa posizione dell'Uno.

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?

CaratteristicaArduino Uno R3ESPDuino-32ESP32 DevKit
ProcessoreATmega328P, 8 bit, 16 MHzESP32, dual core, 240 MHzESP32, dual core, 240 MHz
RAM2 KB520 KB520 KB
Memoria flash32 KB4 MB4 MB
Livello logico5 V3,3 V3,3 V
WirelessNessunoWi-Fi + BluetoothWi-Fi + Bluetooth
Ingressi analogici6 canali, 10 bit6 canali sul connettore Uno, 12 bitFino a 18 canali, 12 bit
Formato e shield68,6 × 53,4 mm, shield per UnoStesso formato dell'Uno, accetta shieldSi inserisce nella breadboard, niente shield
Chip USBATmega16U2Quasi sempre CH340CP2102 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 UnoGPIO ESP32StatoNota
D0 (RX)GPIO 3Da evitareLinea seriale dell'USB
D1 (TX)GPIO 1Da evitareLinea seriale dell'USB
D2GPIO 26SicuroUtilizzabile anche come uscita DAC2
D3GPIO 25SicuroUtilizzabile anche come uscita DAC1
D4GPIO 17SicuroUsato anche come TX di Serial2
D5GPIO 16SicuroUsato anche come RX di Serial2
D6GPIO 27SicuroIngresso touch (T7)
D7GPIO 14Con cautelaAll'avvio emette un breve segnale PWM
D8GPIO 12Con cautelaPin di avvio: se è HIGH all'accensione, la scheda non parte
D9GPIO 13SicuroIngresso e uscita di uso generale
D10GPIO 5Con cautelaSPI SS; all'avvio emette un breve segnale PWM
D11GPIO 23SicuroSPI MOSI
D12GPIO 19SicuroSPI MISO
D13GPIO 18SicuroSPI SCK; a differenza dell'Uno qui non c'è un LED
A0GPIO 2Con cautelaADC2 (non legge con il Wi-Fi attivo), LED integrato, pin di avvio
A1GPIO 4Con cautelaADC2 (non legge con il Wi-Fi attivo)
A2GPIO 35Solo ingressoADC1, funziona insieme al Wi-Fi
A3GPIO 34Solo ingressoADC1, funziona insieme al Wi-Fi
A4GPIO 36 (VP)Solo ingressoADC1; non è SDA come sull'Uno
A5GPIO 39 (VN)Solo ingressoADC1; non è SCL come sull'Uno
SDAGPIO 21SicuroLinea dati I2C
SCLGPIO 22SicuroLinea di clock I2C
Qui A4 e A5 non sono I2C. Sull'Uno A4 e A5 fanno anche da SDA e SCL; sull'ESPDuino-32 sono collegati a GPIO 36 e 39 e funzionano solo come ingressi. Per display e sensori I2C usa i pin separati SDA (GPIO 21) e SCL (GPIO 22) accanto ad AREF.

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 driver motori L293D
Shield motori L293D: il suo registro a scorrimento 74HC595 lavora a 5 V e riconosce a malapena i segnali a 3,3 V dell'ESPDuino-32.
ShieldStatoPerché
CNC Shield V3 (A4988 / DRV8825)Di solito funzionaSTEP 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 funzionaI 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 parteUna 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 L293DInstabileIl 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 KeypadRischiosoI 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 polliciNon funzionaLe 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/A5Non funzionaSull'ESPDuino-32 l'I2C è sui pin SDA/SCL separati (GPIO 21/22)
Per capire se uno shield è compatibile, guarda il suo schema e fatti due domande: manda un segnale a 5 V verso qualche pin? Usa uno dei pin A2–A5 come uscita? Se la risposta è no in entrambi i casi, molto probabilmente funziona. Se anche una sola linea manda 5 V, metti in mezzo un partitore di tensione o un traslatore di livello logico.

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

  1. Installa nell'IDE Arduino il pacchetto schede esp32 di Espressif; i passaggi sono in Cos'è l'ESP32?
  2. 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.
  3. 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.
  4. Seleziona la porta della scheda; se il caricamento fallisce con Upload Speed a 921600, scendi a 115200.
  5. 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.
La scheda selezionata cambia il significato di A0. Con ESP32 Dev Module, l'A0 del tuo codice indica GPIO 36, cioè il pin che sull'ESPDuino-32 è marcato A4; con DOIT ESPduino32, a seconda della versione del core, A0 può non essere definito affatto e il compilatore si ferma con un errore. Il modo più semplice per evitare la confusione è scrivere sempre i numeri dei GPIO nel codice.

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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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

SorgenteTensioneNota
USB5 VSufficiente per lo sviluppo e per piccoli circuiti
Presa jackDi 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 VINLa tensione della presa jackPer alimentare la scheda da una sorgente esterna
Pin 5VUscita a 5 VAlimenta shield e moduli a 5 V; ricordati di abbassare i loro segnali a 3,3 V
Pin 3V3Uscita a 3,3 VPer 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.

Vedi tutti i progetti
LED Lampeggiante con ESP32
ES-1Principiante

LED Lampeggiante con ESP32

Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

4.7(37)
108
Lampeggio del LED interno dell'ESP32
ES-4Principiante

Lampeggio del LED interno dell'ESP32

Far lampeggiare il LED blu integrato nell'ESP32 DevKit V1. Non sono necessari componenti esterni! Il primo progetto da provare quando si acquista un ESP32. Il GPIO 2 è collegato al LED interno.

4.8(29)
54
Semaforo ESP32
ES-5Principiante

Semaforo ESP32

Simulazione di un vero semaforo con 3 LED rosso-giallo-verde. I tempi si avvicinano alla logica del traffico reale: rosso lungo, giallo corto, verde lungo. Classico esempio di controllo GPIO sequenziale.

4.4(22)
45
Lettura dell'intensità luminosa con il modulo LDR ESP32
ES-11Principiante

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.

4.6(36)
55
Luminosità di un LED con Potenziometro su ESP32 (Analogico → PWM)
ES-13Intermedio
Premium

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.

4.5(19)
32
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

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.

4.4(21)
38
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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

4.8(16)
26
ESP32 mDNS: accesso al dispositivo tramite bluegrays-esp.local (con schermo LCD)
ES-29Avanzato
Premium

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

4.8(14)
23