ESP32 30 pin vs 38 pin: differenze, pinout, WROOM e CP2102
ESP32 30 pin vs 38 pin: pinout a confronto, perché non entra nella breadboard, WROOM o WROVER, CP2102 o CH340 e quale scheda scegliere nell'Arduino IDE.
La differenza tra un ESP32 30 pin vs 38 pin è più piccola di quanto sembri: entrambe le schede montano di solito lo stesso modulo ESP32-WROOM-32, eseguono lo stesso codice e nell'Arduino IDE si impostano allo stesso modo, come "ESP32 Dev Module". La scheda a 38 pin porta fuori otto pin in più: il GPIO 0, i GPIO 6–11 collegati alla memoria flash e un GND in più. Dato che i pin della flash non si possono comunque usare, la vera differenza spesso si riduce al GPIO 0, all'ordine dei pin sulla scheda e a come si sistema sulla breadboard.

In questo articolo mettiamo a confronto il pinout delle due schede, spieghiamo perché si sistemano male sulla breadboard e come risolvere, cosa significano le sigle WROOM e WROVER sullo schermo metallico, come capire se il tuo chip USB è un CP2102 o un CH340 e quali impostazioni scegliere nell'Arduino IDE, passo passo. Alla fine trovi uno sketch di prova che stampa il modello del chip, la dimensione della flash e la PSRAM della tua scheda.
Che differenza c'è tra l'ESP32 a 30 pin e a 38 pin?
Il modulo ESP32-WROOM-32 ha di per sé 38 piazzole di saldatura. Il produttore della scheda di sviluppo decide quali portare sui connettori laterali. L'ESP32-DevKitC di Espressif e i suoi cloni offrono 2×19 pin, uno per ogni piazzola. La DOIT ESP32 DevKit V1 e simili lasciano fuori i pin della flash, pericolosi, e il GPIO 0 del pulsante BOOT, e si accontentano di 2×15 = 30 pin. In altre parole, la scheda a 38 pin non è più potente: porta solo all'esterno più piazzole.
| Caratteristica | Scheda a 30 pin (DevKit V1) | Scheda a 38 pin (DevKitC e cloni) |
|---|---|---|
| Modulo | Di solito ESP32-WROOM-32 / 32D / 32E | ESP32-WROOM-32 / 32E, alcune con WROVER |
| Connettori | 2 × 15 | 2 × 19 |
| GPIO accessibili | 25 | 32 (6 sono della flash) |
| GPIO davvero utilizzabili | 25 | 26 |
| GPIO 0 | Non su un pin, solo sul pulsante BOOT | Disponibile come pin |
| Pin della flash (GPIO 6–11) | No | Sì (CLK, SD0–SD3, CMD), non utilizzabili |
| Pin GND | 2 | 3 |
| Pin di alimentazione | VIN e 3V3 | 5V e 3V3 |
| LED utente | Quasi sempre LED blu sul GPIO 2 | Nessuno sulla scheda Espressif, GPIO 2 su alcuni cloni |
| Scheda nell'Arduino IDE | ESP32 Dev Module o DOIT ESP32 DEVKIT V1 | ESP32 Dev Module |
La conclusione della tabella è semplice: sei dei pin in più della scheda a 38 pin non li userai in nessun progetto, e l'unico vero guadagno è il GPIO 0. Per questo l'idea "più pin, scheda migliore" non vale per l'ESP32. A guidare la scelta non deve essere il numero di pin, ma il tuo montaggio su breadboard, gli schemi che segui e la scheda di espansione che pensi di usare.
Pinout: dove si trova ogni pin sulle due schede?
La tabella qui sotto mostra l'ordine dei pin dall'alto verso il basso, con l'antenna in alto, la presa USB in basso e i componenti rivolti verso di te. Sulle DevKit V1 i pin sono marcati come "D23" o "TX2"; ricorda che nel codice si scrive il numero di GPIO (23, 17), non l'etichetta. Puoi vedere la mappa completa della tua scheda anche nello strumento Pinout.
| Posizione | 30 pin sinistra | 30 pin destra | 38 pin sinistra | 38 pin destra |
|---|---|---|---|---|
| 1 | EN | D23 | 3V3 | GND |
| 2 | VP (GPIO 36) | D22 | EN | GPIO 23 |
| 3 | VN (GPIO 39) | TX0 (GPIO 1) | SVP (GPIO 36) | GPIO 22 |
| 4 | D34 | RX0 (GPIO 3) | SVN (GPIO 39) | TX (GPIO 1) |
| 5 | D35 | D21 | GPIO 34 | RX (GPIO 3) |
| 6 | D32 | D19 | GPIO 35 | GPIO 21 |
| 7 | D33 | D18 | GPIO 32 | GND |
| 8 | D25 | D5 | GPIO 33 | GPIO 19 |
| 9 | D26 | TX2 (GPIO 17) | GPIO 25 | GPIO 18 |
| 10 | D27 | RX2 (GPIO 16) | GPIO 26 | GPIO 5 |
| 11 | D14 | D4 | GPIO 27 | GPIO 17 |
| 12 | D12 | D2 | GPIO 14 | GPIO 16 |
| 13 | D13 | D15 | GPIO 12 | GPIO 4 |
| 14 | GND | GND | GND | GPIO 0 |
| 15 | VIN | 3V3 | GPIO 13 | GPIO 2 |
| 16 | - | - | SD2 (GPIO 9) | GPIO 15 |
| 17 | - | - | SD3 (GPIO 10) | SD1 (GPIO 8) |
| 18 | - | - | CMD (GPIO 11) | SD0 (GPIO 7) |
| 19 | - | - | 5V | CLK (GPIO 6) |
I lati sinistri si somigliano molto, quelli destri no: la scheda a 30 pin ha GND e 3V3 nell'angolo in basso a destra, mentre quella a 38 pin nella stessa zona ha i GPIO 0, 2, 15 e i pin della flash. Se riproduci uno schema pensato per una scheda copiando "la stessa posizione" sull'altra, finisci sui pin sbagliati. Sui cloni l'ordine può variare leggermente; fai sempre riferimento alle scritte stampate sulla tua scheda.
Il problema della breadboard e come risolverlo
Una breadboard standard ha, su ogni lato del canale centrale, cinque fori collegati tra loro per fila (a–e e f–j). La scheda ESP32 si appoggia a cavallo del canale e copre tutto ciò che sta tra i suoi due connettori. Le schede con 22,86 mm (0,9 pollici) tra le file di pin lasciano un foro libero su ogni lato. Quelle con 25,4 mm (1 pollice) lasciano un solo foro da un lato, e dall'altro non puoi collegare nemmeno un cavetto. La larghezza dipende dal produttore; si trovano entrambe le larghezze tra le schede a 30 e a 38 pin, ma la più comune è quella larga. Se hai già la scheda, misura con un righello la distanza tra le due file di pin; prima di comprare, controlla le dimensioni del prodotto.
- Due breadboard affiancate: togli la barra di alimentazione laterale da una, unisci le due breadboard e metti una fila di pin della scheda su ciascuna. Accanto a ogni pin restano cinque fori; è la soluzione più comoda ed economica.
- Cavetti jumper femmina-maschio: non mettere la scheda sulla breadboard e collegati direttamente ai suoi pin con cavetti a terminale femmina. È rapido per piccole prove, ma i cavetti si staccano facilmente.
- Scheda di espansione (breakout): queste basi con morsetti a vite, o con GND e 3V3 accanto a ogni pin, ti liberano dalla breadboard. Si producono separatamente per schede a 30 e a 38 pin; compra quella con numero di pin e larghezza uguali alla tua scheda.
- Scegliere una scheda stretta: se lavori spesso con la breadboard, scegli una scheda con 22,86 mm tra le file di pin. Se la pagina del prodotto non riporta questa misura, chiedi al venditore.
WROOM e WROVER: cosa dice lo schermo metallico?
L'etichetta del modulo con schermo metallico riporta il nome del modello. I moduli WROOM contengono solo il processore e la memoria flash. I moduli WROVER sono un po' più lunghi e hanno in più una RAM esterna chiamata PSRAM. I modelli con la "U" (WROOM-32U, WROVER-IE) non hanno l'antenna sul circuito stampato, ma un piccolo connettore U.FL per un'antenna esterna. La D o la E alla fine del nome indica la versione del chip interno.
| Modulo | Chip | Flash | PSRAM | Nota |
|---|---|---|---|---|
| ESP32-WROOM-32 | ESP32-D0WDQ6 | 4 MB | No | Prima versione; diffusa sulle schede vecchie ed economiche |
| ESP32-WROOM-32D | ESP32-D0WD | 4 MB (esistono versioni da 8 e 16 MB) | No | Per anni il modello più diffuso |
| ESP32-WROOM-32E | ESP32-D0WD-V3 | 4, 8 o 16 MB | No | Schede recenti; il silicio V3 corregge difetti del chip precedente |
| ESP32-WROOM-32U / 32UE | Come WROOM-32D / 32E | 4 MB e oltre | No | Connettore U.FL per antenna esterna |
| ESP32-WROVER-E / IE | ESP32-D0WD-V3 | 4, 8 o 16 MB | 2 o 8 MB | Modulo più lungo; GPIO 16 e 17 riservati alla PSRAM |
Per quasi tutti i progetti, come leggere sensori, comandare un relè, far girare un web server o inviare avvisi su Telegram, un WROOM basta e avanza: i 520 KB di RAM interna dell'ESP32 sono più che sufficienti. La PSRAM fa la differenza nei lavori che chiedono molta memoria, come le immagini di una fotocamera, le interfacce grafiche su grandi display a colori o la registrazione audio. Per usare la PSRAM di una scheda WROVER devi attivare PSRAM: Enabled nell'Arduino IDE; se è disattivata, la memoria non compare nemmeno.
Chip USB-seriale: CP2102 o CH340?
L'ESP32 da solo non parla USB; a fare da interprete con il computer è il piccolo chip accanto alla presa USB. Da quel chip dipendono il nome con cui la scheda compare sul computer e il driver di cui ha bisogno. Se la scritta sul chip è troppo piccola per leggerla, guardane la forma:
| Chip | Aspetto | Nome in Windows | ID USB (VID:PID) | Driver |
|---|---|---|---|---|
| CP2102 / CP2104 (Silicon Labs) | Quadrato, senza piedini (QFN) | Silicon Labs CP210x USB to UART Bridge | 10C4:EA60 | Di solito automatico; altrimenti driver CP210x VCP |
| CH340C / CH340G (WCH) | Rettangolare, piedini su due lati (SOP-16) | USB-SERIAL CH340 | 1A86:7523 | Di solito automatico; altrimenti driver CH341SER |
| CH9102F (WCH) | Piccolo e quadrato, senza piedini (QFN) | USB-Enhanced-SERIAL CH9102 | 1A86:55D4 | Driver CH343SER sui sistemi più vecchi |
In Windows apri Gestione dispositivi e guarda in Porte (COM e LPT); la voce che compare quando colleghi la scheda ti dice il chip. Se appare come "Dispositivo sconosciuto", fai clic destro, vai su Proprietà > Dettagli > ID hardware e confronta VID e PID con la tabella. Le versioni recenti di macOS e Linux riconoscono la maggior parte di questi chip senza driver aggiuntivi; la porta compare come /dev/cu.usbserial-... su macOS e come /dev/ttyUSB0 su Linux. Sulle schede con CH340G vedrai accanto al chip un piccolo quarzo da 12 MHz; il CH340C non ne ha bisogno. Per approfondire driver e porte, leggi l'articolo Convertitore USB-TTL.
Scegliere la scheda e le impostazioni giuste nell'Arduino IDE
- Nel Gestore schede cerca esp32 e installa il pacchetto di Espressif Systems. Per la prima installazione segui i passi di Cos'è l'ESP32?.
- In Strumenti > Scheda > esp32 scegli ESP32 Dev Module. Questa opzione funziona con tutte le schede WROOM a 30 e a 38 pin.
- Per la scheda a 30 pin puoi scegliere anche DOIT ESP32 DEVKIT V1; l'unica differenza è che definisce la costante LED_BUILTIN come GPIO 2.
- Se la tua scheda ha un WROVER, scegli ESP32 Wrover Module oppure imposta l'opzione PSRAM su Enabled in ESP32 Dev Module.
- In Strumenti > Porta scegli la porta della scheda e carica il codice. Se il caricamento si ferma su "Connecting...", tieni premuto il pulsante BOOT e rilascialo quando inizia il trasferimento.
| Impostazione del menu Strumenti | Valore consigliato | Quando cambiarla? |
|---|---|---|
| Upload Speed | 921600 | 115200 se il caricamento si interrompe a metà |
| CPU Frequency | 240MHz (WiFi/BT) | 80 o 160 MHz se devi risparmiare batteria |
| Flash Mode | QIO | DIO se un clone non si avvia |
| Flash Size | 4MB (32Mb) | La dimensione reale nei moduli da 8 o 16 MB |
| Partition Scheme | Default 4MB with spiffs | Huge APP (3MB No OTA) se lo sketch non ci sta |
| PSRAM | Disabled | Enabled sulle schede con modulo WROVER |
Uno sketch che riconosce la tua scheda: modello, flash e PSRAM
Invece di indovinare quale chip, quanta flash e quanta PSRAM ha la tua scheda, puoi chiederlo direttamente a lei. Carica questo sketch e apri il Monitor Seriale a 115200 baud:
1// Kartını tanı: yonga modeli, flaş, PSRAM ve MAC / Identify your board: chip model, flash, PSRAM and MAC
2void setup() {
3 Serial.begin(115200);
4 delay(1000); // Seri Monitör'ün açılmasını bekle / wait for the Serial Monitor
5
6 Serial.printf("Yonga / Chip: %s, rev %d, %d cekirdek / cores\n",
7 ESP.getChipModel(), ESP.getChipRevision(), ESP.getChipCores());
8 Serial.printf("CPU: %lu MHz\n", (unsigned long)ESP.getCpuFreqMHz());
9 Serial.printf("Flas / Flash: %lu MB\n", (unsigned long)(ESP.getFlashChipSize() / (1024 * 1024)));
10 Serial.printf("PSRAM: %lu KB\n", (unsigned long)(ESP.getPsramSize() / 1024)); // WROOM: 0, WROVER: > 0 (PSRAM: Enabled)
11
12 uint64_t mac = ESP.getEfuseMac(); // fabrikada yazılan MAC / factory MAC
13 Serial.print("MAC: ");
14 for (int i = 0; i < 6; i++) {
15 Serial.printf("%02X", (unsigned int)((mac >> (8 * i)) & 0xFF));
16 if (i < 5) Serial.print(':');
17 }
18 Serial.println();
19}
20
21void loop() {
22}Se nell'uscita leggi ESP32-D0WDQ6, il modulo è quasi certamente il WROOM-32 originale; ESP32-D0WD indica di solito un WROOM-32D e ESP32-D0WD-V3 (rev 3) un WROOM-32E o un WROVER-E. Se la riga PSRAM è maggiore di zero, la tua scheda è un WROVER; ma questo valore compare solo con l'opzione PSRAM attiva. Se la flash supera i 4 MB, puoi impostare Flash Size sulla dimensione reale e fare spazio a programmi più grandi. L'indirizzo MAC ti aiuta a trovare la scheda nell'elenco dei dispositivi collegati del router.
LED integrato e prova dei pin
La maggior parte delle DevKit V1 a 30 pin ha un LED blu sul GPIO 2, diverso dal LED rosso di alimentazione che resta acceso finché la scheda è alimentata. La DevKitC a 38 pin di Espressif non ha un LED utente, mentre alcuni cloni lo hanno anch'essi sul GPIO 2. Lo sketch qui sotto porta a HIGH, uno alla volta per un secondo, i pin di uscita sicuri presenti su entrambe le schede e scrive nel Monitor Seriale quale è attivo. Collega un LED a GND tramite una resistenza da 220 Ω e tocca i pin con l'altro terminale per verificare che le scritte della tua scheda siano corrette.
1// 30 ve 38 pinli kartta ortak, güvenli çıkış pinleri / safe output pins found on both 30- and 38-pin boards
2const int LED_PIN = 2; // DevKit V1 mavi LED; "ESP32 Dev Module" seçiliyken LED_BUILTIN tanımlı değildir
3 // DevKit V1 blue LED; LED_BUILTIN is not defined when "ESP32 Dev Module" is selected
4const int pins[] = {4, 5, 13, 14, 16, 17, 18, 19, 21, 22, 23, 25, 26, 27, 32, 33}; // WROVER'da 16 ve 17'yi sil / remove 16 and 17 on WROVER
5const int count = sizeof(pins) / sizeof(pins[0]);
6
7void setup() {
8 Serial.begin(115200);
9 pinMode(LED_PIN, OUTPUT);
10 for (int i = 0; i < count; i++) pinMode(pins[i], OUTPUT);
11}
12
13void loop() {
14 for (int i = 0; i < count; i++) {
15 Serial.printf("GPIO %d -> HIGH\n", pins[i]); // LED + 220 Ω ile bu pini yokla / probe this pin with an LED + 220 Ω
16 digitalWrite(LED_PIN, HIGH); // dahili LED test sırasında yanar / onboard LED lights during the test
17 digitalWrite(pins[i], HIGH);
18 delay(1000);
19 digitalWrite(pins[i], LOW);
20 digitalWrite(LED_PIN, LOW);
21 delay(200);
22 }
23}Quali pin sono sicuri? Sulle due schede le regole sono le stesse
| Pin | Stato | Perché? |
|---|---|---|
| GPIO 6–11 | Da non usare | Collegati alla flash; accessibili solo sulla scheda a 38 pin |
| GPIO 0 | Con attenzione | Collegato al pulsante BOOT; se è LOW all'avvio, la scheda entra in modalità caricamento |
| GPIO 2 | Con attenzione | Deve essere LOW o libero durante il caricamento; sulla DevKit V1 comanda il LED integrato |
| GPIO 12 | Con attenzione | Se è HIGH all'avvio, la flash viene alimentata a 1,8 V e la scheda non parte |
| GPIO 15 | Con attenzione | Se è LOW all'avvio, i messaggi di avvio vengono silenziati |
| GPIO 1 e 3 | Con attenzione | TX0 e RX0 della connessione seriale USB |
| GPIO 34, 35, 36, 39 | Solo ingresso | Non possono essere uscite e non hanno pull-up interno |
| GPIO 16 e 17 | Da evitare su WROVER | Sul WROVER vanno alla PSRAM; sul WROOM sono liberi (TX2 e RX2) |
| GPIO 4, 5, 13, 14, 18, 19, 21–23, 25–27, 32, 33 | Sicuri | Ingressi e uscite di uso generale |
Pin di alimentazione: VIN, 5V e 3V3
Il pin VIN della scheda a 30 pin e il 5V della scheda a 38 pin svolgono lo stesso compito: sono collegati alla linea a 5 V dell'USB e alimentano il regolatore a 3,3 V della scheda (di solito un AMS1117). Per usare la scheda senza USB fornisci 5 V da questo pin; il regolatore ha bisogno di almeno 4,5 V circa e scalda molto con tensioni più alte, quindi tra 5 e 6 V è l'intervallo più sicuro. Il pin 3V3 è l'uscita del regolatore e da lì puoi alimentare i sensori. Poiché l'ESP32 assorbe picchi fino a 250 mA quando accende il Wi-Fi, non prelevare più di qualche centinaio di mA dal 3V3. Alimentare VIN con il cavo USB collegato può anche mettere in contatto due alimentazioni; scegline una.
Se usi MicroPython
Le schede a 30 e a 38 pin usano lo stesso firmware MicroPython: basta installare la versione generica per ESP32 di Espressif, oppure quella con supporto PSRAM (SPIRAM) per le schede WROVER. Nella shell di Thonny queste poche righe mostrano la dimensione della flash e la frequenza del processore, e accendono il LED della DevKit V1:
1import esp, machine
2
3print("Flas / Flash:", esp.flash_size() // (1024 * 1024), "MB")
4print("CPU:", machine.freq() // 1000000, "MHz")
5
6led = machine.Pin(2, machine.Pin.OUT) # DevKit V1 dahili LED / onboard LED
7led.on()Quale comprare? Guida rapida alla scelta
- Per esercitarti o insegnare con la breadboard: prendi una DevKit V1 a 30 pin, meglio se stretta con 22,86 mm tra le file di pin; il LED integrato è utile anche per le prime prove.
- Se lo schema o il libro che segui usa una scheda precisa: compra la stessa; dato che le posizioni dei pin cambiano, non dovrai convertirle.
- Se ti serve il GPIO 0 o la tua scheda di espansione è a 38 pin: scegli la scheda a 38 pin.
- Per progetti con fotocamera, display grandi o audio: valuta una scheda con modulo WROVER, o direttamente un ESP32-CAM.
- Se non vuoi problemi di driver: preferisci una scheda recente con CP2102 o CH340C e presa USB-C.
- Schede ESP32-S3, C3 o C6: sono altri chip; i numeri e la disposizione dei loro pin non sono compatibili con le schede di questo articolo.
Errori comuni e soluzioni
- Errore "LED_BUILTIN was not declared": con ESP32 Dev Module selezionata questa costante non esiste. Scrivi 2 al posto di LED_BUILTIN o scegli DOIT ESP32 DEVKIT V1 come scheda.
- Collegato al pin dello schema, ma non funziona: lo schema può essere stato disegnato per l'altra disposizione. Collega in base alla scritta stampata e al numero di GPIO, non in base alla posizione.
- La scheda non si avvia o si riavvia di continuo: potrebbe esserci qualcosa sui GPIO 6–11, oppure il GPIO 12 è tirato a HIGH all'avvio. Scollega quello che c'è su questi pin e riprova.
- La porta non compare: il cavo potrebbe essere solo di ricarica, oppure manca il driver del chip USB. Usa un cavo dati e confronta il nome in Gestione dispositivi con la tabella.
- Errore "Failed to connect": tieni premuto BOOT quando parte il caricamento; se continua, abbassa Upload Speed a 115200. Altre soluzioni nell'articolo ESP32 Failed to Connect.
- Sulla scheda WROVER la PSRAM risulta 0: l'opzione PSRAM è rimasta su Disabled nel menu Strumenti; impostala su Enabled e ricarica il codice.
In sintesi, le schede ESP32 a 30 e a 38 pin hanno lo stesso cervello; a distinguerle sono la posizione dei pin, il GPIO 0 e il modo in cui la scheda si sistema sul tuo banco di lavoro. Una volta lette le scritte della tua scheda e verificate con lo sketch di prova, troverai i pin giusti qualunque schema tu segua. Per le prime prove, guarda nell'app BlueGrays i progetti ESP32 con LED integrato, LED esterno, LED comandato da pulsante, semaforo, misura della luce con LDR, LCD I2C e connessione Wi-Fi; ognuno spiega passo passo schema e codice.
Domande frequenti
Meglio l'ESP32 a 30 pin o a 38 pin?
Se lavori su breadboard senza esigenze particolari, la DevKit V1 a 30 pin di solito è più comoda e ha quasi sempre un LED integrato. Scegli la scheda a 38 pin se vuoi usare il GPIO 0, se hai una scheda di espansione a 38 pin o se lo schema che segui è stato fatto per lei. Processore e codice sono gli stessi.
Devo cambiare il codice per un ESP32 a 30 pin?
No. Finché il codice usa i numeri di GPIO, funziona allo stesso modo sulle schede a 30 e a 38 pin. Controlla solo che un codice scritto per la scheda a 38 pin non usi il GPIO 0 o i pin della flash, perché sulla scheda a 30 pin non sono accessibili.
Su quale pin è il LED integrato dell'ESP32 DevKit V1?
Sulle DevKit V1 il LED blu utente è sul GPIO 2. Con ESP32 Dev Module selezionata nell'Arduino IDE LED_BUILTIN non è definito, quindi scrivi direttamente 2 nel codice o scegli la scheda DOIT ESP32 DEVKIT V1. Il LED rosso indica solo l'alimentazione e non si può comandare.
Quale scheda scelgo nell'Arduino IDE per l'ESP32 a 38 pin?
Per tutte le schede con modulo WROOM, a 30 o a 38 pin, basta ESP32 Dev Module. Se la tua scheda a 38 pin ha un modulo WROVER, scegli ESP32 Wrover Module oppure attiva l'opzione PSRAM in ESP32 Dev Module.
Che differenza c'è tra ESP32 WROOM e WROVER?
Entrambi contengono lo stesso chip ESP32. Il WROVER aggiunge da 2 a 8 MB di PSRAM ed è un po' più lungo, ma in cambio i GPIO 16 e 17 sono riservati a quella memoria. Tranne che per progetti con fotocamera, display grandi o audio, il WROOM basta.
Come capisco se il mio ESP32 ha un CP2102 o un CH340?
Guarda il piccolo chip accanto alla presa USB: quello quadrato senza piedini di solito è un CP2102, quello rettangolare con piedini su due lati è un CH340. In Gestione dispositivi di Windows la scheda compare come "Silicon Labs CP210x" o "USB-SERIAL CH340"; nell'ID hardware, 10C4 indica Silicon Labs e 1A86 indica WCH.
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 LED ESP32 con pulsante (Push)
Il LED si accende quando il pulsante viene premuto e si spegne quando viene rilasciato. Mostra come vengono utilizzati il pin di ingresso digitale dell'ESP32 e la resistenza di pull-up interna. Grazie alla modalità INPUT_PULLUP, non è necessaria alcuna resistenza esterna.

Controllo LED ESP32 con pulsante (Toggle)
Ogni volta che si preme il pulsante, lo stato del LED cambia: se è acceso si spegne, se è spento si accende. Classico schema toggle. Con il debounce puliamo il rumore meccanico del pulsante per garantire una singola commutazione con una sola pressione.

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.

Schermo LCD I2C per ESP32 (16x2)
In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).

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

