Progetti ESP32 per principianti: 20 idee dal facile al difficile
20 progetti ESP32 per principianti: dal LED integrato e dal web server all'orologio NTP, alla pagina DHT22 e all'allarme Telegram; componenti, tempi e librerie.
Se cerchi progetti ESP32 per principianti, la trappola più grande è voler costruire il primo giorno un allarme che manda avvisi su Telegram e ritrovarsi sommerso da problemi di cavi, driver, Wi-Fi e librerie tutti insieme. I 20 progetti di questa guida vanno dal più facile al più difficile e ognuno aggiunge una sola novità al precedente. Prima fai lampeggiare il LED integrato della scheda, poi aggiungi pulsanti, sensori e display, quindi ti colleghi al Wi-Fi e crei pagine da comandare con lo smartphone e alla fine passi a dispositivi che prendono dati da internet, inviano notifiche e funzionano per mesi a batteria.
I progetti sono divisi in quattro livelli e raccolti in un'unica tabella, così vedi a colpo d'occhio componenti, tempo indicativo e libreria di ciascuno. Sotto ogni livello trovi cosa insegna ogni progetto, a quali pin fare attenzione e le guide con la spiegazione completa. Il codice di tre progetti è proprio in questa pagina: LED con pin touch, orologio internet NTP e pagina web della temperatura con DHT22.

Prima di iniziare: installazione e regole di base
- Arduino IDE e pacchetto ESP32: installa il pacchetto esp32 di Espressif dal Gestore schede e scegli ESP32 Dev Module come scheda; i passaggi sono nella guida come installare Arduino IDE.
- Se la porta non compare: prima cambia il cavo, poi installa il driver del chip USB della scheda (CP2102 o CH340); i dettagli sono nella guida driver CH340.
- La regola dei 3,3 V: i pin dell'ESP32 lavorano a 3,3 V e non tollerano i 5 V. Con i sensori che hanno un'uscita a 5 V, metti in mezzo un partitore di tensione.
- Pin sicuri: i GPIO da 6 a 11 sono collegati alla memoria flash e i GPIO da 34 a 39 sono solo ingressi. Guarda la mappa della tua scheda nello strumento Pinout.
- Wi-Fi: l'ESP32 si collega solo a reti a 2,4 GHz; le reti a 5 GHz non le vede.
- Alimentazione: all'avvio del Wi-Fi la scheda assorbe picchi fino a 250 mA; un cavo scadente o una porta debole la fanno riavviare di continuo. La soluzione è nella guida brownout dell'ESP32.
I 20 progetti ESP32 in un'unica tabella
| # | Progetto | Componenti | Tempo | Libreria |
|---|---|---|---|---|
| 1 | Far lampeggiare il LED integrato | Solo l'ESP32 | 10 min | Nessuna |
| 2 | LED con pulsante (a pressione e a commutazione) | Pulsante, LED, 220 Ω | 20 min | Nessuna |
| 3 | Semaforo | 3 LED, 3 × 220 Ω | 20 min | Nessuna |
| 4 | Dissolvenza di un LED con PWM | LED, 220 Ω | 20 min | Nessuna (LEDC è nel core) |
| 5 | LED con pin touch | Un cavetto jumper | 15 min | Nessuna |
| 6 | Luce notturna con LDR | LDR, 10 kΩ, LED | 30 min | Nessuna |
| 7 | Luminosità del LED con potenziometro | Potenziometro da 10 kΩ, LED | 30 min | Nessuna |
| 8 | Misuratore di distanza HC-SR04 | HC-SR04, resistenze da 1 kΩ e 2 kΩ | 40 min | Nessuna |
| 9 | Termometro con DHT22 e LCD I2C | DHT22, LCD 16x2 I2C | 45 min | DHT sensor library, LiquidCrystal_I2C |
| 10 | Luce automatica con PIR | HC-SR501, LED o relè | 30 min | Nessuna |
| 11 | Collegarsi al Wi-Fi e mostrare l'IP | Solo l'ESP32 | 15 min | WiFi (core) |
| 12 | Comandare un LED dallo smartphone | LED, 220 Ω | 30 min | WiFi, WebServer (core) |
| 13 | Orologio internet NTP | Solo l'ESP32 (OLED facoltativo) | 30 min | WiFi, time.h (core) |
| 14 | Pagina web della temperatura con DHT22 | DHT22 | 45 min | DHT sensor library, WebServer |
| 15 | Selettore colore RGB sullo smartphone | LED RGB, 3 resistenze | 45 min | WebServer (core) |
| 16 | Display meteo | OLED da 0,96 pollici | 1 ora | HTTPClient, ArduinoJson, Adafruit SSD1306 |
| 17 | Pannello di controllo in tempo reale con WebSocket | 2 pulsanti, LED | 1 ora | ESPAsyncWebServer, AsyncTCP |
| 18 | Allarme di movimento con Telegram | HC-SR501, buzzer | 1 ora | UniversalTelegramBot, ArduinoJson |
| 19 | Sensore a batteria con deep sleep | DHT22, cella 18650, TP4056 | 1 ora | esp_sleep (core) |
| 20 | Caricamento del codice senza fili con OTA | Solo l'ESP32 | 30 min | ArduinoOTA (core) |
Livello 1: primi passi senza Wi-Fi (1–5)
I primi cinque progetti servono a conoscere l'ESP32 e nessuno usa il Wi-Fi. Nel progetto 1 fai lampeggiare il LED blu che sulla maggior parte delle DevKit è collegato al GPIO 2 e vedi che pinMode, digitalWrite e delay funzionano esattamente come su Arduino. Nel progetto 2 colleghi un pulsante tra il GPIO 4 e GND e usi INPUT_PULLUP; nella versione a commutazione impari a gestire i rimbalzi del pulsante (debounce), spiegati nella guida come collegare un pulsante ad Arduino. Il progetto 3 accende tre LED in sequenza e ti insegna a ragionare per tempi e stati. Nel progetto 4 usi il LEDC, la periferica PWM dell'ESP32, per far accendere e spegnere lentamente un LED, come se respirasse; qui noterai che con il core 3.x le funzioni sono cambiate, e le basi sono nella guida cos'è il PWM.
Il progetto 5 mostra la prima funzione che distingue l'ESP32 dall'Arduino Uno: i pin touch. Dieci pin dell'ESP32 misurano la piccola variazione di capacità che un dito provoca toccandoli; il GPIO 4, chiamato T0, è uno di questi. Basta inserire un cavetto jumper nel pin e toccarne l'estremità. Nel Monitor seriale vedrai valori intorno a 60–80 senza contatto e 10–20 al tocco; mettere la soglia tra i due è sufficiente. Gli altri pin touch e i metodi per letture stabili sono nella guida pin touch dell'ESP32.
1// Proje 5: ESP32 dokunmatik pin ile LED / project 5: LED with an ESP32 touch pin
2const int TOUCH_PIN = T0; // T0 = GPIO 4
3const int LED_PIN = 2; // çoğu DevKit'te dahili LED / onboard LED on most DevKits
4const int THRESHOLD = 30; // Seri Monitör'deki değere göre ayarla / tune to the Serial Monitor value
5
6void setup() {
7 Serial.begin(115200);
8 pinMode(LED_PIN, OUTPUT);
9}
10
11void loop() {
12 int value = touchRead(TOUCH_PIN); // dokununca değer düşer / the value drops when touched
13 Serial.println(value);
14 digitalWrite(LED_PIN, value < THRESHOLD ? HIGH : LOW);
15 delay(100);
16}Livello 2: sensori e display (6–10)
Nel secondo livello usi gli ingressi analogici dell'ESP32 e i sensori. L'ADC dell'ESP32 è a 12 bit: analogRead restituisce valori da 0 a 4095, cioè misura in modo quattro volte più fine dell'intervallo 0–1023 di Arduino. Nel progetto 6 colleghi la LDR come partitore di tensione con una resistenza da 10 kΩ e accendi il LED quando fa buio (sensore di luce LDR). Nel progetto 7 trasformi con map il valore 0–4095 del potenziometro in PWM e regoli la luminosità del LED (cos'è un potenziometro).
Nel progetto 8 misuri la distanza con l'HC-SR04; poiché il sensore lavora a 5 V, devi abbassare il pin ECHO a 3,3 V con un partitore da 1 kΩ e 2 kΩ (sensore a ultrasuoni HC-SR04). Il progetto 9 è un vero termometro che mostra temperatura e umidità del DHT22 su un LCD 16x2 I2C (DHT11 e DHT22, display LCD I2C). Nel progetto 10 il sensore PIR HC-SR501 accende un LED, o una lampada tramite relè, quando rileva un movimento; la sua uscita è già a 3,3 V e si collega direttamente (sensore di movimento PIR).
| Sensore o modulo | Pin dell'ESP32 | Nota |
|---|---|---|
| LDR (partitore con 10 kΩ) | GPIO 34 | Pin ADC1, solo ingresso |
| Potenziometro (cursore) | GPIO 35 | Pin ADC1, estremi a 3V3 e GND |
| HC-SR04 TRIG / ECHO | GPIO 5 / GPIO 18 | ECHO abbassato a 3,3 V con un partitore da 1 kΩ e 2 kΩ |
| Dati del DHT22 | GPIO 4 | Se non è un modulo, aggiungi una pull-up da 10 kΩ |
| LCD I2C SDA / SCL | GPIO 21 / GPIO 22 | L'LCD si alimenta a 5V (VIN); la soluzione più sicura è un traslatore di livello |
| Uscita del PIR HC-SR501 | GPIO 27 | Uscita a 3,3 V, collegamento diretto |
Livello 3: primi passi con il Wi-Fi (11–15)
Il terzo livello libera la vera potenza dell'ESP32. Nel progetto 11 ti colleghi alla rete di casa e scrivi nel Monitor seriale l'indirizzo IP assegnato dal router; se non si collega, le cause sono elencate una per una nella guida l'ESP32 non si collega al Wi-Fi. Nel progetto 12 l'ESP32 diventa un piccolo web server e accendi o spegni il LED con due pulsanti in una pagina aperta nel browser dello smartphone; il codice completo è nella guida cos'è l'ESP32. Il progetto 13 prende l'ora esatta da internet: l'ESP32 interroga i server NTP, calcola da solo fuso orario e ora legale, e non ti serve più un modulo RTC.
1// Proje 13: NTP ile internet saati / project 13: internet clock with NTP
2#include <WiFi.h>
3#include <time.h>
4
5const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8// Saat dilimi (POSIX) / time zone (POSIX):
9// Orta Avrupa / Central Europe: "CET-1CEST,M3.5.0,M10.5.0/3"
10// Türkiye: "<+03>-3" México: "CST6" Argentina: "<-03>3" UK: "GMT0BST,M3.5.0/1,M10.5.0"
11const char* TZ_INFO = "CET-1CEST,M3.5.0,M10.5.0/3";
12
13void setup() {
14 Serial.begin(115200);
15 WiFi.begin(WIFI_SSID, WIFI_PASS);
16 while (WiFi.status() != WL_CONNECTED) {
17 delay(500);
18 Serial.print(".");
19 }
20 Serial.println();
21 configTzTime(TZ_INFO, "pool.ntp.org", "time.google.com"); // saati internetten al / get the time online
22}
23
24void loop() {
25 struct tm now;
26 if (getLocalTime(&now)) {
27 char text[32];
28 strftime(text, sizeof(text), "%d.%m.%Y %H:%M:%S", &now);
29 Serial.println(text);
30 } else {
31 Serial.println("Saat bekleniyor / waiting for time");
32 }
33 delay(1000);
34}La riga TZ_INFO del codice definisce il fuso orario in formato POSIX, compresi i passaggi all'ora legale; per l'Italia l'impostazione predefinita per l'Europa centrale va già bene. configTzTime stabilisce in background la connessione ai server NTP e getLocalTime restituisce false finché l'ora non è arrivata, quindi è normale vedere il messaggio "waiting" nei primi secondi. Per mostrare l'ora su un OLED o un LCD e impostare una sveglia, prosegui con la guida orologio NTP con ESP32.
Il progetto 14 unisce il secondo e il terzo livello: mostri temperatura e umidità del DHT22 in una pagina web che qualsiasi smartphone della stessa rete può aprire. La pagina si ricarica da sola ogni cinque secondi; al DHT22 non piace essere letto più spesso di ogni due secondi, quindi questo ritmo va bene anche per il sensore. Nel progetto 15 regoli il colore di un LED RGB con il selettore colore dello smartphone; la conversione da HEX a RGB e la correzione gamma sono spiegate passo passo nella guida ESP32 LED RGB web server.

1// Proje 14: DHT22 sıcaklık ve nemi web sayfasında göster
2// Project 14: show DHT22 temperature and humidity on a web page
3#include <WiFi.h>
4#include <WebServer.h>
5#include <DHT.h>
6
7const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
8const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
9const int DHT_PIN = 4; // DHT22 veri pini / DHT22 data pin
10
11DHT dht(DHT_PIN, DHT22);
12WebServer server(80);
13
14void handleRoot() {
15 float t = dht.readTemperature();
16 float h = dht.readHumidity();
17 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
18 "<meta name='viewport' content='width=device-width'>"
19 "<meta http-equiv='refresh' content='5'>" // 5 saniyede bir yenile / refresh every 5 s
20 "<title>ESP32 DHT22</title></head>"
21 "<body style='font-family:sans-serif;text-align:center'>";
22 if (isnan(t) || isnan(h)) {
23 html += "<h2>Sensör okunamadı / sensor read failed</h2>";
24 } else {
25 html += "<h1>" + String(t, 1) + " °C</h1>";
26 html += "<h2>" + String(h, 0) + " %</h2>";
27 }
28 html += "</body></html>";
29 server.send(200, "text/html", html);
30}
31
32void setup() {
33 Serial.begin(115200);
34 dht.begin();
35 WiFi.begin(WIFI_SSID, WIFI_PASS);
36 while (WiFi.status() != WL_CONNECTED) {
37 delay(500);
38 Serial.print(".");
39 }
40 Serial.println();
41 Serial.println(WiFi.localIP()); // bu adresi tarayıcıda aç / open this address in a browser
42 server.on("/", handleRoot);
43 server.begin();
44}
45
46void loop() {
47 server.handleClient();
48}Livello 4: internet, notifiche e batteria (16–20)
Nell'ultimo livello l'ESP32 non parla più solo con la rete di casa, ma con internet. Nel progetto 16 invii una richiesta a un servizio meteo con HTTPClient, interpreti la risposta JSON con ArduinoJson e mostri la temperatura su un display OLED (API meteo con ESP32). Nel progetto 17 costruisci un pannello di controllo in tempo reale che funziona senza ricaricare la pagina: grazie a WebSocket, il contatore sullo smartphone cambia nell'istante in cui premi il pulsante sulla scheda (ESP32 con WebSocket).
Il progetto 18 è un sistema di sicurezza: quando il PIR rileva un movimento suona il buzzer e sullo smartphone arriva un messaggio Telegram; la configurazione del bot è nella guida bot Telegram con ESP32. Nel progetto 19 impari il deep sleep: la scheda si sveglia ogni dieci minuti, misura e torna a dormire. Il chip ESP32 da solo assorbe circa 10 µA in deep sleep; sulle schede DevKit regolatore e chip USB continuano a consumare qualche mA, quindi la durata reale della batteria dipende dal progetto della scheda (deep sleep dell'ESP32). Il progetto 20 mostra come caricare il codice via Wi-Fi senza cavo USB (OTA); così aggiorni un dispositivo montato sul soffitto o in giardino senza smontarlo (aggiornamento OTA dell'ESP32).
Da quale progetto iniziare?
| La tua situazione | Inizia da | Poi passa a |
|---|---|---|
| Non hai mai fatto elettronica | 1, 2 e 3 | 6 e 7 |
| Conosci Arduino ma l'ESP32 è nuovo per te | 4 e 5 | 11, 12 e 13 |
| Hai solo l'ESP32, nessun altro componente | 1, 5, 11 e 13 | 20 |
| Prepari un compito scolastico o una tesina | 9 e 14 | 18 e 19 |
| Ti interessa la domotica | 10 e 12 | 17 e poi MQTT |
Dopo i 20 progetti: i prossimi passi
- ESP-NOW: fai comunicare due ESP32 senza router, a centinaia di metri di distanza (ESP-NOW).
- Bluetooth Low Energy: scambia dati con lo smartphone via BLE (Bluetooth BLE dell'ESP32).
- Home Assistant: collega i tuoi sensori alla casa intelligente via MQTT (ESP32, MQTT e Home Assistant).
- WiFiManager: invece di scrivere nome della rete e password nel codice, usa una pagina di configurazione da compilare con lo smartphone (WiFiManager su ESP32).
- Registrazione dati: invia le misure a Google Fogli e fanne un grafico (ESP32 e Google Sheets).
- Due core: con i task di FreeRTOS fai girare il Wi-Fi su un core e le misure sull'altro (FreeRTOS su ESP32).
Gli errori più comuni dei principianti con l'ESP32
- Usare i GPIO da 6 a 11: questi pin sono collegati alla memoria flash della scheda; se li usi, la scheda non si avvia o si blocca.
- Mandare un segnale a 5 V direttamente su un pin: abbassa a 3,3 V con un partitore le uscite a 5 V come l'ECHO dell'HC-SR04.
- Un pin ADC2 in un progetto Wi-Fi: sposta il sensore analogico sui pin ADC1, dal GPIO 32 al 39.
- Un delay lungo nel web server: un delay(5000) dentro loop lascia la pagina senza risposta per cinque secondi; gestisci i tempi con millis.
- L'errore "Failed to connect": tieni premuto il pulsante BOOT quando inizia il caricamento; la soluzione definitiva è nella guida ESP32 Failed to Connect.
- Copiare codice vecchio da internet: con il core ESP32 3.x le funzioni di LEDC e dei timer sono cambiate; un codice PWM del 2020 potrebbe non compilare.
Usa questa lista come una tabella di marcia: ogni volta che finisci un progetto, spunta la sua riga nella tabella e passa al successivo. Nell'app BlueGrays trovi la maggior parte di questi progetti ESP32, dal LED integrato all'allarme Telegram, passo passo con schema dei collegamenti, elenco dei componenti e codice pronto; se ti blocchi da qualche parte, torna alla guida corrispondente per i dettagli.
Domande frequenti
Qual è il primo progetto da fare con un ESP32?
Il modo migliore per iniziare è far lampeggiare il LED integrato della scheda, collegato al GPIO 2: non servono componenti e confermi che l'installazione funziona. Poi prosegui con il LED e il pulsante e con il LED in dissolvenza PWM, e passa al Wi-Fi solo quando questi progetti di base funzionano senza problemi.
L'ESP32 è adatto ai principianti?
Sì. L'ESP32 si programma con l'Arduino IDE e con le stesse funzioni di Arduino; la maggior parte degli sketch scritti per Arduino funziona con piccole modifiche. Le differenze principali sono i pin a 3,3 V, il fatto che i pin ADC2 non leggono valori analogici con il Wi-Fi acceso e i GPIO da 6 a 11 da non usare.
Che componenti servono per i progetti con ESP32?
Per iniziare bastano un ESP32 DevKit, una breadboard, cavetti jumper, qualche LED e resistenza, un pulsante, una LDR e un potenziometro. Aggiungendo un DHT22, un HC-SR04, un sensore PIR, un LCD I2C e un display OLED puoi realizzare quasi tutti i 20 progetti di questa lista.
L'ESP32 funziona senza internet?
Sì. I primi dieci progetti di questa lista non usano affatto il Wi-Fi e senza internet l'ESP32 funziona come un Arduino molto potente. Può anche creare una propria rete Wi-Fi o comunicare con altri ESP32 tramite ESP-NOW senza router.
Meglio iniziare con ESP32 o con Arduino Uno?
Se vuoi progetti con Wi-Fi, Bluetooth o controllo dallo smartphone, inizia con l'ESP32. L'Arduino Uno lavora a 5 V ed è compatibile direttamente con molti sensori più vecchi, il che riserva meno sorprese a chi parte da zero; con l'ESP32 serve un partitore di tensione per i sensori a 5 V.
Conviene programmare l'ESP32 con Arduino IDE o MicroPython?
Gli esempi di questa lista usano l'Arduino IDE perché ci sono molti più tutorial e librerie. Anche MicroPython funziona bene sull'ESP32 e permette di provare il codice senza compilare; se conosci già Python, è una buona scelta per progetti semplici.
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.

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.

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.

ESP32: ora reale da Internet tramite NTP
L'ESP32 si collega al Wi-Fi e ottiene l'ora esatta dai server NTP (Network Time Protocol) con precisione al millisecondo. Con configTzTime() si applica in automatico il fuso orario turco (TRT, UTC+3) e, nei paesi con l'ora legale, il cambio (DST) è gestito da una stringa POSIX TZ. L'ora viene stampata sul Serial Monitor e su un display LCD I2C opzionale.

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

Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
Un allarme di sicurezza smart: quando il sensore PIR rileva un movimento, suona il buzzer, si accende il LED e il proprietario riceve subito una notifica su Telegram. Un'attesa di 30 secondi (cooldown) limita la frequenza degli allarmi ripetuti; non elimina i falsi rilevamenti del sensore PIR. Adatto a casa, garage, magazzino o studio.
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

