ESP32-S3 con Arduino: DevKitC N16R8, due porte USB e PSRAM
ESP32-S3 con Arduino: cosa significano N16R8 e N8R2, porta UART o USB, USB CDC On Boot, PSRAM OPI, LED RGB su GPIO48, impostazioni dell'IDE e tastiera USB HID.
L'ESP32-S3 è il chip dual core con Wi-Fi e Bluetooth di Espressif, potenziato con USB nativo, più pin, una PSRAM capiente e istruzioni vettoriali che accelerano i calcoli di intelligenza artificiale. La scheda che vedrai più spesso è l'ESP32-S3-DevKitC-1 con i suoi cloni: ha due porte USB-C, un pulsante BOOT, un pulsante RST e un solo LED RGB indirizzabile. Le sigle come N16R8 o N8R2 sulla scheda o sul modulo indicano la dimensione della memoria flash e della PSRAM, e sono la chiave per impostare correttamente l'Arduino IDE.
In questa guida scoprirai in cosa l'ESP32-S3 differisce dall'ESP32 classico, cosa significano i codici modello, quale delle due porte USB usare e quando, l'impostazione USB CDC On Boot che risolve il Monitor seriale vuoto e come scegliere la modalità PSRAM giusta (OPI o QSPI). Poi scriverai uno sketch di prova che accende il LED RGB integrato, un esempio che riserva un buffer da 1 MB nella PSRAM e un progetto HID che fa riconoscere l'ESP32-S3 al computer come una tastiera USB.
Che cos'è l'ESP32-S3? Le differenze con l'ESP32 classico
L'ESP32-S3 non è nato per sostituire l'ESP32 classico, ma per colmarne le lacune. La differenza più grande è l'USB nativo: il chip si collega direttamente al computer, senza convertitore USB-seriale in mezzo, e può presentarsi come porta seriale, tastiera, mouse o dispositivo MIDI. I core Xtensa LX7 aggiungono istruzioni vettoriali per l'elaborazione dei segnali e le reti neurali, e le interfacce dedicate per fotocamera (DVP) e display LCD parallelo semplificano i progetti di immagine. In cambio mancano due cose: non c'è il Bluetooth Classic (solo Bluetooth 5 LE) e non c'è un DAC per le uscite analogiche.
| Caratteristica | ESP32 (classico) | ESP32-S3 |
|---|---|---|
| Processore | Xtensa LX6, dual core, 240 MHz | Xtensa LX7, dual core, 240 MHz, istruzioni vettoriali |
| SRAM interna | 520 KB | 512 KB |
| PSRAM | Fino a 4 MB sui moduli WROVER | 2 MB Quad o 8 MB Octal a seconda del modulo |
| Bluetooth | Classic e BLE 4.2 | Solo BLE 5 (con supporto lungo raggio) |
| USB | Assente, serve un chip USB-seriale separato | USB OTG nativo e USB Serial/JTAG |
| GPIO utilizzabili | Circa 34 | 45 |
| Pin touch | 10 | 14 |
| DAC (uscita analogica) | 2 canali, 8 bit | Assente |
| Interfaccia fotocamera e display | Fotocamera via I2S (ESP32-CAM) | Interfacce dedicate DVP per fotocamera e LCD parallelo |

Codici modello dell'ESP32-S3: cosa vuol dire N16R8?
La sigla sulla schermatura metallica del modulo o nell'annuncio del venditore si legge facilmente: il numero dopo la N è la flash, quello dopo la R la PSRAM, entrambi in megabyte. N16R8 significa 16 MB di flash e 8 MB di PSRAM; N8R2, 8 MB di flash e 2 MB di PSRAM. La sigla dice anche come è collegata la PSRAM: nei moduli ESP32-S3-WROOM-1, R2 è una PSRAM Quad SPI (QSPI) a quattro linee e R8 una PSRAM Octal SPI (OPI) a otto linee. Una V finale (come in N32R8V) indica i moduli WROOM-2 con flash e PSRAM a 1,8 V. In base a queste informazioni scegli l'impostazione PSRAM nell'Arduino IDE.
| Sigla | Flash | PSRAM | Impostazione PSRAM nell'Arduino IDE |
|---|---|---|---|
| N8 | 8 MB | Assente | Disabled |
| N16 | 16 MB | Assente | Disabled |
| N4R2 | 4 MB | 2 MB Quad (QSPI) | QSPI PSRAM |
| N8R2 | 8 MB | 2 MB Quad (QSPI) | QSPI PSRAM |
| N8R8 | 8 MB | 8 MB Octal (OPI) | OPI PSRAM |
| N16R8 | 16 MB | 8 MB Octal (OPI) | OPI PSRAM |
| N32R8V (WROOM-2) | 32 MB Octal, 1,8 V | 8 MB Octal (OPI) | OPI PSRAM e Flash Mode: OPI 80MHz |
Due porte USB: la differenza tra UART e USB
Le due porte USB-C dell'ESP32-S3-DevKitC-1 non fanno lo stesso lavoro. Quella marcata UART (COM su alcuni cloni) va a un chip USB-seriale, un CP2102N o un CH343P a seconda della revisione della scheda, collegato a sua volta alla UART0 dell'ESP32-S3 (GPIO 43 e 44). È uguale all'unica porta delle schede ESP32 classiche e mette la scheda in modalità download automaticamente durante il caricamento. Quella marcata USB è invece collegata direttamente ai pin GPIO 19 (D-) e GPIO 20 (D+) del chip. Collegandoti lì, il computer vede l'USB dell'ESP32-S3 senza chip intermedi; Windows 10 e 11, macOS e Linux non hanno bisogno di driver.
| Caratteristica | Porta UART (COM) | Porta USB (nativa) |
|---|---|---|
| Collegata a | UART0 (GPIO 43 e 44) tramite un chip USB-seriale | Direttamente a GPIO 19 (D-) e GPIO 20 (D+) |
| Driver | CP210x o CH343, a seconda del chip | Non serve |
| Nome sul computer | COMx, /dev/cu.usbserial-… o /dev/cu.wchusbserial… | COMx (USB JTAG/serial debug unit), /dev/cu.usbmodem…, /dev/ttyACM0 |
| L'uscita di Serial arriva qui | Con USB CDC On Boot: Disabled | Con USB CDC On Boot: Enabled |
| Caricamento del codice | Sempre, con reset automatico | Quasi sempre; se lo sketch si blocca o va in deep sleep, la porta può sparire |
| Tastiera e mouse USB (HID) | Non possibile | Possibile con USB Mode: USB-OTG (TinyUSB) |
L'impostazione USB CDC On Boot: perché il Monitor seriale è vuoto?
È il problema più comune di chi usa l'ESP32-S3: lo sketch si carica, la scheda funziona, ma nel Monitor seriale non arriva nemmeno una riga. Il motivo è la porta su cui scrive l'oggetto Serial del tuo sketch. Con Strumenti > USB CDC On Boot su Disabled, Serial scrive sulla UART0, cioè sulla porta UART; se il cavo è nella porta USB, i messaggi non ti arrivano mai. Con Enabled, Serial viene reindirizzato alla porta USB nativa. La regola è semplice: scegli l'impostazione in base alla porta in cui hai inserito il cavo. Enabled per la porta USB, Disabled per la porta UART. Se con Enabled il codice contiene un'attesa come while (!Serial), quel ciclo non finisce mai quando la scheda non è collegata a un computer; usa invece qualche secondo di ritardo o un timeout.
Impostazioni dell'Arduino IDE (ESP32S3 Dev Module)
| Menu | Per N16R8 | Per N8R2 | Nota |
|---|---|---|---|
| Scheda | ESP32S3 Dev Module | ESP32S3 Dev Module | Si sceglie questa anche per i cloni |
| USB CDC On Boot | Enabled | Enabled | Disabled se usi la porta UART |
| Flash Size | 16MB (128Mb) | 8MB (64Mb) | Il valore N della sigla |
| Partition Scheme | 16M Flash (3MB APP/9.9MB FATFS) | 8M with spiffs (3MB APP/1.5MB SPIFFS) | Per sketch grandi e un file system |
| PSRAM | OPI PSRAM | QSPI PSRAM | Il valore R della sigla |
| Flash Mode | QIO 80MHz | QIO 80MHz | OPI 80MHz sui moduli WROOM-2 con V |
| USB Mode | Hardware CDC and JTAG | Hardware CDC and JTAG | USB-OTG (TinyUSB) per tastiera o mouse USB |
| Upload Mode | UART0 / Hardware CDC | UART0 / Hardware CDC | Va bene il valore predefinito |
Il supporto all'ESP32-S3 fa parte del pacchetto esp32 di Espressif che installi dal Gestore schede; non serve un pacchetto a parte. I passaggi sono nella guida come installare Arduino IDE. I nomi dei menu sono gli stessi con il core 2.x e con il 3.x. Se sbagli l'impostazione PSRAM vedrai uno di due sintomi: con Disabled lo sketch funziona ma si comporta come se la PSRAM non ci fosse; con QSPI PSRAM su una scheda con PSRAM Octal, all'avvio la scheda mostra PSRAM ID read error e non può usare la PSRAM.
Primo test: LED RGB, porta seriale e PSRAM
Il LED RGB della DevKitC-1 è un LED indirizzabile di tipo WS2812; si comanda con un solo pin e non si accende con digitalWrite come un LED normale, ma inviandogli dati di colore. Il core Arduino per ESP32 offre una funzione pronta: neopixelWrite nella versione 2.x e rgbLedWrite nella 3.x. Sulla revisione 1.0 della scheda e sulla maggior parte dei cloni il LED è sul GPIO 48; sulla revisione 1.1 di Espressif è sul GPIO 38, quindi controlla la revisione stampata sul retro della scheda. Alcuni cloni hanno accanto al LED un piccolo ponticello a saldare con la scritta RGB; se il LED non si accende mai, quel ponticello potrebbe essere aperto. Lo sketch qui sotto accende il LED rosso, verde e blu in sequenza e all'avvio scrive nel Monitor seriale la dimensione della flash e della PSRAM.
1// ESP32-S3: dahili RGB LED, seri port, PSRAM ve flaş testi
2// ESP32-S3: onboard RGB LED, serial port, PSRAM and flash test
3const int RGB_PIN = 48; // DevKitC-1 v1.0 ve çoğu klon: 48, v1.1: 38 / v1.0 and most clones: 48, v1.1: 38
4
5void setRgb(uint8_t r, uint8_t g, uint8_t b) {
6#if ESP_ARDUINO_VERSION_MAJOR >= 3
7 rgbLedWrite(RGB_PIN, r, g, b); // çekirdek 3.x / core 3.x
8#else
9 neopixelWrite(RGB_PIN, r, g, b); // çekirdek 2.x / core 2.x
10#endif
11}
12
13void setup() {
14 Serial.begin(115200);
15 delay(1500); // USB'nin açılmasını bekle / give the USB port time to come up
16 Serial.println("ESP32-S3 hazir / ready");
17 Serial.printf("Flash: %lu bayt / bytes\n", (unsigned long)ESP.getFlashChipSize());
18 Serial.printf("PSRAM: %lu bayt / bytes\n", (unsigned long)ESP.getPsramSize()); // 0 ise menüden aç / if 0, enable it in the menu
19}
20
21void loop() {
22 setRgb(40, 0, 0); delay(500); // kırmızı / red
23 setRgb(0, 40, 0); delay(500); // yeşil / green
24 setRgb(0, 0, 40); delay(500); // mavi / blue
25 setRgb(0, 0, 0); delay(500); // kapalı / off
26}Su una scheda N16R8 impostata correttamente, il Monitor seriale mostra 16.777.216 byte nella riga Flash (il valore scelto nel menu Flash Size) e un valore vicino a 8 MB nella riga PSRAM; la piccola differenza è lo spazio che il gestore della PSRAM tiene per sé. Se la riga PSRAM mostra 0, controlla l'impostazione PSRAM nel menu. Se non arriva nulla, imposta USB CDC On Boot in base alla porta in cui hai inserito il cavo.
Usare la PSRAM: buffer grandi
I 512 KB di memoria interna dell'ESP32-S3 sono condivisi tra lo stack Wi-Fi, il Bluetooth e il tuo codice, e un array grande li esaurisce in fretta. Per questo la PSRAM è così importante: i buffer dei fotogrammi di una fotocamera, un buffer di disegno a schermo intero per un display a colori, registrazioni audio o grandi documenti JSON non entrano nella memoria interna, ma stanno comodamente in 8 MB di PSRAM. In Arduino la memoria in PSRAM si riserva con ps_malloc; la maggior parte delle librerie ESP32 (come il driver della fotocamera) usa già la PSRAM da sola. La PSRAM è più lenta della memoria interna, quindi tieni le variabili piccole e usate spesso nella RAM normale.
1// PSRAM'de 1 MB tampon ayırmak / allocating a 1 MB buffer in PSRAM
2void setup() {
3 Serial.begin(115200);
4 delay(1500);
5 if (!psramFound()) {
6 Serial.println("PSRAM yok: Araçlar > PSRAM ayarını kontrol et / no PSRAM: check Tools > PSRAM");
7 return;
8 }
9 const size_t SIZE = 1024 * 1024; // 1 MB, dahili RAM'e sığmaz / does not fit in internal RAM
10 uint8_t* buffer = (uint8_t*)ps_malloc(SIZE); // PSRAM'den ayır / allocate from PSRAM
11 if (buffer == NULL) {
12 Serial.println("Ayrılamadı / allocation failed");
13 return;
14 }
15 memset(buffer, 0xA5, SIZE); // tamponu doldur / fill the buffer
16 Serial.printf("1 MB tampon hazır, boş PSRAM / buffer ready, free PSRAM: %lu\n", (unsigned long)ESP.getFreePsram());
17 free(buffer);
18}
19
20void loop() {
21}Perché l'ESP32-S3? Fotocamera, intelligenza artificiale e USB HID
- Progetti con fotocamera: l'interfaccia DVP dedicata e gli 8 MB di PSRAM consentono risoluzioni e frame rate più alti con fotocamere OV2640 o OV5640. Per un confronto con la soluzione classica guarda la guida ESP32-CAM.
- Intelligenza artificiale e audio: grazie alle istruzioni vettoriali, le librerie ESP-DL ed ESP-SR di Espressif eseguono sul chip compiti come il riconoscimento dei volti e della parola di attivazione.
- USB HID: la scheda si collega al computer come tastiera, mouse, gamepad o dispositivo MIDI; è ideale per tastierini di macro e telecomandi per presentazioni.
- Display a colori: l'interfaccia LCD parallela e la PSRAM rendono più facile disegnare interfacce fluide su grandi display TFT.
- Più pin: 45 GPIO e 14 pin touch danno respiro ai progetti con molti sensori e pulsanti.
- Bluetooth 5 LE: supporta la modalità a lungo raggio e i 2 Mbps; l'uso del BLE è spiegato nella guida Bluetooth BLE dell'ESP32.
USB HID: trasformare l'ESP32-S3 in una tastiera
Una delle cose più divertenti che l'ESP32 classico non sa fare è far riconoscere l'ESP32-S3 al computer come una vera tastiera USB. Per farlo imposta Strumenti > USB Mode su USB-OTG (TinyUSB) e collega il cavo alla porta marcata USB. Lo sketch qui sotto scrive Hello e preme Invio ogni volta che premi il pulsante BOOT della scheda (GPIO 0). L'USB HID non invia lettere ma posizioni dei tasti, che il computer traduce secondo il proprio layout di tastiera. Con il layout italiano lettere e numeri coincidono con quelli americani, ma alcuni simboli e segni di punteggiatura escono diversi; per questo l'esempio usa lettere che cadono sugli stessi tasti in tutti i layout.
1// ESP32-S3 USB klavye: BOOT düğmesine basınca bilgisayara "Hello" yazar
2// ESP32-S3 USB keyboard: types "Hello" on the computer when you press BOOT
3// Araçlar > USB Mode: "USB-OTG (TinyUSB)" seç, kabloyu "USB" yazan porta tak
4// Tools > USB Mode: select "USB-OTG (TinyUSB)", plug the cable into the port marked "USB"
5#if !(defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32S2)) || ARDUINO_USB_MODE
6// Bu kart ya da bu USB Mode ayarı USB HID desteklemez / no USB HID on this board or USB Mode
7void setup() {
8 Serial.begin(115200);
9}
10
11void loop() {
12 Serial.println("USB Mode: USB-OTG (TinyUSB) gerekli / required");
13 delay(2000);
14}
15#else
16#include "USB.h"
17#include "USBHIDKeyboard.h"
18
19USBHIDKeyboard Keyboard;
20const int BUTTON_PIN = 0; // BOOT düğmesi / BOOT button
21
22void setup() {
23 pinMode(BUTTON_PIN, INPUT_PULLUP);
24 Keyboard.begin();
25 USB.begin();
26}
27
28void loop() {
29 if (digitalRead(BUTTON_PIN) == LOW) {
30 Keyboard.print("Hello"); // klavye düzeninden bağımsız harfler / layout-safe letters
31 Keyboard.write(KEY_RETURN);
32 while (digitalRead(BUTTON_PIN) == LOW) {
33 delay(10); // bırakılana kadar bekle / wait until released
34 }
35 delay(50); // titreşim payı / debounce margin
36 }
37}
38#endifPin dell'ESP32-S3: a cosa fare attenzione
| Pin | Stato | Nota |
|---|---|---|
| GPIO 0, 3, 45, 46 | Usare con cautela | Pin di avvio (strapping); conta il loro livello all'accensione |
| GPIO 19, 20 | Riservati all'USB | Linee D- e D+ dell'USB nativo |
| GPIO 43, 44 | UART0 | TX e RX della porta UART |
| GPIO 35, 36, 37 | Da non usare sui moduli R8 | Collegati alla PSRAM Octal |
| GPIO 26–32 | Non portati all'esterno | Collegati a flash e PSRAM dentro il modulo |
| GPIO 1–10 | ADC1 | Letture analogiche affidabili anche con il Wi-Fi acceso |
| GPIO 11–20 | ADC2 | Poco affidabili insieme al Wi-Fi |
| GPIO 1–14 | Touch | A differenza dell'ESP32 classico, il valore sale al tocco |
| GPIO 8 e 9 | I2C | SDA e SCL predefiniti nel core Arduino |
| GPIO 47, 48 | 1,8 V sui moduli V | Lavorano a 1,8 V sui WROOM-2 |
Problemi comuni e soluzioni
| Sintomo | Causa | Soluzione |
|---|---|---|
| Il Monitor seriale è vuoto | Cavo nella porta USB, USB CDC On Boot: Disabled | Imposta Enabled o sposta il cavo nella porta UART |
| La porta sparisce dopo il caricamento | Lo sketch si è bloccato, è in deep sleep o USB Mode è su USB-OTG | Premi RST tenendo premuto BOOT, poi carica |
| Riavvii continui o PSRAM ID read error | L'impostazione PSRAM non corrisponde al modulo | Scegli OPI PSRAM per R8 e QSPI PSRAM per R2 |
| Il LED RGB non si accende | Scheda revisione 1.1 (GPIO 38) o ponticello RGB aperto | Cambia RGB_PIN, chiudi il ponticello con lo stagno |
| Serial Bluetooth not available or not enabled | L'ESP32-S3 non ha il Bluetooth Classic | Usa la libreria BLE al posto di BluetoothSerial |
| 'dacWrite' was not declared in this scope | L'ESP32-S3 non ha un DAC | Usa il PWM con un filtro RC o un amplificatore audio I2S |
| Failed to connect to ESP32-S3 | La scheda non è entrata in modalità download | Entra in modalità download con BOOT e RST; dettagli nella guida ESP32 Failed to Connect |
Una volta capite le due porte e l'impostazione PSRAM, l'ESP32-S3 è facile da usare quanto l'ESP32 classico e molto più capace. Dato che il LED RGB della scheda è in realtà un WS2812 da un solo pixel, il progetto Controllo striscia WS2812B NeoPixel con ESP32 dell'app BlueGrays è un ottimo passo successivo; puoi anche seguire passo passo gli altri progetti ESP32 dell'app, con schema dei collegamenti e codice pronto, e adattarli a questa scheda spostando i pin su quelli che esistono sull'S3.
Domande frequenti
Cosa significa ESP32-S3 N16R8?
N16 indica che il modulo ha 16 MB di memoria flash e R8 che ha 8 MB di PSRAM. Nei moduli ESP32-S3-WROOM-1 la PSRAM R8 è collegata in Octal SPI (OPI), quindi nell'Arduino IDE devi scegliere OPI PSRAM per PSRAM e 16MB per Flash Size.
Come si programma l'ESP32-S3 con Arduino?
Installa il pacchetto esp32 di Espressif dal Gestore schede e scegli ESP32S3 Dev Module. Poi imposta Flash Size e PSRAM in base alla sigla del modulo (per esempio 16MB e OPI PSRAM per un N16R8) e metti USB CDC On Boot su Enabled se colleghi il cavo alla porta USB.
Perché l'ESP32-S3 non mostra nulla nel Monitor seriale?
Molto probabilmente il cavo è nella porta USB mentre USB CDC On Boot è su Disabled, quindi l'uscita di Serial va alla porta UART. Imposta Enabled e ricarica lo sketch, oppure sposta il cavo nella porta UART e usa nel Monitor seriale la stessa velocità dello sketch.
Come si attiva la PSRAM dell'ESP32-S3?
Nell'Arduino IDE, in Strumenti > PSRAM, scegli l'opzione adatta al modulo: OPI PSRAM per i moduli R8, QSPI PSRAM per i moduli R2. Nel codice psramFound() ti dice se la PSRAM è stata rilevata e ps_malloc() vi riserva buffer grandi.
L'ESP32-S3 supporta il Bluetooth Classic?
No. L'ESP32-S3 supporta solo il Bluetooth 5 LE, quindi la libreria BluetoothSerial e l'accoppiamento diretto con dispositivi Classic come l'HC-05 non funzionano. Per comunicare con lo smartphone usa la libreria BLE; se ti serve il Bluetooth Classic, scegli l'ESP32 classico.
Su quale pin è il LED integrato dell'ESP32-S3?
Il LED integrato dell'ESP32-S3-DevKitC-1 è un LED RGB indirizzabile, collegato al GPIO 48 nella revisione 1.0 e nella maggior parte dei cloni e al GPIO 38 nella revisione 1.1. Non si accende con digitalWrite: gli si invia un colore con neopixelWrite nel core 2.x o rgbLedWrite nel core 3.x.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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.

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.

Controllo della striscia LED NeoPixel WS2812B con ESP32
I LED indirizzabili WS2812B (NeoPixel) sono LED RGB intelligenti collegabili in catena e controllati da un solo pin dati. Pilotiamo una striscia WS2812B da 8 LED con la libreria Adafruit_NeoPixel e creiamo un arcobaleno fluido. La logica a 3,3 V dell'ESP32 va bene con quasi tutti i WS2812B; in caso di instabilità mostriamo la soluzione con una resistenza in serie da 470Ω e un condensatore da 1000µF. L'animazione sposta la tonalità nello spazio HSV.

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

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

