Sensore di umidità del terreno: irrigazione automatica delle piante con Arduino

Un sensore di umidità del terreno è un sensore semplice che misura quanto è bagnata la terra in un vaso o in giardino. È alla base di molti progetti, da una spia che avvisa quando una pianta ha sete a un sistema che annaffia i fiori mentre sei in vacanza. È economico, si collega ad Arduino con tre fili e, aggiungendo un relè e una piccola pompa, ottieni un'automazione davvero utile.

Come funziona un sensore di umidità del terreno?

L'acqua nel terreno cambia la capacità della terra di condurre elettricità e di accumulare carica. I sensori resistivi misurano la resistenza tra due punte metalliche infilate nella terra: più la terra è bagnata, più la resistenza scende. I sensori capacitivi misurano la capacità intorno a un elettrodo rivestito; il metallo non tocca mai la terra. Nella maggior parte dei moduli la lettura è alta con terra secca e bassa con terra bagnata.

Collegamento

Leggere l'umidità con Arduino e calibrare

Ogni sensore e ogni terreno danno valori diversi, quindi prima calibra il tuo sensore: annota la lettura con il sensore all'aria (completamente asciutto) e immerso in un bicchiere d'acqua (completamente bagnato). Poi con map() trasformi questo intervallo in una percentuale da 0 a 100. Sostituisci DRY e WET nel codice con le tue letture:

1const int SENSOR_PIN = A0;
2const int POWER_PIN = 7;       // sensörü yalnızca ölçerken besle / power only while measuring
3const int DRY = 850;           // havadayken okunan / reading in air (kendin ölç / measure yours)
4const int WET = 380;           // sudayken okunan / reading in water (kendin ölç / measure yours)
5
6void setup() {
7  pinMode(POWER_PIN, OUTPUT);
8  Serial.begin(9600);
9}
10
11int readMoisture() {
12  digitalWrite(POWER_PIN, HIGH);
13  delay(10);                                              // değerin oturmasını bekle / let it settle
14  int raw = analogRead(SENSOR_PIN);
15  digitalWrite(POWER_PIN, LOW);
16  return constrain(map(raw, DRY, WET, 0, 100), 0, 100);   // % nem / % moisture
17}
18
19void loop() {
20  int moisture = readMoisture();
21  Serial.print("Toprak nemi / Soil moisture: %");
22  Serial.println(moisture);
23  delay(2000);
24}

Irrigazione automatica: relè e pompa

Ora trasformiamo la misura in un'azione reale: quando l'umidità scende sotto il 30%, la pompa va per 4 secondi, poi si aspetta 1 minuto che l'acqua si distribuisca nella terra prima di misurare di nuovo. Questa attesa evita che la pompa non si fermi più e allaghi il vaso perché il sensore non si è ancora bagnato. La pompa non si può alimentare direttamente da un pin di Arduino; si comanda tramite un relè o un MOSFET. Per il collegamento del relè vedi Cos'è un modulo relè?

1const int SENSOR_PIN = A0, POWER_PIN = 7, PUMP_PIN = 8;   // PUMP_PIN → röle IN / relay IN
2const int DRY = 850, WET = 380;
3const int START_BELOW = 30;          // %30'un altında sula / water below 30%
4const unsigned long PUMP_MS = 4000;  // her seferde 4 sn / 4 s per run
5const unsigned long SOAK_MS = 60000; // suyun yayılması için bekle / wait for the water to soak in
6
7int readMoisture() {
8  digitalWrite(POWER_PIN, HIGH);
9  delay(10);
10  int raw = analogRead(SENSOR_PIN);
11  digitalWrite(POWER_PIN, LOW);
12  return constrain(map(raw, DRY, WET, 0, 100), 0, 100);
13}
14
15void setup() {
16  pinMode(POWER_PIN, OUTPUT);
17  pinMode(PUMP_PIN, OUTPUT);
18  digitalWrite(PUMP_PIN, HIGH);      // aktif LOW röle: kapalı başla / active-LOW relay: start off
19}
20
21void loop() {
22  if (readMoisture() < START_BELOW) {
23    digitalWrite(PUMP_PIN, LOW);     // pompayı çalıştır / pump on
24    delay(PUMP_MS);
25    digitalWrite(PUMP_PIN, HIGH);    // pompayı durdur / pump off
26    delay(SOAK_MS);                  // tekrar ölçmeden önce bekle / wait before measuring again
27  }
28  delay(5000);
29}

Umidità del terreno con ESP32 e Raspberry Pi Pico

Sull'ESP32 collega il sensore a uno dei pin ADC1 (GPIO 32–39), che funzionano anche con il Wi-Fi attivo; i valori vanno da 0 a 4095, quindi ricalibra. Con un ESP32 puoi inviare l'umidità al telefono come notifica, oppure costruire un sensore da vaso che misura una volta all'ora in deep sleep e dura mesi a batteria. Sul Pico con MicroPython la lettura è così:

1from machine import ADC, Pin
2import time
3
4sensor = ADC(26)               # GP26 → AOUT
5power = Pin(15, Pin.OUT)       # sensörü yalnızca ölçerken besle / power only while measuring
6DRY, WET = 52000, 24000        # kendi değerlerinle değiştir / replace with your readings
7
8def moisture():
9    power.value(1)
10    time.sleep_ms(10)
11    raw = sensor.read_u16()
12    power.value(0)
13    pct = (DRY - raw) * 100 // (DRY - WET)
14    return max(0, min(100, pct))
15
16while True:
17    print("Toprak nemi / Soil moisture: %", moisture())
18    time.sleep(2)

Quanta umidità deve avere il terreno?

Queste percentuali si riferiscono all'intervallo secco-bagnato del tuo sensore; non sono il contenuto d'acqua del terreno in senso scientifico. La soglia migliore si trova osservando per qualche giorno cosa segna il sensore quando la pianta ha davvero bisogno d'acqua.

Idee di progetti con il sensore di umidità del terreno

• Irrigazione automatica dei vasi: un sistema che annaffia i fiori da solo, anche quando sei in vacanza.
• Avviso "ho sete": un LED che si accende o un buzzer che suona quando la terra si secca.
• Notifica sul telefono: invia un messaggio Telegram da un ESP32 quando l'umidità cala.
• Irrigazione di più vasi: dai a ogni vaso un sensore e una piccola valvola e annaffia le piante separatamente.
• Mini stazione per serra: misura anche l'umidità dell'aria con un DHT11 e la luce con una LDR, e mostra tutto su un display.
• Giardino intelligente: salta automaticamente l'irrigazione quando un sensore di pioggia rileva precipitazioni.

Errori comuni e come risolverli

• Il valore è sempre 1023 o sempre 0: viene letto il pin DO invece di AO, manca l'alimentazione o il filo verso la scheda del sensore è interrotto.
• Le punte si sono corrose e le letture non hanno senso: il sensore resistivo è stato alimentato di continuo; alimentalo da un pin o passa a un modello capacitivo.
• Le letture cambiano col tempo: la conducibilità varia quando la terra si compatta o viene concimata; ricalibra ogni tanto.
• La pompa non si ferma: il relè è attivo basso e HIGH/LOW sono invertiti nel codice, oppure si misura di nuovo prima che l'acqua sia assorbita; aggiungi un'attesa tra le misure.
• Il sensore capacitivo dà valori strani: l'elettronica in alto si è bagnata; rendi impermeabile la scheda.
• Sull'ESP32 le letture impazziscono quando parte il Wi-Fi: il sensore è su un pin ADC2; spostalo su un pin tra GPIO 32 e 39.

Un sensore di umidità del terreno può essere il tuo primo progetto che va oltre la misura e cambia davvero qualcosa nel mondo reale. Nell'app BlueGrays trovi una stazione di irrigazione intelligente e un sistema di irrigazione per piante con ESP32, passo passo con schemi e codice.