Sensore umidità terreno capacitivo Arduino: calibrazione e codice
Usare il sensore di umidità del terreno capacitivo v1.2 con Arduino: differenze col resistivo, TLC555 e NE555 a 3,3 V, calibrazione, tabella %, ESP32 e Pico.
Il sensore di umidità del terreno capacitivo misura quanto è bagnata la terra di un vaso o del giardino senza che nessun elettrodo metallico tocchi il terreno. Per questo non ha il problema delle classiche sonde resistive a forchetta, che si corrodono e si guastano in poche settimane, e nei progetti di irrigazione automatica con Arduino può durare mesi o persino anni. Di solito porta la scritta "Capacitive Soil Moisture Sensor v1.2" o v2.0, ha una sola uscita analogica e si collega con tre fili ad Arduino Uno, ESP32 o Raspberry Pi Pico.
Questi moduli economici nascondono però trappole importanti: alcune schede montano il chip 555 sbagliato e non funzionano a 3,3 V, in altre manca il collegamento di una resistenza e i bordi tagliati assorbono acqua e fanno derivare la misura in poche settimane. In questa guida imparerai come funziona il sensore, in cosa si differenzia da quello resistivo, come riconoscere una scheda buona, come tararlo all'asciutto e in acqua e come convertire il valore analogico in percentuale di umidità. Poi arrivano l'irrigazione automatica con Arduino Uno, un monitor per piante a batteria con ESP32 e il codice MicroPython per il Pico.
Come funziona il sensore di umidità del terreno capacitivo?
L'ampia area di rame sulla punta del sensore e la superficie di GND che la circonda si comportano come le due armature di un condensatore, e l'isolante tra loro è il terreno stesso. La costante dielettrica dell'acqua è circa 80, quella della terra asciutta 3–5 e quella dell'aria 1: più il terreno è bagnato, più cresce la capacità. Il chip 555 nella parte alta genera un'onda quadra di circa 1,5 MHz che carica e scarica la sonda attraverso una resistenza; poi un diodo e un piccolo filtro trasformano il segnale in una tensione continua. Quando la capacità aumenta, l'ampiezza dell'onda sulla sonda diminuisce, e il risultato è che nel terreno asciutto la tensione d'uscita è alta, in quello bagnato è bassa. Poiché gli elettrodi sono coperti dal solder mask, nel terreno non passa corrente. Puoi sperimentare il funzionamento del 555 con lo strumento del timer 555.
| Caratteristica | Valore |
|---|---|
| Alimentazione | 3,3–5,5 V (nelle schede con TLC555) |
| Uscita | Analogica, circa 1,2–3,0 V; alta all'asciutto, bassa sul bagnato |
| Assorbimento | Circa 5 mA |
| Connettore | PH2.0 a 3 pin: GND, VCC, AOUT |
| Dimensioni | Circa 98 × 23 mm |
| Oscillatore | TLC555 (CMOS), circa 1,5 MHz; NE555 nelle copie |
| Regolatore | XC6206 marcato 662K, 3,3 V |
| Elettrodi | Rame isolato dal solder mask; nel terreno non passa corrente |
Differenza con il sensore resistivo: niente corrosione
I sensori resistivi (YL-69, FC-28) fanno passare corrente tra due punte metalliche nude infilate nel terreno e ne misurano la resistenza. Nel terreno umido questa corrente continua provoca elettrolisi: il metallo della punta positiva si scioglie, con l'alimentazione sempre attiva il rivestimento sparisce in poche settimane e la misura continua a derivare. Inoltre la lettura dipende più dai sali e dal concime che dall'acqua: il giorno in cui concimi, la terra sembra bagnata. Il sensore capacitivo invece misura l'effetto dielettrico dell'acqua, quindi risente molto meno dei sali, e poiché nessun metallo è esposto non si ossida. Abbiamo trattato il sensore resistivo in sensore di umidità del terreno.

| Caratteristica | Resistivo (YL-69, FC-28) | Capacitivo v1.2 |
|---|---|---|
| Principio di misura | Resistenza elettrica del terreno | Capacità (costante dielettrica) |
| Elettrodi | Metallo nudo nichelato | Rame isolato dal solder mask |
| Corrosione | In poche settimane con alimentazione continua | Nessuna (se il solder mask non si graffia) |
| Effetto di concime e sali | Forte | Debole |
| Uscita | AO e DO (comparatore LM393) | Solo analogica (AOUT) |
| Funziona a 3,3 V | Sì | Solo nelle schede con TLC555 |
| Durata | Mesi | Anni, se i bordi sono protetti |
Versioni v1.2 e v2.0: TLC555, NE555 e il problema dei 3,3 V
Il numero di versione stampato sulla scheda non è una garanzia; ciò che conta è la scritta sul chip a otto piedini. Le schede giuste montano un TLC555 CMOS, che funziona senza problemi fino a 2 V. Una parte delle copie economiche usa invece il classico NE555, che richiede almeno 4,5 V: con i 3,3 V di un ESP32 o di un Pico l'uscita non cambia o resta bloccata su un valore senza senso. Il secondo punto da controllare è il piccolo regolatore marcato 662K: se manca o è ponticellato, con 5 V di alimentazione l'uscita può superare i 3 V. In alcuni lotti manca il collegamento a GND della resistenza di scarica da 1 MΩ sull'uscita; su queste schede il passaggio da asciutto a bagnato richiede minuti oppure il valore resta sempre alto. Infine la vetroresina scoperta sui bordi tagliati assorbe acqua col tempo e fa derivare la misura.
| Controllo | Scheda buona | Scheda difettosa | Sintomo |
|---|---|---|---|
| Chip 555 | TLC555 (CMOS) | NE555 o SA555 | A 3,3 V l'uscita non cambia o resta fissa |
| Regolatore | Piccolo chip a 3 piedini marcato 662K | Assente o ponticellato | A 5 V l'uscita può superare i 3 V |
| Resistenza d'uscita da 1 MΩ | Collegata a GND | Collegamento a GND mancante | Risposta lentissima, valore sempre alto |
| Bordi della scheda | Protetti con vernice o resina epossidica | Vetroresina scoperta | La misura deriva in poche settimane |
Collegamenti: Arduino Uno, ESP32 e Raspberry Pi Pico
| Pin del sensore | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| GND (nero) | GND | GND | GND |
| VCC (rosso) | 5V | GPIO 25 (3,3 V solo durante la misura) | GP22 (3,3 V solo durante la misura) |
| AOUT (giallo) | A0 | GPIO 34 (ADC1) | GP26 (ADC0) |
| IN del modulo relè (pompa nell'esempio Uno) | D7 | — | — |
Negli esempi con ESP32 e Pico, il VCC del sensore non va direttamente al pin 3V3 ma a un GPIO. Siccome il sensore assorbe solo 5 mA, un pin lo alimenta senza problemi; così tra una misura e l'altra il sensore è completamente spento e la batteria dura di più. Sull'ESP32 usa per la lettura analogica i pin ADC1 (GPIO 32–39), che funzionano anche con il Wi-Fi acceso. Su Arduino Uno il sensore è alimentato a 5V, ma grazie al regolatore della scheda l'uscita resta comunque intorno ai 3 V; per questo l'Uno non usa tutta la scala a 10 bit, ma circa da 250 a 600.
Taratura: trovare i valori asciutto e bagnato
- Carica il codice per Uno qui sotto senza collegare la pompa e apri il Monitor seriale a 9600 baud.
- Tieni il sensore asciutto e pulito in aria; dopo qualche secondo annota il valore grezzo stabile come DRY_VALUE (sull'Uno di solito tra 520 e 600).
- Immergi il sensore in un bicchiere d'acqua senza superare la linea sulla scheda e annota la lettura come WET_VALUE (di solito tra 250 e 300).
- Per un risultato più realistico fai una seconda misura: usa i valori nel terriccio del vaso completamente secco e nello stesso terriccio dopo un'abbondante annaffiatura e 30 minuti di sgocciolamento.
- Ricarica il codice; ora nel Monitor seriale vedi una percentuale di umidità da 0 a 100. Ogni sensore dà valori un po' diversi, quindi tara ciascuno separatamente.
| Valore grezzo (Uno, taratura d'esempio) | Umidità | Stato del terreno | Cosa fare? |
|---|---|---|---|
| 590 e oltre | 0 % | Aria o terra secchissima | Controlla che il sensore sia ben infilato nel terreno |
| 510 | 25 % | Asciutto | Per la maggior parte delle piante è ora di annaffiare |
| 430 | 50 % | Leggermente umido | Intervallo ideale; non serve annaffiare |
| 350 | 75 % | Umido | Terra appena annaffiata |
| 270 e meno | 100 % | Acqua o fango | Troppa acqua; rischio di marciume radicale |
Le percentuali della tabella sono calcolate con % = (590 − grezzo) × 100 / (590 − 270) per DRY_VALUE = 590 e WET_VALUE = 270. Non è una misura di laboratorio ma un valore relativo tra i due punti di taratura: "50 %" non vuol dire che metà del volume del terreno sia acqua. Nemmeno la risposta del sensore è perfettamente lineare, ma per decidere quando annaffiare basta e avanza. Anche la compattazione, la temperatura e il tipo di terreno spostano la lettura di qualche punto; dopo aver infilato il sensore, premi un po' la terra intorno per chiudere le sacche d'aria. Abbiamo spiegato in dettaglio la lettura analogica in Che cos'è un ADC?.
Codice per Arduino Uno: percentuale di umidità e irrigazione automatica
Il codice qui sotto legge il sensore 10 volte e ne fa la media, converte il valore in percentuale e lo stampa nel Monitor seriale. Quando l'umidità scende sotto il 35 % parte l'irrigazione, che continua finché l'umidità non supera il 60 %; la differenza tra le due soglie (isteresi) evita che la pompa si accenda e si spenga di continuo. L'acqua non viene data tutta insieme ma in dosi da 4 secondi, con un'attesa di 1 minuto dopo ogni dose per lasciarla distribuire nel terreno. Poiché il sensore si accorge dell'acqua con qualche secondo di ritardo, tenere la pompa sempre accesa farebbe traboccare il vaso.
1const byte SENSOR_PIN = A0; // sensör AOUT / sensor AOUT
2const byte PUMP_PIN = 7; // röle IN (pompa) / relay IN (pump)
3const byte RELAY_ON = HIGH; // röle LOW ile çekiyorsa LOW yap / use LOW for active-low relays
4const int DRY_VALUE = 590; // kuru: havada ya da kuru toprakta / dry: in air or dry soil
5const int WET_VALUE = 270; // ıslak: suda ya da yeni sulanmış toprakta / wet: in water or just-watered soil
6const byte START_PCT = 35; // bunun altında sulamaya başla / start watering below this
7const byte STOP_PCT = 60; // bunun üstünde sulamayı bitir / stop watering above this
8const unsigned long PUMP_MS = 4000; // tek seferde en fazla pompa süresi / max pump time per pulse
9const unsigned long SOAK_MS = 60000; // suyun toprağa yayılması için bekle / let the water spread
10
11bool watering = false;
12
13int readAverage() { // 10 okumanın ortalaması / average of 10 readings
14 long sum = 0;
15 for (byte i = 0; i < 10; i++) {
16 sum += analogRead(SENSOR_PIN);
17 delay(10);
18 }
19 return sum / 10;
20}
21
22int toPercent(int raw) { // ham değeri yüzdeye çevir / raw value to percent
23 long pct = (long)(DRY_VALUE - raw) * 100 / (DRY_VALUE - WET_VALUE);
24 return constrain(pct, 0, 100);
25}
26
27void setup() {
28 Serial.begin(9600);
29 pinMode(PUMP_PIN, OUTPUT);
30 digitalWrite(PUMP_PIN, !RELAY_ON); // pompa kapalı başlasın / start with the pump off
31}
32
33void loop() {
34 int raw = readAverage();
35 int pct = toPercent(raw);
36 Serial.print(F("Ham / raw: "));
37 Serial.print(raw);
38 Serial.print(F(" Nem / moisture: %"));
39 Serial.println(pct);
40
41 if (!watering && pct < START_PCT) watering = true; // histerezis / hysteresis
42 if (watering && pct >= STOP_PCT) watering = false;
43
44 if (watering) {
45 digitalWrite(PUMP_PIN, RELAY_ON); // kısa bir doz su ver / give a short dose of water
46 delay(PUMP_MS);
47 digitalWrite(PUMP_PIN, !RELAY_ON);
48 delay(SOAK_MS); // tekrar ölçmeden önce bekle / wait before measuring again
49 } else {
50 delay(2000);
51 }
52}
Non collegare mai la pompa direttamente a un pin di Arduino; alimentala con una sorgente da 5 V separata tramite un modulo relè o un MOSFET e unisci le masse. Alcuni moduli relè si attivano con il livello LOW; se il tuo è così, imposta a LOW la costante RELAY_ON nel codice. Per scegliere la pompa e collegare il tubicino guarda l'articolo sulla mini pompa d'acqua. Aggiungere un sensore di livello per accorgersi che il serbatoio è vuoto evita che la pompa giri a secco e si bruci.
Monitor di umidità per piante a batteria con ESP32
La modalità deep sleep dell'ESP32 permette di far funzionare il sensore a batteria per mesi. Al risveglio, il codice qui sotto accende il sensore tramite il GPIO 25, aspetta 1 secondo che l'uscita si stabilizzi, fa la media di 16 letture, spegne il sensore e stampa il risultato. Se il terreno è sotto il 30 %, il LED integrato lampeggia tre volte; poi l'ESP32 dorme per 30 minuti. Il contatore marcato RTC_DATA_ATTR si conserva durante il deep sleep. Poiché l'ADC dell'ESP32 è a 12 bit, i valori di taratura vanno da 0 a 4095 e sono diversi da quelli dell'Uno; rimisurali con il tuo sensore.
1const int SENSOR_PIN = 34; // AOUT, ADC1 pini / ADC1 pin
2const int SENSOR_POWER_PIN = 25; // sensörün VCC'si / sensor VCC
3const int LED_PIN = 2; // dahili LED: kuru uyarısı / onboard LED: dry warning
4const int DRY_VALUE = 3100; // 12 bit, havada / 12-bit, in air
5const int WET_VALUE = 1350; // 12 bit, suda / 12-bit, in water
6const uint64_t SLEEP_MIN = 30; // ölçüm aralığı (dakika) / interval (minutes)
7
8RTC_DATA_ATTR int bootCount = 0; // derin uykuda korunur / kept through deep sleep
9
10void setup() {
11 Serial.begin(115200);
12 bootCount++;
13 pinMode(SENSOR_POWER_PIN, OUTPUT);
14 pinMode(LED_PIN, OUTPUT);
15
16 digitalWrite(SENSOR_POWER_PIN, HIGH); // sensörü aç / power the sensor
17 delay(1000); // çıkış otursun / let the output settle
18 long sum = 0;
19 for (int i = 0; i < 16; i++) sum += analogRead(SENSOR_PIN);
20 digitalWrite(SENSOR_POWER_PIN, LOW); // sensörü kapat / switch it off
21 int raw = sum / 16;
22 int pct = constrain(map(raw, DRY_VALUE, WET_VALUE, 0, 100), 0, 100);
23 Serial.printf("#%d raw %d moisture %d%%\n", bootCount, raw, pct);
24
25 if (pct < 30) { // kuruysa 3 kez yanıp sön / blink 3 times if dry
26 for (int i = 0; i < 3; i++) {
27 digitalWrite(LED_PIN, HIGH);
28 delay(200);
29 digitalWrite(LED_PIN, LOW);
30 delay(200);
31 }
32 }
33 esp_sleep_enable_timer_wakeup(SLEEP_MIN * 60ULL * 1000000ULL); // mikrosaniye / microseconds
34 esp_deep_sleep_start(); // 30 dk uyu / sleep for 30 min
35}
36
37void loop() {
38}Stimiamo a grandi linee la durata della batteria: a ogni risveglio l'ESP32 assorbe 40–50 mA per circa 1,5 secondi; svegliandosi ogni 30 minuti la media è appena 50 × 1,5 / 1800 ≈ 0,04 mA. A fare la differenza è la corrente in sleep: un normale DevKit, con il suo chip USB-seriale e il regolatore, assorbe diversi mA anche quando dorme e scarica una batteria da 2000 mAh in due o tre settimane. Con un modulo ESP32 nudo e un regolatore a basse perdite la corrente in sleep scende a qualche decina di microampere e la batteria dura mesi. Calcola il tuo circuito con il calcolatore di durata della batteria; i dettagli sono in deep sleep dell'ESP32.
Sensore capacitivo con Raspberry Pi Pico (MicroPython)
Sul Raspberry Pi Pico collega l'uscita AOUT del sensore a GP26, cioè ADC0, e il VCC a GP22. In MicroPython read_u16() restituisce valori da 0 a 65535; in aria vedrai circa 50000–53000, in acqua intorno a 22000–26000. Poiché l'ADC del Pico usa un riferimento di 3,3 V, l'uscita di un sensore con regolatore copre bene l'intervallo. Il codice misura ogni 10 secondi e classifica il terreno come dry, ok o wet.
1from machine import ADC, Pin
2import time
3
4sensor = ADC(26) # GP26 = ADC0, sensör AOUT / sensor AOUT
5power = Pin(22, Pin.OUT) # sensörün VCC'si / sensor VCC
6DRY = 52000 # havada okunan (16 bit) / reading in air (16-bit)
7WET = 24000 # suda okunan (16 bit) / reading in water (16-bit)
8
9def read_moisture():
10 power.value(1) # sensörü aç / power on
11 time.sleep(1) # çıkış otursun / let the output settle
12 total = 0
13 for _ in range(16):
14 total += sensor.read_u16()
15 time.sleep_ms(5)
16 power.value(0) # sensörü kapat / power off
17 raw = total // 16
18 pct = (DRY - raw) * 100 // (DRY - WET)
19 return raw, max(0, min(100, pct))
20
21while True:
22 raw, pct = read_moisture()
23 state = "dry" if pct < 30 else ("ok" if pct < 80 else "wet")
24 print("raw:", raw, "moisture %:", pct, state)
25 time.sleep(10)Impermeabilizzazione: proteggere i bordi e posizionarlo bene
- Proteggi i bordi: la vetroresina scoperta sui bordi tagliati della scheda assorbe acqua e in poche settimane fa derivare la misura. Copri i bordi della sonda con smalto per unghie, vernice trasparente o un sottile strato di resina epossidica.
- Proteggi l'elettronica: copri la parte alta con il 555, il regolatore e il connettore con guaina termorestringente, colla a caldo o resina, così che non arrivino pioggia e acqua di irrigazione.
- Non superare la linea: la linea bianca sulla scheda indica il punto più profondo che può entrare nel terreno; l'elettronica deve restare sempre fuori.
- Infilalo dritto e ben fermo: inserisci il sensore in verticale e premi leggermente la terra intorno; le sacche d'aria fanno sembrare il terreno più asciutto.
- Tieni ferma la posizione: metti il sensore a 1–2 cm dalla parete del vaso, nella zona delle radici e non proprio sotto il tubicino dell'acqua. Se lo sposti, rifai la taratura.
- Non graffiare il solder mask: forzarlo in un terreno duro graffia lo strato protettivo, e il rame scoperto si ossida anche su un sensore capacitivo. Se serve, prepara prima un foro con un bastoncino.
Idee di progetto
- Irrigazione automatica dei vasi: annaffia le piante mentre sei in vacanza con il codice per Uno, un relè e una mini pompa.
- Serra intelligente: unisci l'umidità del terreno a temperatura e umidità dell'aria in una serra intelligente che gestisce ventola e pompa.
- Avviso sul telefono: fai inviare all'ESP32 un messaggio con un bot Telegram quando il terreno si asciuga.
- Grafico dell'umidità: salva le misure su Fogli Google e guarda in un grafico quanto tempo impiega la pianta ad asciugarsi.
- Indicatore con display: mostra la percentuale di umidità con una barra su un display OLED.
- Niente irrigazione quando piove: nel giardino non accendere la pompa se un sensore pioggia rileva precipitazioni.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Su ESP32 o Pico il valore non cambia mai | La scheda monta un NE555 e 3,3 V non bastano | Controlla il chip; usa una scheda con TLC555 o sostituisci l'NE555 con un TLC555 |
| Il passaggio da asciutto a bagnato richiede minuti | La resistenza di scarica da 1 MΩ non è collegata a GND | Collega a GND l'estremità libera della resistenza con un filo sottile |
| La misura deriva lentamente in qualche settimana | I bordi assorbono acqua o l'elettronica si bagna | Proteggi bordi e parte alta con vernice, resina o guaina e rifai la taratura |
| La percentuale va sotto zero o sopra 100 | Valori di taratura sbagliati o invertiti | DRY_VALUE deve essere il valore asciutto (maggiore), WET_VALUE quello bagnato (minore) |
| I valori saltano di continuo | Cavo lungo, disturbi o terra smossa | Fai la media delle letture, usa un cavo corto e premi la terra intorno al sensore |
| Arduino si resetta quando parte la pompa | La pompa è alimentata dai 5V di Arduino | Alimenta la pompa con un'altra sorgente e unisci le masse |
| Sull'ESP32 le letture impazziscono quando si accende il Wi-Fi | Il sensore è su un pin ADC2 | Sposta AOUT su un pin ADC1 tra GPIO 32 e 39 |
Se scegli la scheda giusta e ne proteggi i bordi, il sensore di umidità del terreno capacitivo è il componente più affidabile di qualsiasi progetto per piante e giardino. Controlla prima il chip, poi tara il sensore nella tua terra e annaffia con isteresi e a piccole dosi. Nell'app BlueGrays trovi una stazione di irrigazione intelligente con Arduino, insieme alla misura di temperatura e umidità, ognuno con schema del circuito passo passo e codice pronto.
Domande frequenti
Che differenza c'è tra sensore di umidità del terreno capacitivo e resistivo?
Il sensore resistivo fa passare corrente tra due punte metalliche nude infilate nel terreno, e queste punte si corrodono in poche settimane per elettrolisi. Il capacitivo misura la capacità del terreno con elettrodi isolati, non fa passare corrente e non arrugginisce. Inoltre risente molto meno di concime e sali.
Il sensore di umidità capacitivo funziona a 3,3 V?
Le schede con chip TLC555 funzionano senza problemi a 3,3 V e si collegano direttamente a un ESP32 o a un Pico. Le copie con NE555 richiedono almeno 4,5 V e a 3,3 V l'uscita non cambia. Puoi capire quale hai dalla scritta sul chip a otto piedini della scheda.
Come si tara un sensore di umidità del terreno capacitivo?
Tieni il sensore in aria o in terra secchissima e annota la lettura come valore asciutto, poi immergilo in acqua o in terra appena annaffiata e annota il valore bagnato. La percentuale si calcola con % = (asciutto − grezzo) × 100 / (asciutto − bagnato). Ogni sensore dà valori diversi, quindi tara ciascuno.
Che percentuale di umidità deve avere il terreno?
La percentuale di questo sensore è relativa ai suoi punti di taratura. Per la maggior parte delle piante in vaso un intervallo del 40–70 % va bene; conviene annaffiare quando scende sotto il 25–30 % e smettere sopra l'80 %. Per succulente e cactus usa una soglia più bassa.
Il sensore di umidità capacitivo è impermeabile?
La sonda di misura resiste all'acqua, ma i bordi tagliati della scheda e l'elettronica in alto no. Se copri i bordi con vernice o resina e la parte alta con guaina termorestringente o colla a caldo, il sensore dura molti anni. Non infilarlo oltre la linea segnata sulla scheda.
Perché il valore del sensore cambia così lentamente?
In alcune copie la resistenza da 1 MΩ sull'uscita non è collegata a GND e il condensatore d'uscita non riesce a scaricarsi. Il passaggio da asciutto a bagnato richiede allora diversi minuti. Collegare a GND l'estremità libera della resistenza con un filo sottile risolve il problema.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Stazione di irrigazione intelligente
Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

Temperatura e umidità con DHT11
Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

Misurare l'intensità luminosa con LDR
Vuoi vedere quanto è luminosa la tua stanza sotto forma di numero? L'LDR, un piccolo componente sensibile alla luce, misura la luce ambiente e l'Arduino scrive il valore sullo schermo del computer…

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 DHT22 Temperatura e umidità (con display LCD)
Si tratta di un progetto che misura la temperatura e l'umidità dell'ambiente tramite il sensore DHT22 e le visualizza in tempo reale su un display LCD I2C 16x2. I dati vengono letti dal sensore utilizzando il protocollo one-wire tramite la libreria Adafruit DHT. Questo progetto costituisce la base per stazioni meteorologiche IoT, sistemi di automazione domestica intelligente o sistemi di monitoraggio ambientale nelle serre. La comunicazione con il DHT22 avviene tramite il pin GPIO 4 dell'ESP32.

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

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

