Capteur d'humidité du sol : arrosage automatique des plantes avec Arduino

Un capteur d'humidité du sol est un capteur simple qui mesure à quel point la terre est humide dans un pot ou au jardin. Il est à la base de nombreux projets, du voyant qui t'avertit quand une plante a soif au système qui arrose tes fleurs pendant tes vacances. Il est bon marché, se branche sur un Arduino avec trois fils, et avec un relais et une petite pompe tu obtiens une automatisation vraiment utile.

Comment fonctionne un capteur d'humidité du sol ?

L'eau contenue dans le sol modifie sa capacité à conduire l'électricité et à stocker des charges. Les capteurs résistifs mesurent la résistance entre deux pointes métalliques plantées dans la terre : plus la terre est humide, plus la résistance baisse. Les capteurs capacitifs mesurent la capacité autour d'une électrode recouverte ; le métal ne touche jamais la terre. Sur la plupart des modules, la valeur est élevée quand la terre est sèche et basse quand elle est humide.

Câblage

Lire l'humidité avec Arduino et étalonner

Chaque capteur et chaque terre donnent des valeurs différentes : commence donc par étalonner ton capteur. Note la valeur lue quand le capteur est à l'air (complètement sec) puis plongé dans un verre d'eau (complètement mouillé). Ensuite, avec map(), tu convertis cette plage en pourcentage de 0 à 100. Remplace DRY et WET dans le code par tes propres mesures :

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}

Arrosage automatique : relais et pompe

Transformons maintenant la mesure en action : quand l'humidité du sol passe sous 30 %, la pompe tourne 4 secondes, puis on attend 1 minute que l'eau se répartisse dans la terre avant de mesurer à nouveau. Cette pause évite que la pompe tourne sans arrêt et fasse déborder le pot parce que le capteur n'est pas encore mouillé. La pompe ne peut pas être alimentée directement par une broche d'Arduino ; on la commande via un relais ou un MOSFET. Pour le câblage du relais, vois Qu'est-ce qu'un module relais ?

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}

L'humidité du sol avec l'ESP32 et le Raspberry Pi Pico

Sur l'ESP32, branche le capteur sur une broche ADC1 (GPIO 32 à 39), qui fonctionne même avec le Wi-Fi actif ; les valeurs vont de 0 à 4095, il faut donc étalonner à nouveau. Avec un ESP32, tu peux envoyer l'humidité sur ton téléphone sous forme de notification, ou fabriquer un capteur de pot qui mesure une fois par heure en sommeil profond et tient des mois sur pile. Sur le Pico en MicroPython, la lecture se fait ainsi :

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)

Quelle humidité faut-il viser ?

Ces pourcentages se rapportent à la plage sec-mouillé de ton capteur ; ce n'est pas la teneur en eau du sol au sens scientifique. Le meilleur seuil se trouve en observant pendant quelques jours ce qu'indique le capteur quand ta plante a vraiment besoin d'eau.

Idées de projets avec un capteur d'humidité du sol

• Arrosage automatique de pots : un système qui arrose tes fleurs tout seul, même pendant tes vacances.
• Alerte « j'ai soif » : une LED qui s'allume ou un buzzer qui sonne quand la terre se dessèche.
• Notification sur le téléphone : envoie un message Telegram depuis un ESP32 quand l'humidité baisse.
• Arrosage de plusieurs pots : donne à chaque pot son capteur et une petite vanne pour arroser chaque plante séparément.
• Mini-station de serre : mesure aussi l'humidité de l'air avec un DHT11 et la lumière avec une LDR, et affiche tout sur un écran.
• Jardin intelligent : saute automatiquement l'arrosage quand un capteur de pluie détecte des précipitations.

Erreurs fréquentes et solutions

• La valeur est toujours 1023 ou toujours 0 : c'est la broche DO qui est lue au lieu de AO, l'alimentation manque, ou le fil vers la carte du capteur est coupé.
• Les pointes ont rouillé et les mesures n'ont plus de sens : le capteur résistif a été alimenté en permanence ; alimente-le par une broche ou passe à un modèle capacitif.
• Les mesures dérivent avec le temps : la conductivité change quand la terre se tasse ou qu'on ajoute de l'engrais ; réétalonne de temps en temps.
• La pompe ne s'arrête pas : le relais est actif à l'état bas et HIGH/LOW sont inversés dans le code, ou la mesure est refaite avant que l'eau ait pénétré ; ajoute une pause entre deux mesures.
• Le capteur capacitif donne des valeurs étranges : l'électronique du haut a pris l'eau ; rends la carte étanche.
• Sur l'ESP32, les mesures déraillent au démarrage du Wi-Fi : le capteur est sur une broche ADC2 ; déplace-le sur une broche entre GPIO 32 et 39.

Un capteur d'humidité du sol peut être ton premier projet qui va au-delà de la mesure et change vraiment quelque chose dans le monde réel. Dans l'application BlueGrays, tu trouveras une station d'arrosage intelligente et un système d'arrosage de plantes avec ESP32, pas à pas avec schémas et code.