Guide · 10 min di lettura

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.

Minipompa sommergibile per acqua
Minipompa sommergibile da 3–6 V: sta nel serbatoio, spinge l'acqua nel vaso attraverso un tubicino e assorbe circa 100–200 mA.

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.

ComponenteCompitoNota
ESP32 DevKitMisura, decide e gestisce il pannello webSolo Wi-Fi a 2,4 GHz
Sensore di umidità del terreno capacitivo v1.2Trasforma l'umidità del terreno in una tensione analogicaNon si corrode; funziona da 3,3 a 5,5 V
Modulo relè a 1 canaleAccende e spegne la pompaScegli un modello che si attivi con 3,3 V
Minipompa sommergibile 3–6 V e tuboPorta l'acqua dal serbatoio al vasoCirca 100–200 mA
Sensore di livello a galleggianteSegnala quando il serbatoio è vuotoProtegge la pompa dal funzionamento a secco
Alimentatore 5 V 2 AAlimenta ESP32, relè e pompaTutte le masse collegate
Diodo 1N4007 o 1N5819Assorbe il picco di tensione allo spegnimento della pompaCatodo 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

CollegamentoPin ESP32Nota
AOUT del sensoreGPIO 34Canale ADC1; leggibile anche con il Wi-Fi attivo
VCC del sensore3V3 (GPIO 25 nella versione a batteria)A batteria è alimentato solo durante la misura
GND del sensoreGNDMassa comune
IN del relèGPIO 26La maggior parte dei moduli si attiva con LOW
VCC / GND del relèVIN (5 V) / GNDLa bobina del relè vuole 5 V
GalleggianteGPIO 27 e GNDINPUT_PULLUP; contatto chiuso finché c'è acqua
Pompa5 V, tramite COM–NO del relèLa corrente della pompa non passa dall'ESP32
Sull'ESP32 i pin dei canali ADC2 (GPIO 0, 2, 4, 12–15 e 25–27) non si possono leggere con analogRead() quando il Wi-Fi è attivo, perché il Wi-Fi usa quel convertitore. Collega sempre il sensore a un canale ADC1, cioè tra GPIO 32 e 39. Occhio anche al relè: alcuni moduli relè con optoisolatore alimentati a 5 V non interpretano l'HIGH a 3,3 V dell'ESP32 come "spento" e il relè resta sempre eccitato. Scegli un modulo che si attivi con 3,3 V oppure pilota la pompa con un MOSFET a livello logico.

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

C++ (Arduino IDE)
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}
CondizioneValore grezzo (esempio)Umidità (%)
In aria (completamente secco)≈ 30000 (RAW_DRY)
Terreno secco≈ 2500–270017–29
Terreno umido (ideale per quasi tutte le piante)≈ 1800–220046–69
Terreno appena annaffiato≈ 1500–170074–86
In un bicchiere d'acqua≈ 1250100 (RAW_WET)
Infila il sensore nell'acqua o nel terreno solo fino alla linea stampata; se si bagna l'elettronica in alto, il sensore è da buttare. Per letture costanti, inseriscilo sempre alla stessa profondità e compatta bene la terra intorno; le sacche d'aria fanno sembrare il terreno più secco di quanto sia. Se vuoi il riferimento "bagnato" più realistico, annaffia bene il vaso, aspetta un'ora e usa il valore che leggi in quel momento.

Scegliere la soglia di irrigazione in base alla pianta

Tipo di piantaSoglia di irrigazioneNota
Cactus e piante grasse15–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:

C++ (Arduino IDE)
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> &middot; 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 codiceCosa fa
RAW_DRY / RAW_WETI due valori estremi trovati durante la taratura
map() + constrain()Converte il valore grezzo in 0–100% e lo tiene nell'intervallo
PreferencesSalva nella flash soglia, tempo della pompa e tempo di attesa
soakMinAspetta 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 /waterSalvano 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.

C++ (Arduino IDE)
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.

Durante il deep sleep i pin dell'ESP32 restano flottanti. La maggior parte dei moduli relè considera un ingresso flottante come "spento", ma se usi un MOSFET metti una resistenza da 100 kΩ tra gate e GND; altrimenti il gate resta scollegato e la pompa potrebbe accendersi da sola mentre la scheda dorme. Spegni sempre la pompa nel codice prima di dormire e tieni d'occhio il montaggio nei primi giorni.

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

SintomoCausa probabileSoluzione
Umidità sempre a 0% o fermaSensore su un pin ADC2 con il Wi-Fi attivoSposta il sensore su uno dei GPIO 32–39
Le letture saltano di continuoDisturbi o sensore poco aderente al terrenoFai la media di 16 letture e pianta bene il sensore
L'ESP32 si resetta quando parte la pompaCalo di tensione, manca il diodoAggiungi il diodo e un condensatore da 470 µF, usa un alimentatore da 2 A
Il relè non si diseccita maiIl relè a 5 V non riconosce l'HIGH a 3,3 VUsa un relè compatibile con 3,3 V o un MOSFET, controlla RELAY_ACTIVE_LOW
Il vaso traboccaTempo di attesa troppo breve o effetto sifoneAumenta soakMin, porta l'uscita del tubo sopra il livello del serbatoio
La pompa gira ma l'acqua non esceAria nella pompa o serbatoio vuotoImmergi completamente la pompa, controlla il galleggiante
Le impostazioni spariscono dopo un blackoutI valori non vengono salvati nella flashControlla che le righe con prefs.putInt() vengano eseguite
Prima di provarlo su una pianta vera, collauda il sistema con un bicchiere d'acqua e un asciugamano: verifica che la pompa parta con il sensore in aria, si fermi quando lo immergi nell'acqua e si spenga subito quando abbassi il galleggiante. Metti l'elettronica in una scatola chiusa lontano dall'acqua e non tenere l'ESP32 e il serbatoio sullo stesso ripiano.

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.

Vedi tutti i progetti
Stazione di irrigazione intelligente
AR-83Avanzato
Premium

Stazione di irrigazione intelligente

Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

5.0(42)
57
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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

4.8(16)
26
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

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.

4.4(21)
38
ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
ES-33Avanzato
Premium

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.

4.3(10)
16
ESP32 DHT22 Temperatura e umidità (con display LCD)
ES-15Intermedio

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.

4.8(38)
57
Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
ES-37Avanzato
Premium

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.

4.3(6)
11
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

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.

4.7(7)
12