Système d'irrigation Zigbee sous Home Assistant — 3 zones, 100% local

Pourquoi ce projet ?

Vous en avez assez de voir vos plantes dépérir pendant vos absences, ou tout simplement d’oublier de les arroser ? Ce système d’irrigation automatique Zigbee est la réponse : il pilote 3 zones d’arrosage indépendantes selon l’humidité réelle du sol, la température ambiante, et des créneaux horaires paramétrables.

Le cœur du système est un commutateur intelligent Zigbee 4 canaux — un module capable de piloter jusqu’à 4 charges en 7-32V DC, le tout alimenté par un simple chargeur de téléphone USB-C.

💡 Pourquoi un commutateur Zigbee 4 canaux plutôt que des prises connectées ? Parce qu’il accepte une alimentation DC basse tension (7-32V) et peut être directement branché sur un chargeur USB. Pas de relais 230V, pas de prise secteur à proximité des plantes, zéro risque électrique. Chaque canal pilote une pompe DC en direct — simple, sûr, économique.

Ce que vous obtiendrez

• ✅ Arrosage automatique de 3 zones indépendantes
• ✅ Déclenchement basé sur l’humidité réelle du sol (capteurs Tuya Zigbee)
• ✅ Plage de température pour éviter d’arroser en pleine chaleur
• ✅ Mode manuel pour un arrosage ponctuel au besoin
• ✅ Supervision complète via Home Assistant (Lovelace)
• ✅ 100% local, pas de cloud
• ✅ Budget total d’environ 42€

Le matériel nécessaire

Budget total : environ 42€ chez AliExpress.

Le commutateur Zigbee 4 canaux

C’est la pièce maîtresse du projet. Ce petit module embarque un microcontrôleur Zigbee (généralement un SoC Tuya ZS3L ou équivalent EFR32MG21) et 4 relais à semi-conducteurs. Chaque sortie peut commuter jusqu’à 10A sous 7-32V DC.

Points clés :

• Alimentation DC large plage (7-32V) → compatible avec un chargeur USB 5V vers USB-C (un convertisseur boost intégré élève la tension)
• 4 canaux indépendants → chaque canal = une pompe = une zone
• Zigbee 3.0 → compatible ZHA et Zigbee2MQTT sans reflashage
• Format compact → tient dans un boîtier étanche standard

Principe de fonctionnement

Le système s’articule autour de 3 boucles de régulation indépendantes :

┌─────────────────────────────────────────────────────────────┐
│                     Home Assistant                          │
│  ┌──────────────────────────────────────────────────────┐  │
│  │              Automatisation irrigation                 │  │
│  │                                                       │  │
│  │  ┌──────────┐   ┌──────────┐   ┌──────────┐         │  │
│  │  │  Zone 1  │   │  Zone 2  │   │  Zone 3  │         │  │
│  │  │ Ficus    │   │ Thym…    │   │ Palmier  │         │  │
│  │  │          │   │          │   │          │         │  │
│  │  │ Capteur  │   │ Capteur  │   │ Capteur  │         │  │
│  │  │ humidité │   │ humidité │   │ humidité │         │  │
│  │  └────┬─────┘   └────┬─────┘   └────┬─────┘         │  │
│  │       │              │              │                │  │
│  │       ▼              ▼              ▼                │  │
│  │  Humidité < seuil ET T° ok → Pompe ON               │  │
│  └──────────────────────────────────────────────────────┘  │
│                            │                                │
│                            ▼                                │
│               Commutateur Zigbee 4 canaux                   │
│               L1 → Pompe Ficus                             │
│               L2 → Pompe Plantes arômatiques               │
│               L3 → Pompe Palmier nain                      │
└─────────────────────────────────────────────────────────────┘

Logique d’arrosage

1. Toutes les N heures (paramétrable, par défaut 1h), Home Assistant vérifie les capteurs
2. Pour chaque zone : si l’humidité du sol est inférieure au seuil configuré ET que la température est dans la plage autorisée (ni trop froid, ni trop chaud), la pompe correspondante est activée
3. La pompe tourne pendant la durée configurée (en secondes), puis s’arrête
4. Un flag irrigation_running empêche deux arrosages simultanés
5. En mode manuel, vous pouvez déclencher la séquence complète d’un simple appui sur le dashboard Lovelace

Montage du boîtier

Le boîtier étanche contient le commutateur Zigbee, le connecteur USB-C, et le câblage vers les pompes. Des presse-étoupes (ou passages de câbles étanches) assurent l’étanchéité pour une utilisation en extérieur.

Vue de côté : le connecteur USB-C est accessible depuis l’extérieur du boîtier pour l’alimentation. Les deux pompes sont connectées aux sorties L1 et L2.

L’autre face du boîtier, montrant les sorties de câbles vers les pompes.

Circuit interne

Le câblage interne est minimaliste :

• Alimentation : USB-C → bornier 7-32V du commutateur
• Pompes : chaque pompe est connectée entre une sortie (L1/L2/L3) et la masse commune
• Polarité : les pompes DC ne sont pas polarisées — le sens de rotation n’a pas d’importance pour ce type de micro-pompe centrifuge

L’intérieur du boîtier : commutateur Zigbee, connecteur USB-C soudé aux borniers d’alimentation, fils silicone vers les pompes.

Capteurs d’humidité et de température

Chaque zone est surveillée par un capteur Tuya Zigbee de température et d’humidité. Ces capteurs sont placés directement dans le sol à proximité des racines.

Un capteur de température et d’humidité Tuya Zigbee inséré dans le pot. L’humidité mesurée déclenche l’arrosage, la température peut l’inhiber si elle est hors plage.

Zones surveillées

⚠️ À savoir : les capteurs Tuya rapportent l’humidité sur une échelle de 0 à 100%. Selon le modèle, le nom de l’entité dans Home Assistant peut être soil_moisture ou humidity. À vérifier dans vos entités après appairage.

Intégration Home Assistant

Appairage Zigbee

1. Alimentez le commutateur Zigbee via l’USB-C
2. Dans Home Assistant, allez dans Paramètres → Appareils et services → Zigbee2MQTT (ou ZHA)
3. Activez le mode appairage
4. Le commutateur apparaît comme un périphérique à 4 canaux (switches L1 à L4)
5. Appairez chaque capteur Tuya de la même manière

Configuration YAML

Créez les helpers suivants dans configuration.yaml (ou via l’interface Helpers) :

input_boolean:
  irrigation_mode_auto:
    name: Mode automatique
    icon: mdi:robot
  irrigation_running:
    name: Arrosage en cours
    icon: mdi:sprinkler

input_number:
  irrigation_duration_l1:
    name: Durée arrosage zone 1 (s)
    initial: 30
    min: 5
    max: 120
    step: 5
  irrigation_duration_l2:
    name: Durée arrosage zone 2 (s)
    initial: 30
    min: 5
    max: 120
    step: 5
  irrigation_duration_l3:
    name: Durée arrosage zone 3 (s)
    initial: 30
    min: 5
    max: 120
    step: 5
  irrigation_threshold_l1:
    name: Seuil humidité zone 1 (%)
    initial: 50
    min: 10
    max: 90
    step: 5
  irrigation_threshold_l2:
    name: Seuil humidité zone 2 (%)
    initial: 45
    min: 10
    max: 90
    step: 5
  irrigation_threshold_l3:
    name: Seuil humidité zone 3 (%)
    initial: 50
    min: 10
    max: 90
    step: 5
  irrigation_temp_min:
    name: T° min arrosage (°C)
    initial: 10
    min: 0
    max: 30
    step: 1
  irrigation_temp_max:
    name: T° max arrosage (°C)
    initial: 30
    min: 15
    max: 45
    step: 1
  irrigation_check_interval:
    name: Fréquence vérification automatique (h)
    initial: 1
    min: 1
    max: 24
    step: 1

Scripts

Le projet repose sur deux scripts : un script générique de pilotage de pompe et un script séquenceur qui orchestre l’arrosage des 3 zones.

Script pompe générique

alias: Irrigation - exécuter pompe
mode: single
fields:
  pump_entity:
    description: Entité switch de la pompe à activer
    example: switch.0xa4c138a31a9aa625_l1
  duration:
    description: Durée en secondes
    example: 30
sequence:
  - target:
      entity_id: "{{ pump_entity }}"
    action: switch.turn_on
  - delay:
      seconds: "{{ duration | int }}"
  - target:
      entity_id: "{{ pump_entity }}"
    action: switch.turn_off

Script séquenceur principal

alias: Irrigation - Séquence principale
mode: single
sequence:
  - target:
      entity_id: input_boolean.irrigation_running
    action: input_boolean.turn_on
  # Zone 1 — Palmier nain
  - choose:
      - conditions:
          - condition: template
            value_template: >
              {% set moist = states('sensor.xxx_soil_moisture') | float(default=100) %}
              {% set thr = states('input_number.irrigation_threshold_l1') | float %}
              {% set temp = states('sensor.xxx_temperature') | float(default=100) %}
              {% set tmin = states('input_number.irrigation_temp_min') | float %}
              {% set tmax = states('input_number.irrigation_temp_max') | float %}
              {{ (moist < thr) and (temp >= tmin) and (temp <= tmax) }}
        sequence:
          - data:
              pump_entity: switch.0xa4c138a31a9aa625_l1
              duration: "{{ states('input_number.irrigation_duration_l1') | int }}"
            action: script.irrigation_run_pump
  # Zone 2 — Plantes arômatiques
  - choose:
      - conditions:
          - condition: template
            value_template: >
              {% set moist = states('sensor.xxx_humidity') | float(default=100) %}
              {% set thr = states('input_number.irrigation_threshold_l2') | float %}
              {% set temp = states('sensor.xxx_temperature') | float(default=100) %}
              {% set tmin = states('input_number.irrigation_temp_min') | float %}
              {% set tmax = states('input_number.irrigation_temp_max') | float %}
              {{ (moist < thr) and (temp >= tmin) and (temp <= tmax) }}
        sequence:
          - data:
              pump_entity: switch.0xa4c138a31a9aa625_l2
              duration: "{{ states('input_number.irrigation_duration_l2') | int }}"
            action: script.irrigation_run_pump
  # Zone 3 — Ficus
  - choose:
      - conditions:
          - condition: template
            value_template: >
              {% set moist = states('sensor.xxx_soil_moisture') | float(default=100) %}
              {% set thr = states('input_number.irrigation_threshold_l3') | float %}
              {% set temp = states('sensor.xxx_temperature') | float(default=100) %}
              {% set tmin = states('input_number.irrigation_temp_min') | float %}
              {% set tmax = states('input_number.irrigation_temp_max') | float %}
              {{ (moist < thr) and (temp >= tmin) and (temp <= tmax) }}
        sequence:
          - data:
              pump_entity: switch.0xa4c138a31a9aa625_l3
              duration: "{{ states('input_number.irrigation_duration_l3') | int }}"
            action: script.irrigation_run_pump
  - target:
      entity_id: input_boolean.irrigation_running
    action: input_boolean.turn_off

Automatisations

Deux automatisations complètent le système :

1. Déclenchement au changement d’humidité

alias: Irrigation auto — déclenchement seuil humidité
triggers:
  - trigger: state
    entity_id:
      - sensor.xxx_soil_moisture   # Palmier
      - sensor.xxx_humidity        # Plantes arômatiques
      - sensor.xxx_soil_moisture   # Ficus
conditions:
  - condition: state
    entity_id: input_boolean.irrigation_mode_auto
    state: "on"
  - condition: state
    entity_id: input_boolean.irrigation_running
    state: "off"
  - condition: template
    value_template: |
      {{
        states('sensor.xxx_soil_moisture')|float < states('input_number.irrigation_threshold_l1')|float
        or
        states('sensor.xxx_humidity')|float < states('input_number.irrigation_threshold_l2')|float
        or
        states('sensor.xxx_soil_moisture')|float < states('input_number.irrigation_threshold_l3')|float
      }}
actions:
  - action: script.irrigation_sequence
mode: single

💡 Cette automatisation déclenche la séquence dès qu’un capteur passe sous son seuil. Pratique pour réagir rapidement après une journée ensoleillée par exemple.

2. Relance périodique

alias: Irrigation auto — relance périodique si encore sec
description: Vérifie régulièrement l'humidité du sol et relance l'arrosage si besoin
mode: single
triggers:
  - hours: /1
    trigger: time_pattern
conditions:
  - condition: state
    entity_id: input_boolean.irrigation_mode_auto
    state: "on"
  - condition: state
    entity_id: input_boolean.irrigation_running
    state: "off"
actions:
  - variables:
      interval: "{{ states('input_number.irrigation_check_interval') | int }}"
      current_hour: "{{ now().hour | int }}"
  - condition: template
    value_template: |
      {{ (current_hour % interval) == 0 }}
  - choose:
      - conditions:
          - condition: template
            value_template: >
              {% set moist = states('sensor.xxx_soil_moisture') | float(default=100) %}
              {% set thr = states('input_number.irrigation_threshold_l1') | float %}
              {{ moist < thr }}
        sequence:
          - action: script.irrigation_sequence
      - conditions:
          - condition: template
            value_template: >
              {% set moist = states('sensor.xxx_humidity') | float(default=100) %}
              {% set thr = states('input_number.irrigation_threshold_l2') | float %}
              {{ moist < thr }}
        sequence:
          - action: script.irrigation_sequence
      - conditions:
          - condition: template
            value_template: >
              {% set moist = states('sensor.xxx_soil_moisture') | float(default=100) %}
              {% set thr = states('input_number.irrigation_threshold_l3') | float %}
              {{ moist < thr }}
        sequence:
          - action: script.irrigation_sequence

🧠 Pourquoi deux automatisations ? La première réagit immédiatement quand un capteur détecte un sol sec. La seconde agit comme un filet de sécurité : elle vérifie périodiquement (toutes les heures par défaut) qu’aucune zone n’est restée sèche — utile si un capteur n’a pas envoyé de mise à jour ou si le sol s’est asséché progressivement.

Tableau de bord Lovelace

Voici le tableau de bord complet pour superviser et contrôler votre système d’irrigation :

Structure du dashboard

views:
  - title: Arrosage
    path: arrosage
    icon: mdi:sprinkler
    type: masonry
    badges: []
    cards:
      # --- Contrôle global ---
      - type: custom:button-card
        entity: input_boolean.irrigation_mode_auto
        name: Mode Auto / Manuel
        icon: mdi:robot
        state:
          - value: 'on'
            color: green
            name: Mode automatique
            icon: mdi:robot
          - value: 'off'
            color: red
            name: Mode manuel
            icon: mdi:robot-off

      # --- Boutons d'action ---
      - type: horizontal-stack
        cards:
          - type: custom:button-card
            name: ▶️ Séquence arrosage
            icon: mdi:play
            tap_action:
              action: call-service
              service: script.irrigation_sequence
          - type: custom:button-card
            name: ⛔ Arrêt
            icon: mdi:stop
            tap_action:
              action: call-service
              service: switch.turn_off
              service_data:
                entity_id:
                  - switch.xxx_l1
                  - switch.xxx_l2
                  - switch.xxx_l3

      # --- Statut ---
      - type: entities
        entities:
          - entity: input_number.irrigation_check_interval
          - entity: input_boolean.irrigation_running

      # --- Capteurs par zone (pool-monitor-card) ---
      # Voir le YAML complet ci-dessous...

💡 Le dashboard utilise les cartes personnalisées button-card et pool-monitor-card pour une visualisation claire des seuils d’humidité avec barres de progression.

Résultat final

Une fois tout en place, vous obtenez :

• Un système d’arrosage 3 zones entièrement automatique, piloté par les capteurs d’humidité du sol
• Un mode manuel pour déclencher un arrosage ponctuel depuis le dashboard
• Une supervision complète avec jauges de température et d’humidité par plante
• Une protection température qui bloque l’arrosage s’il fait trop chaud (évaporation) ou trop froid (risque de gel)
• Un arrêt d’urgence en un clic
• Une solution 100% locale, sans cloud, sans abonnement
• Un budget total d’environ 42€ pour 3 zones

Le boîtier d’irrigation terminé, prêt à être installé près du réservoir d’eau et des plantes.

Aller plus loin

• Ajoutez un capteur de niveau d’eau dans le réservoir (ultrason ou flotteur) pour être alerté quand il faut remplir
• Gérez l’engrais liquide avec une 4ème pompe sur le canal L4 inutilisé
• Intégrez la météo : si de la pluie est prévue, différer l’arrosage (template sensor avec l’intégration Météo France ou OpenWeatherMap)
• Historique et graphiques : ajoutez une carte statistics-graph pour suivre l’évolution de l’humidité sur 7 jours
• Notifications : recevez un message Telegram/WhatsApp quand l’arrosage se déclenche ou quand le réservoir est vide

---

Un projet réalisé par un passionné de domotique — vous avez des questions ou des améliorations à proposer ? Les discussions sont ouvertes ci-dessous.