Chapitre 9 — Automatisation de l’Irrigation avec ESP32

Après avoir découvert les capteurs au chapitre précédent, nous passons à l’action : construire un système d’irrigation automatique qui prend des décisions basées sur des mesures réelles du sol et de l’environnement. L’objectif est de maintenir l’humidité du sol dans une plage optimale, en minimisant la consommation d’eau.

9.1 Architecture du système

Un système d’irrigation automatique repose sur trois couches :

Schéma fonctionnel

[Capteur humidité] ──┐
[Capteur température] ─┤
[Pluviomètre] ─────────┤──→ [ESP32] ──→ [Module relais] ──→ [Électrovanne / Pompe]
[Horloge RTC] ─────────┤        │
[Seuils configurés] ───┘        └──→ [Stockage données / WiFi]

9.2 Composants matériels

Électrovannes

Une électrovanne (solenoid valve) contrôle le passage de l’eau. On distingue :

• Normalement fermée (NF) : l’eau ne passe que lorsque la bobine est alimentée. Sécuritaire en cas de panne (pas de fuite).
• Normalement ouverte (NO) : l’eau passe par défaut. Utile pour les systèmes où l’arrosage est la norme.

Point pratique : Pour un jardin, choisir une vanne NF 12V DC, débit ≥ 10 L/min, pression de travail 0,2–8 bar. Les vannes d’irrigation de type Gardena ou Hunter fonctionnent en 24V AC — elles nécessitent un transformateur.

Puissance de la bobine : P = U × I. Une vanne 12V / 0,5A consomme 6W. C’est trop pour un GPIO de l’ESP32 (max 12 mA à 3,3V) → il faut un relais ou un MOSFET.

Module relais

Le relais agit comme un interrupteur commandé électriquement :

ESP32 GPIO ──→ [Optocoupleur] ──→ [Bobine relais] ──→ [Contact] ──→ Vanne 12V
    3,3V              Isolation galvanique           Commutation puissance

Choix du module :

• Module relais 5V avec optocoupleur intégré (SRD-05VDC)
• Entrée compatible 3,3V (vérifier : certains modules nécessitent un level shifter)
• Capacité du contact : ≥ 10A @ 250VAC ou 30VDC

⚠️ Protection contre les surtensions : la bobine de l’électrovanne génère un pic de tension à la coupure (loi de Lenz). Une diode de roue libre (1N4007) en antiparallèle sur la bobine est indispensable.

Pompe (optionnel)

Pour les systèmes alimentés par une cuve (récupération d’eau de pluie) :

• Pompe submersible 12V DC, débit 3-5 L/min
• Pression : 0,2-0,5 bar (suffisant pour goutte-à-goutte)
• Commande identique à l’électrovanne : via relais

Capteur de pluie

Un simple interrupteur à lame ou un capteur résistif détecte s’il pleut. On peut aussi utiliser un pluviomètre à augets basculants (tipping bucket) pour une mesure quantitative :

Résolution = Volume de l’auget / Surface de collecte

Un auget de 3,2 mL avec une surface de collecte de 55 cm² donne 0,2 mm par basculement.

9.3 Circuits de puissance et sécurité

Dimensionnement de l’alimentation

Le système complet consomme :

Équation clé — Capacité batterie :

C(Ah) = I_moyen × t_autonomie × facteur_sécurité

Pour 24h d’autonomie solaire avec une mesure toutes les 15 min (deep sleep entre les mesures) et un arrosage de 10 min/jour :

• Veille : 10 µA × 23,8 h = 0,238 mAh
• Mesures : 250 mA × (96 × 2s) / 3600 = 13,3 mAh
• Arrosage : (240 + 70) mA × 10/60 h = 51,7 mAh
• Électrovanne (alimentation séparée 12V) : 500 mA × 10/60 h = 83,3 mAh @ 12V
• Total côté ESP32 ≈ 65 mAh → batterie 18650 (3400 mAh) = ~50 jours

Protection électrique

1. Fusible sur l’alimentation 12V (1A)
2. Diode de roue libre (1N4007) sur chaque charge inductive
3. Condensateur de découplage (100 µF) sur l’alimentation de l’ESP32
4. Boîtier étanche IP65 minimum pour l’électronique au jardin

9.4 Algorithme de décision

Approche par seuils simples

L’algorithme le plus basique compare l’humidité mesurée à deux seuils :

SI humidité < seuil_bas ET pas_de_pluie :
    OUVRIR vanne pendant durée_arrosage
SI humidité > seuil_haut :
    FERMER vanne

Limites : pas de prise en compte de la météo, risque d’arrosage juste avant la pluie, pas d’adaptation saisonnière.

Approche par bilan hydrique simplifié

Plus intelligent, cet algorithme estime le stock d’eau dans le sol :

S(t+1) = S(t) + P + I - ET_estimée

avec :

• S(t) recalé régulièrement par la mesure du capteur d’humidité
• ET estimée via la température et l’humidité relative (formule de Hargreaves simplifiée)

ET₀ ≈ 0,0023 × (T_moy + 17,8) × √(T_max - T_min) × Ra

où Ra = rayonnement extraterrestre (tabulé selon latitude et jour de l’année)

Algorithme multi-zones

Un jardin comporte souvent des zones aux besoins différents :

Chaque zone possède sa propre électrovanne et son capteur d’humidité. L’ESP32 gère les zones séquentiellement (jamais deux vannes ouvertes en même temps, pour maintenir la pression).

9.5 Implémentation MicroPython

Classe de gestion d’une zone d’irrigation

# code/irrigation_zone.py
from machine import Pin, ADC
import time

class ZoneIrrigation:
    def __init__(self, nom, pin_relais, pin_capteur,
                 seuil_bas=40, seuil_haut=70,
                 duree_max=600):
        self.nom = nom
        self.relais = Pin(pin_relais, Pin.OUT, value=0)
        self.capteur = ADC(Pin(pin_capteur))
        self.capteur.atten(ADC.ATTN_11DB)
        self.seuil_bas = seuil_bas
        self.seuil_haut = seuil_haut
        self.duree_max = duree_max  # secondes

Le fichier complet code/irrigation_zone.py contient les méthodes de lecture, calibration et arrosage.

Lecture de l’humidité avec moyennage

Les capteurs capacitifs sont bruités. Un moyennage sur N mesures stabilise la lecture :

def lire_humidite(self, n_samples=10, delai_ms=50):
    lectures = []
    for _ in range(n_samples):
        lectures.append(self.capteur.read())
        time.sleep_ms(delai_ms)
    brut = sum(lectures) // len(lectures)
    # Conversion en % (calibration linéaire)
    # air = 3200, eau = 1400 (valeurs typiques)
    pct = max(0, min(100,
        (3200 - brut) * 100 // (3200 - 1400)))
    return pct

Boucle principale du contrôleur

# code/controleur_irrigation.py (extrait)
from irrigation_zone import ZoneIrrigation
from machine import RTC, deepsleep
import network, ntptime

zones = [
    ZoneIrrigation("Potager", pin_relais=26,
                   pin_capteur=34, seuil_bas=40),
    ZoneIrrigation("Pelouse", pin_relais=27,
                   pin_capteur=35, seuil_bas=30),
]

def cycle_irrigation():
    for zone in zones:
        h = zone.lire_humidite()
        print(f"{zone.nom}: {h}%")
        if h < zone.seuil_bas:
            zone.arroser()

Le contrôleur effectue un cycle de mesure, arrose si nécessaire, puis entre en deep sleep jusqu’au prochain cycle.

9.6 Gestion du temps et planification

Horloge temps réel (RTC)

L’ESP32 possède un RTC interne qui survit au deep sleep. Cependant, il dérive (~5 s/jour). Pour les systèmes connectés, la synchronisation NTP corrige cette dérive :

import ntptime
ntptime.host = "pool.ntp.org"
ntptime.settime()  # Synchronise le RTC interne

Fenêtres d’arrosage

L’arrosage est plus efficace tôt le matin (6h-8h) ou en soirée (19h-21h) :

• Évaporation minimale → meilleure absorption
• Feuillage sec avant la nuit → réduction des maladies fongiques

def dans_fenetre_arrosage():
    heure = time.localtime()[3]  # heure courante
    return (6 <= heure <= 8) or (19 <= heure <= 21)

Inhibition par la pluie

Un capteur de pluie ou une API météo peut inhiber l’arrosage :

def verifier_pluie(pin_pluie=33):
    """Capteur de pluie : 0 = pluie détectée"""
    pluie = Pin(pin_pluie, Pin.IN, Pin.PULL_UP)
    return pluie.value() == 0

def prevoir_pluie_api():
    """Interroge OpenWeatherMap (nécessite WiFi)"""
    import urequests, json
    url = ("http://api.openweathermap.org/data/2.5/"
           "forecast?q=Paris&appid=VOTRE_CLE&cnt=8")
    r = urequests.get(url)
    data = json.loads(r.text)
    r.close()
    for item in data["list"]:
        if "rain" in item.get("weather", [{}])[0].get("main", "").lower():
            return True
    return False

9.7 Modes de fonctionnement

Le système prévoit plusieurs modes :

Machine à états

              ┌──────────┐
    ┌────────→│   AUTO   │←──────────┐
    │         └────┬─────┘           │
    │              │ T<2°C           │ T>5°C
    │              ▼                 │
    │         ┌──────────┐           │
    │         │ HORS-GEL │───────────┘
    │         └──────────┘
    │
    │  btn    ┌──────────┐
    └─────────│  MANUEL  │
              └──────────┘

9.8 Optimisation de la consommation d’eau

Arrosage par impulsions

Plutôt qu’un long arrosage continu, des impulsions courtes permettent une meilleure infiltration :

Principe : 3 × 5 minutes espacées de 15 minutes > 1 × 15 minutes continues

L’eau a le temps de s’infiltrer au lieu de ruisseler en surface.

Coefficient cultural (Kc)

Le besoin réel d’une culture = ET₀ × Kc, où Kc varie selon le stade de croissance :

L’intégration du Kc dans l’algorithme permet de réduire la consommation de 20-30% par rapport à un arrosage à seuil fixe.

Mesure de l’eau consommée

Un débitmètre à effet Hall (type YF-S201) sur la canalisation mesure le volume d’eau utilisé :

Volume = nombre_d’impulsions / facteur_K

Facteur K typique : 7,5 impulsions/litre pour le YF-S201

from machine import Pin
compteur = 0

def compter_impulsion(pin):
    global compteur
    compteur += 1

debit_pin = Pin(25, Pin.IN, Pin.PULL_UP)
debit_pin.irq(trigger=Pin.IRQ_FALLING,
              handler=compter_impulsion)

9.9 Journalisation et diagnostic

Le système enregistre chaque événement pour le diagnostic :

def log_evenement(zone, action, humidite, volume=0):
    timestamp = time.localtime()
    ligne = "{:04d}-{:02d}-{:02d} {:02d}:{:02d}," \
            "{},{},{},{}\n".format(
        *timestamp[:5], zone, action, humidite, volume)
    with open("/data/log.csv", "a") as f:
        f.write(ligne)

Format CSV résultant :

2026-03-23 07:15,Potager,ARROSAGE,35,12.5
2026-03-23 07:16,Pelouse,SKIP,42,0
2026-03-23 19:00,Potager,ARROSAGE,38,10.2

9.10 Tests et calibration

Calibration du capteur d’humidité

Protocole :

1. Point sec : capteur dans l’air → noter la valeur ADC (typiquement ~3200)
2. Point saturé : capteur dans l’eau → noter la valeur ADC (typiquement ~1400)
3. Vérification : comparer avec un tensiomètre à 3 niveaux d’humidité

Test du système complet

Checklist avant déploiement :

• Chaque relais commute correctement (test LED)
• Chaque vanne s’ouvre et se ferme sans fuite
• Les capteurs retournent des valeurs cohérentes
• Le deep sleep et le réveil fonctionnent
• La synchronisation NTP réussit
• Le log CSV s’écrit correctement
• Le mode HORS-GEL se déclenche sous 2°C
• Le capteur de pluie inhibe l’arrosage

9.11 Récapitulatif

💡 Point pratique : Commencez par le système le plus simple (un capteur, une vanne, seuils fixes). Ajoutez la complexité progressivement : multi-zones, bilan hydrique, API météo. Un système simple qui fonctionne vaut mieux qu’un système complexe qui plante.

← Retour à la Table des Matières

>> You can subscribe to my mailing list here for a monthly update. <<