Irrigazione automatica ESP32: sistema Wi-Fi e sensore di umidità
Irrigazione automatica ESP32: sensore capacitivo, relè e minipompa, soglia e durata da pannello web, taratura, deep sleep e protezione dal secco.
Un sistema di irrigazione automatica con ESP32 unisce un sensore che misura l'umidità della terra nel vaso a una piccola pompa d'acqua, così la tua pianta viene annaffiata al momento giusto anche quando non sei in casa. Quando il terreno si asciuga sotto il livello che hai impostato, l'ESP32 fa girare la pompa per qualche secondo tramite un relè, aspetta che l'acqua venga assorbita e misura di nuovo. Grazie al Wi-Fi puoi controllare l'umidità dal telefono e cambiare soglia e durata dell'irrigazione da un pannello web.
In questa guida procediamo passo dopo passo: dalla taratura del sensore di umidità capacitivo a un codice di irrigazione completo con pannello web, fino a una versione a batteria con deep sleep per i balconi senza presa. Vedremo anche come scegliere la soglia in base al tipo di pianta, come calcolare il tempo della pompa dalla portata e, soprattutto, come evitare che la pompa giri a secco quando il serbatoio è vuoto.

Come funziona l'irrigazione automatica con ESP32?
Il sistema gira con un ciclo semplice. Ogni 10 secondi l'ESP32 fa 16 letture dal sensore, ne calcola la media e la converte in un'umidità tra 0% (completamente secco) e 100% (immerso in acqua). Se l'umidità è sotto la tua soglia, nel serbatoio c'è acqua ed è passato abbastanza tempo dall'ultima irrigazione, fa girare la pompa per il tempo impostato. Poi parte un tempo di attesa perché l'acqua si distribuisca nel terreno; finché non scade non avviene una nuova irrigazione. Tutte queste impostazioni si cambiano dal pannello web e vengono salvate nella memoria flash dell'ESP32.
| Componente | Compito | Nota |
|---|---|---|
| ESP32 DevKit | Misura, decide e gestisce il pannello web | Solo Wi-Fi a 2,4 GHz |
| Sensore di umidità del terreno capacitivo v1.2 | Trasforma l'umidità del terreno in una tensione analogica | Non si corrode; funziona da 3,3 a 5,5 V |
| Modulo relè a 1 canale | Accende e spegne la pompa | Scegli un modello che si attivi con 3,3 V |
| Minipompa sommergibile 3–6 V e tubo | Porta l'acqua dal serbatoio al vaso | Circa 100–200 mA |
| Sensore di livello a galleggiante | Segnala quando il serbatoio è vuoto | Protegge la pompa dal funzionamento a secco |
| Alimentatore 5 V 2 A | Alimenta ESP32, relè e pompa | Tutte le masse collegate |
| Diodo 1N4007 o 1N5819 | Assorbe il picco di tensione allo spegnimento della pompa | Catodo sul + della pompa |
Capacitivo o resistivo? Il sensore di umidità giusto
I sensori resistivi economici (due punte metalliche a forchetta) misurano facendo passare corrente direttamente nel terreno. Questa corrente provoca elettrolisi sulle punte: in poche settimane il metallo si corrode, le letture derivano e nel terreno finiscono ioni metallici. Nel sensore capacitivo invece gli elettrodi sono sotto un rivestimento isolante e non hanno contatto elettrico con il terreno; il sensore misura come l'acqua nel suolo cambia la sua capacità. Per questo può restare interrato per mesi o addirittura anni. Per un'irrigazione sempre in funzione, il sensore capacitivo è praticamente obbligatorio. Trovi un confronto dettagliato tra i due in Sensore di umidità del terreno.
Collegamenti: ESP32, sensore, relè e pompa
| Collegamento | Pin ESP32 | Nota |
|---|---|---|
| AOUT del sensore | GPIO 34 | Canale ADC1; leggibile anche con il Wi-Fi attivo |
| VCC del sensore | 3V3 (GPIO 25 nella versione a batteria) | A batteria è alimentato solo durante la misura |
| GND del sensore | GND | Massa comune |
| IN del relè | GPIO 26 | La maggior parte dei moduli si attiva con LOW |
| VCC / GND del relè | VIN (5 V) / GND | La bobina del relè vuole 5 V |
| Galleggiante | GPIO 27 e GND | INPUT_PULLUP; contatto chiuso finché c'è acqua |
| Pompa | 5 V, tramite COM–NO del relè | La corrente della pompa non passa dall'ESP32 |
Quando si spegne, il motore della pompa genera un picco di tensione inversa che può resettare l'ESP32: collega quindi un diodo in antiparallelo ai capi della pompa (catodo sul +) e aggiungi un condensatore da 100–470 µF vicino all'ingresso 5 V dell'ESP32. Le masse del modulo relè, della pompa e dell'ESP32 devono essere unite. Tieni il serbatoio più in basso del vaso e fai terminare il tubo sopra il livello dell'acqua del serbatoio; altrimenti l'acqua continua a scorrere per effetto sifone anche a pompa ferma e il vaso trabocca. Spieghiamo nel dettaglio come pilotare la pompa in Pompa d'acqua con Arduino.
Passo 1: tarare il sensore (valore secco e bagnato)
Ogni sensore capacitivo, ogni lunghezza di cavo e ogni tensione di alimentazione danno valori leggermente diversi, quindi devi adattare il codice ai due valori estremi del tuo sensore. Carica il codice qui sotto e apri il Monitor seriale a 115200 baud. Prima tieni il sensore in aria e annota il valore: è RAW_DRY, cioè 0%. Poi immergi il sensore in un bicchiere d'acqua fino alla linea stampata e annota il nuovo valore: è RAW_WET, cioè 100%. Con un sensore capacitivo il valore scende quando l'umidità sale; la percentuale si calcola con umidità % = (RAW_DRY − grezzo) × 100 / (RAW_DRY − RAW_WET).
1// Kalibrasyon: sensörü önce havada, sonra bardak suda tut / calibration: hold the sensor in air, then in a glass of water
2const int SOIL_PIN = 34; // sensör AOUT, ADC1 kanalı / sensor AOUT, an ADC1 channel
3
4void setup() {
5 Serial.begin(115200);
6}
7
8void loop() {
9 long sum = 0;
10 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 readings
11 sum += analogRead(SOIL_PIN);
12 delay(5);
13 }
14 Serial.print("Ham deger / raw value: ");
15 Serial.println(sum / 16); // havada → RAW_DRY, suda → RAW_WET / in air → RAW_DRY, in water → RAW_WET
16 delay(1000);
17}| Condizione | Valore grezzo (esempio) | Umidità (%) |
|---|---|---|
| In aria (completamente secco) | ≈ 3000 | 0 (RAW_DRY) |
| Terreno secco | ≈ 2500–2700 | 17–29 |
| Terreno umido (ideale per quasi tutte le piante) | ≈ 1800–2200 | 46–69 |
| Terreno appena annaffiato | ≈ 1500–1700 | 74–86 |
| In un bicchiere d'acqua | ≈ 1250 | 100 (RAW_WET) |
Scegliere la soglia di irrigazione in base alla pianta
| Tipo di pianta | Soglia di irrigazione | Nota |
|---|---|---|
| Cactus e piante grasse | 15–25% | Lascia asciugare il terreno quasi del tutto |
| Piante da appartamento (pothos, monstera, ficus) | 30–40% | Quando i primi 2–3 cm sono asciutti |
| Ortaggi e piantine (pomodori, basilico, peperoni) | 45–60% | Terreno sempre leggermente umido |
| Felci e piante amanti dell'umidità | 55–70% | Non lasciare mai asciugare del tutto |
Ci sono due impostazioni importanti quanto la soglia: il tempo della pompa e il tempo di attesa. Una minipompa da 100 L/h in teoria sposta circa 28 ml al secondo, ma con un tubicino sottile e qualche decina di centimetri di prevalenza in pratica si arriva a 15–20 ml al secondo. La cosa migliore è far girare la pompa per 10 secondi in un misurino e misurare la portata reale. Per un vaso da 15 cm bastano di solito 80–150 ml per irrigazione, cioè 5–8 secondi. Il tempo di attesa serve perché l'acqua si distribuisca nel terreno e arrivi al sensore: senza, il sensore non si è ancora bagnato, il sistema fa ripartire la pompa più volte e allaga il vaso. 30 minuti sono un buon punto di partenza.
Passo 2: codice di irrigazione ESP32 con pannello web
Lo sketch principale gestisce l'irrigazione automatica e serve anche un piccolo pannello da aprire sul telefono. Il pannello aggiorna ogni 3 secondi l'umidità, lo stato della pompa e del serbatoio e il tempo trascorso dall'ultima irrigazione. Dal modulo puoi cambiare soglia, tempo della pompa e tempo di attesa, e con il pulsante "Water now" annaffi a mano. Le impostazioni vengono scritte nella flash con la libreria Preferences, quindi restano anche dopo un blackout. Anche se il Wi-Fi non si connette, dopo 20 secondi il codice va avanti e l'irrigazione automatica continua a funzionare. Non dimenticare di inserire i due valori della taratura nelle righe RAW_DRY e RAW_WET:
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8const int SOIL_PIN = 34; // sensör AOUT (ADC1) / sensor AOUT (ADC1)
9const int RELAY_PIN = 26; // röle IN / relay IN
10const int FLOAT_PIN = 27; // şamandıra, diğer ucu GND / float switch, other leg to GND
11const bool RELAY_ACTIVE_LOW = true; // çoğu röle modülü LOW'da çeker / most relay modules switch on LOW
12const int RAW_DRY = 3000; // havadaki değer (%0) / reading in air (0%)
13const int RAW_WET = 1250; // sudaki değer (%100) / reading in water (100%)
14
15WebServer server(80);
16Preferences prefs;
17
18int threshold = 35; // bu nemin altında sula (%) / water below this moisture (%)
19int durationS = 5; // pompa süresi (sn) / pump run time (s)
20int soakMin = 30; // iki sulama arası bekleme (dk) / soak time between waterings (min)
21
22int moisture = 0; // son nem (%) / last moisture (%)
23bool pumpOn = false, tankLow = false, everWatered = false;
24unsigned long pumpStart = 0, lastWater = 0, lastCheck = 0;
25
26const char PAGE[] PROGMEM = R"HTML(<!DOCTYPE html><html><head><meta charset="utf-8">
27<meta name="viewport" content="width=device-width,initial-scale=1"><title>ESP32 Sulama</title>
28<style>body{font-family:sans-serif;margin:16px;max-width:420px}input{width:70px}button{padding:8px 14px;margin-top:8px}</style></head>
29<body><h2>ESP32 Sulama / Watering</h2>
30<p>Nem / Moisture: <b id="m">--</b> %</p>
31<p>Pompa / Pump: <b id="p">--</b> · Depo / Tank: <b id="k">--</b></p>
32<p>Son sulama / Last watering: <b id="l">--</b></p>
33<form action="/save" method="POST">
34<p>Esik / Threshold (%): <input name="th" type="number" min="5" max="90" value="%TH%"></p>
35<p>Sure / Duration (s): <input name="du" type="number" min="1" max="60" value="%DU%"></p>
36<p>Bekleme / Soak (min): <input name="so" type="number" min="1" max="720" value="%SO%"></p>
37<button>Kaydet / Save</button></form>
38<form action="/water" method="POST"><button>Simdi sula / Water now</button></form>
39<script>
40function upd() {
41 fetch('/data').then(r => r.json()).then(d => {
42 document.getElementById('m').textContent = d.m;
43 document.getElementById('p').textContent = d.p ? 'ON' : 'OFF';
44 document.getElementById('k').textContent = d.k ? 'BOS / EMPTY' : 'OK';
45 document.getElementById('l').textContent = d.l < 0 ? '--' : Math.round(d.l / 60) + ' dk / min';
46 });
47}
48upd(); setInterval(upd, 3000);
49</script></body></html>)HTML";
50
51void setPump(bool on) {
52 pumpOn = on;
53 digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
54}
55
56bool waterAvailable() { // şamandıra yukarıda: kontak kapalı, LOW / float up: contact closed, LOW
57 return digitalRead(FLOAT_PIN) == LOW;
58}
59
60int readMoisture() {
61 long sum = 0;
62 for (int i = 0; i < 16; i++) { sum += analogRead(SOIL_PIN); delay(5); }
63 int pct = map(sum / 16, RAW_DRY, RAW_WET, 0, 100); // kuru → 0, ıslak → 100 / dry → 0, wet → 100
64 return constrain(pct, 0, 100);
65}
66
67void startWatering() {
68 if (pumpOn || !waterAvailable()) return; // su yoksa pompayı asla çalıştırma / never run the pump dry
69 setPump(true);
70 pumpStart = lastWater = millis();
71 everWatered = true;
72}
73
74void handleRoot() {
75 String page = PAGE;
76 page.replace("%TH%", String(threshold));
77 page.replace("%DU%", String(durationS));
78 page.replace("%SO%", String(soakMin));
79 server.send(200, "text/html", page);
80}
81
82void handleData() {
83 long ago = everWatered ? (long)((millis() - lastWater) / 1000) : -1;
84 server.send(200, "application/json", "{\"m\":" + String(moisture) + ",\"p\":" + String(pumpOn ? 1 : 0) +
85 ",\"k\":" + String(tankLow ? 1 : 0) + ",\"l\":" + String(ago) + "}");
86}
87
88void handleSave() {
89 threshold = constrain(server.arg("th").toInt(), 5, 90);
90 durationS = constrain(server.arg("du").toInt(), 1, 60);
91 soakMin = constrain(server.arg("so").toInt(), 1, 720);
92 prefs.putInt("th", threshold); // flaşa kaydet, elektrik kesilse de kalır / saved to flash, survives power cuts
93 prefs.putInt("du", durationS);
94 prefs.putInt("so", soakMin);
95 server.sendHeader("Location", "/");
96 server.send(303);
97}
98
99void handleWater() {
100 startWatering(); // elle sulama / manual watering
101 server.sendHeader("Location", "/");
102 server.send(303);
103}
104
105void setup() {
106 Serial.begin(115200);
107 pinMode(RELAY_PIN, OUTPUT);
108 setPump(false); // açılışta pompa kapalı / pump off at boot
109 pinMode(FLOAT_PIN, INPUT_PULLUP);
110 prefs.begin("sulama", false);
111 threshold = prefs.getInt("th", threshold);
112 durationS = prefs.getInt("du", durationS);
113 soakMin = prefs.getInt("so", soakMin);
114
115 WiFi.mode(WIFI_STA);
116 WiFi.begin(ssid, password);
117 for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) delay(500); // en fazla 20 sn bekle / wait 20 s at most
118 Serial.print("IP: ");
119 Serial.println(WiFi.localIP()); // Wi-Fi yoksa da sulama çalışır / watering works even without Wi-Fi
120
121 server.on("/", handleRoot);
122 server.on("/data", handleData);
123 server.on("/save", HTTP_POST, handleSave);
124 server.on("/water", HTTP_POST, handleWater);
125 server.begin();
126}
127
128void loop() {
129 server.handleClient();
130 unsigned long now = millis();
131 if (pumpOn) {
132 tankLow = !waterAvailable();
133 if (now - pumpStart >= (unsigned long)durationS * 1000UL || tankLow) setPump(false); // süre ya da su bitti / time or water ran out
134 }
135 if (now - lastCheck >= 10000) { // 10 sn'de bir kontrol / check every 10 s
136 lastCheck = now;
137 moisture = readMoisture();
138 tankLow = !waterAvailable();
139 bool soaked = !everWatered || now - lastWater >= (unsigned long)soakMin * 60000UL;
140 if (!pumpOn && !tankLow && moisture < threshold && soaked) startWatering();
141 Serial.printf("Nem / Moisture: %d %% Depo / Tank: %s\n", moisture, tankLow ? "BOS / EMPTY" : "OK");
142 }
143}| Parte del codice | Cosa fa |
|---|---|
| RAW_DRY / RAW_WET | I due valori estremi trovati durante la taratura |
| map() + constrain() | Converte il valore grezzo in 0–100% e lo tiene nell'intervallo |
| Preferences | Salva nella flash soglia, tempo della pompa e tempo di attesa |
| soakMin | Aspetta tra due irrigazioni che l'acqua si distribuisca nel terreno |
| waterAvailable() | Se il galleggiante segnala serbatoio vuoto, la pompa non parte o si ferma subito |
| /save e /water | Salvano le impostazioni del modulo e avviano un'irrigazione manuale |
Dopo il caricamento, apri l'indirizzo IP mostrato nel Monitor seriale su un telefono collegato allo stesso Wi-Fi. A seconda di come è montato il galleggiante, il contatto può essere aperto quando c'è acqua; se il pannello mostra sempre il serbatoio come "EMPTY", cambia LOW in HIGH in waterAvailable(). Il pannello non ha password, quindi usalo solo nella rete di casa; se al posto dell'IP vuoi un indirizzo facile da ricordare e un'interfaccia più reattiva, aggiungi i metodi di Web server asincrono ESP32 e WebSocket.
Proteggere la pompa quando finisce l'acqua
Le minipompe sommergibili vengono raffreddate e lubrificate dall'acqua che le attraversa. A secco si scaldano in pochi minuti e consumano guarnizioni e girante; una pompa lasciata girare in un serbatoio vuoto per tutte le vacanze di solito è da buttare. Per questo un buon sistema di irrigazione protegge la pompa su più livelli:
- Galleggiante: Quando l'acqua nel serbatoio scende sotto un certo livello il contatto si apre e il codice non avvia mai la pompa; se l'acqua finisce durante l'irrigazione, la ferma subito. I dettagli dei collegamenti sono in Sensore a galleggiante.
- Limite di tempo: La pompa non gira mai più del tempo impostato (al massimo 60 s); il software la spegne in ogni caso.
- Tempo di attesa: Tra due irrigazioni passano almeno soakMin minuti, così un sensore guasto non può costringere il sistema ad annaffiare senza sosta.
- Controllo dell'aumento di umidità: Se vuoi, tieni un contatore di errori quando dopo l'irrigazione l'umidità non è salita; dopo tre tentativi falliti ferma l'irrigazione automatica e invia un avviso con un bot Telegram. È utile se il tubo si è sfilato o il sensore è uscito dal terreno.
- Sensore di livello senza contatto: Al posto del galleggiante, un XKC-Y25 misura dall'esterno della parete del serbatoio, senza mettere nulla in acqua.
Irrigazione a batteria con il deep sleep
Per far funzionare il sistema a batteria su un balcone o in giardino senza presa, metti l'ESP32 in deep sleep tra una misura e l'altra. La versione qui sotto non usa il pannello web, perché tenere il Wi-Fi sempre acceso scaricherebbe la batteria in pochi giorni. La scheda si sveglia ogni 30 minuti, alimenta il sensore tramite il GPIO 25 solo durante la misura, fa girare la pompa se serve e torna a dormire. I contatori di risvegli e irrigazioni restano nella memoria RTC grazie a RTC_DATA_ATTR, quindi sopravvivono al sonno. Nella versione a batteria la bobina di un relè a 5 V assorbe molto e con tensione bassa potrebbe non attrarre, per cui conviene pilotare la pompa con un MOSFET a livello logico; dettagli in Usare un MOSFET con Arduino.
1// Pilli sürüm: 30 dk'da bir uyan, ölç, gerekirse sula, uyu / battery version: wake every 30 min, measure, water if needed, sleep
2const int SOIL_PIN = 34; // sensör AOUT / sensor AOUT
3const int SENSOR_PWR = 25; // sensör VCC bu pinden / sensor VCC from this pin
4const int PUMP_PIN = 26; // röle IN ya da MOSFET gate / relay IN or MOSFET gate
5const int FLOAT_PIN = 27; // şamandıra / float switch
6const bool PUMP_ACTIVE_LOW = true; // MOSFET kullanıyorsan false / false if you use a MOSFET
7const int RAW_DRY = 3000, RAW_WET = 1250;
8const int THRESHOLD = 35; // %
9const int DURATION_S = 5; // sn / s
10const uint64_t SLEEP_US = 30ULL * 60 * 1000000; // 30 dakika / 30 minutes
11
12RTC_DATA_ATTR int wakeCount = 0; // deep sleep'te silinmez / survives deep sleep
13RTC_DATA_ATTR int waterCount = 0;
14
15void pump(bool on) {
16 digitalWrite(PUMP_PIN, (on != PUMP_ACTIVE_LOW) ? HIGH : LOW);
17}
18
19void setup() {
20 Serial.begin(115200);
21 wakeCount++;
22 pinMode(PUMP_PIN, OUTPUT);
23 pump(false);
24 pinMode(FLOAT_PIN, INPUT_PULLUP);
25 pinMode(SENSOR_PWR, OUTPUT);
26 digitalWrite(SENSOR_PWR, HIGH); // sensörü yalnız ölçerken aç / power the sensor only while measuring
27 delay(200); // çıkışın oturmasını bekle / let the output settle
28 long sum = 0;
29 for (int i = 0; i < 16; i++) { sum += analogRead(SOIL_PIN); delay(5); }
30 digitalWrite(SENSOR_PWR, LOW);
31 int pct = constrain(map(sum / 16, RAW_DRY, RAW_WET, 0, 100), 0, 100);
32 bool water = digitalRead(FLOAT_PIN) == LOW;
33 Serial.printf("Uyanma / Wake %d: nem / moisture %d %%, depo / tank %s, sulama / waterings %d\n",
34 wakeCount, pct, water ? "OK" : "BOS / EMPTY", waterCount);
35
36 if (pct < THRESHOLD && water) {
37 pump(true);
38 unsigned long start = millis();
39 while (millis() - start < DURATION_S * 1000UL && digitalRead(FLOAT_PIN) == LOW) delay(10); // su biterse hemen dur / stop at once if the tank empties
40 pump(false);
41 waterCount++;
42 }
43 esp_sleep_enable_timer_wakeup(SLEEP_US);
44 esp_deep_sleep_start(); // uyanınca setup() baştan başlar / wakes up into setup()
45}
46
47void loop() {
48}Quello che decide la durata della batteria è soprattutto l'assorbimento della scheda in sleep. Un normale ESP32 DevKit può assorbire 5–10 mA in sleep per colpa del regolatore e del chip USB-seriale: a 10 mA una batteria da 3000 mAh dura appena 300 ore, circa 12 giorni. Con una scheda a basso consumo che dorme a 0,15 mA il quadro cambia: 48 risvegli al giorno (0,5 secondi ciascuno a 50 mA), 0,15 mA di sleep e una pompata giornaliera di 5 secondi fanno in totale circa 4,3 mAh; la stessa batteria in teoria durerebbe quasi due anni, anche se in pratica l'autoscarica limita tutto a qualche mese. Fai il conto con i tuoi valori nello strumento Durata della batteria e scopri come ridurre il consumo in sleep in ESP32 Deep Sleep.
Idee di progetto e miglioramenti
- Più vasi: Dai a ogni vaso un sensore e una pompa; i pin ADC1 dell'ESP32 bastano fino a sei vasi.
- Notifiche: Invia un messaggio al telefono con Telegram quando il serbatoio è vuoto o il terreno resta troppo secco.
- Registro dell'umidità: Salva le letture su Google Sheets e guarda su un grafico ogni quanto la pianta ha bisogno d'acqua.
- Irrigazione a energia solare: Ricarica la batteria di giorno con un piccolo pannello solare e un TP4056.
- Controllo pioggia: All'aperto aggiungi un sensore di pioggia e salta l'irrigazione quando piove.
- Serra intelligente: Aggiungi temperatura, umidità dell'aria e una ventola per trasformarlo in un progetto di serra intelligente.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Umidità sempre a 0% o ferma | Sensore su un pin ADC2 con il Wi-Fi attivo | Sposta il sensore su uno dei GPIO 32–39 |
| Le letture saltano di continuo | Disturbi o sensore poco aderente al terreno | Fai la media di 16 letture e pianta bene il sensore |
| L'ESP32 si resetta quando parte la pompa | Calo di tensione, manca il diodo | Aggiungi il diodo e un condensatore da 470 µF, usa un alimentatore da 2 A |
| Il relè non si diseccita mai | Il relè a 5 V non riconosce l'HIGH a 3,3 V | Usa un relè compatibile con 3,3 V o un MOSFET, controlla RELAY_ACTIVE_LOW |
| Il vaso trabocca | Tempo di attesa troppo breve o effetto sifone | Aumenta soakMin, porta l'uscita del tubo sopra il livello del serbatoio |
| La pompa gira ma l'acqua non esce | Aria nella pompa o serbatoio vuoto | Immergi completamente la pompa, controlla il galleggiante |
| Le impostazioni spariscono dopo un blackout | I valori non vengono salvati nella flash | Controlla che le righe con prefs.putInt() vengano eseguite |
Visto che mette insieme misura, decisione, sicurezza e controllo a distanza in un solo progetto, questa irrigazione automatica con ESP32 è anche un ottimo primo passo verso la domotica. Se vuoi vedere passo dopo passo un circuito di irrigazione, nell'app BlueGrays il progetto Stazione di irrigazione intelligente offre lo schema di collegamento e il codice pronto da caricare in una versione per Arduino.
Domande frequenti
Come si fa un'irrigazione automatica con ESP32?
Collega un sensore di umidità del terreno capacitivo a un pin ADC1 dell'ESP32 e un modulo relè a un pin digitale, e alimenta la minipompa tramite il relè con un alimentatore da 5 V separato. Tara il sensore in aria e in acqua e imposta nel codice una soglia di umidità; quando l'umidità scende sotto, la pompa gira per qualche secondo e il sistema aspetta che l'acqua venga assorbita.
A quale pin dell'ESP32 si collega il sensore di umidità del terreno?
Collega l'uscita analogica a uno dei pin ADC1 tra GPIO 32 e 39; in questa guida usiamo il GPIO 34. I pin ADC2 non si possono leggere con analogRead() quando il Wi-Fi è attivo, quindi nei progetti Wi-Fi il sensore va sempre su ADC1.
A che percentuale di umidità bisogna annaffiare?
Dipende dalla pianta: 15–25% per cactus e piante grasse, 30–40% per la maggior parte delle piante da appartamento e 45–60% per ortaggi come pomodori e basilico sono buoni punti di partenza. Poiché le percentuali dipendono dalla taratura del sensore, osserva la pianta per qualche giorno e regola la soglia.
Meglio pilotare la pompa con un relè o con un MOSFET?
In un sistema alimentato dalla rete, un modulo relè che si attiva con 3,3 V è pratico e sicuro. A batteria, o se vuoi regolare la velocità della pompa in PWM, un MOSFET a livello logico consuma meno ed è silenzioso; in entrambi i casi serve un diodo in antiparallelo sulla pompa.
La minipompa si rompe se gira a secco?
Sì. Le minipompe sommergibili vengono raffreddate e lubrificate dall'acqua che le attraversa e a secco si surriscaldano e si consumano in pochi minuti. Un galleggiante o un sensore di livello senza contatto nel serbatoio, che ferma la pompa via software, è la protezione più semplice.
Quanto dura a batteria un'irrigazione con ESP32?
Con il Wi-Fi sempre acceso la batteria si scarica in pochi giorni. Con il deep sleep dipende dall'assorbimento della scheda in sleep: un normale DevKit da 10 mA in sleep dura circa 12 giorni con 3000 mAh, mentre una scheda a basso consumo da 0,15 mA arriva a mesi.
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.

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

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.

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.

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.

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.

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

