Aller au contenu

Agriculture de précision

De Wiki Alseno
Version datée du 20 novembre 2026 à 19:42 par Robot-agri (discussion | contributions) (Alseno Tech : accueil et portail Agritech)
(diff) ← Version précédente | Version actuelle (diff) | Version suivante → (diff)

Agriculture de précision

L'agriculture de précision consiste à donner à chaque parcelle, voire à chaque plante, ce dont elle a besoin au bon moment, plutôt que de traiter tout le champ de la même façon. Pour l'eau, cela veut dire arroser quand le sol le demande, pas quand le calendrier le dit.

Le cycle : mesurer, décider, agir

  1. Mesurer : des capteurs relèvent l'état du sol, de l'air et de l'eau.
  2. Décider : un logiciel compare les mesures à des seuils ou à un modèle et propose une action.
  3. Agir : on arrose (à la main au début, par une vanne commandée ensuite).

Le cycle se referme : l'arrosage change l'humidité, que l'on mesure à nouveau.

Ce qu'on mesure

Grandeur Capteur typique Pourquoi
Humidité du sol sonde capacitive savoir si la plante a soif ; première mesure à installer
Température du sol et de l'air AHT10, SHT31, PT1000 vitesse d'assèchement, distinguer pluie et arrosage
Météo (pluie, vent, lumière) mini station météo, pluviomètre ne pas arroser avant une pluie ; évaporation
Niveau d'eau (cuve, forage) capteur de pression ou ultrason éviter de pomper à sec
Débit et pression de la conduite compteur à impulsions, capteur de pression contrôler ce qui est réellement arrosé, repérer les fuites

Les modèles de capteurs LoRaWAN prêts à l'emploi sont listés dans Matériel et coûts.

Décider : trois étapes

Nous avançons par paliers, chacun utilisable seul.

v1 — conseil par règles
Un seuil et une tendance (voir l'exemple e du Kit de démarrage) : « sol sous 30 % → arroser ; sol en hausse → attendre ». Simple, lisible, suffisant pour commencer. Le conseil est calculé sur un serveur et affiché ; c'est l'humain qui arrose.
v2 — modèle appris
Après une saison complète de mesures, on ajuste les seuils par plante et par sol, voire on entraîne un modèle qui prédit l'assèchement. Il faut des données propres : d'où l'importance de conserver la trame brute (voir Chaîne de données).
v3 — vannes commandées
Le logiciel ouvre lui-même une vanne (électrovanne ou relais LoRaWAN de classe C), avec des protections : durée maximale, arrêt si pas de nouvelle mesure, validation humaine au début.

Un exemple de lecture : pluie ou arrosage ?

Dans notre jardin d'essai, la valeur brute de la sonde chute quand le sol se mouille. Une règle de deux conditions sépare les deux causes :

  • la valeur brute chute vite et la température chute aussi → pluie (de l'air plus frais arrive avec l'eau) ;
  • la valeur brute chute vite sans chute de température → arrosage (l'eau du robinet est à température ambiante).

Mesure du 24 août 2026 : valeur brute de 613 à 559 en 11 minutes, température de 30,3 à 26,3 °C : une averse.

Piège de la tendance. Un détecteur de tendance ne voit que le front de la chute. Quand le sol est gorgé, la valeur reste basse mais stable : la pente est nulle et le détecteur conclut à tort que la pluie est finie. Il faut séparer lévénement (la chute, pour notifier) de létat (valeur sous un seuil absolu, pour savoir que le sol est mouillé).

Exemple de code : règle d'arrosage

Un point de départ pour le conseil v1 (voir aussi le Kit de démarrage).

#!/usr/bin/env python3
"""Conseil d'arrosage v1 : un seuil et une tendance. Point de départ d'un modèle plus fin.

Exemple de démarrage (Alseno Tech, licence MIT). Aucune dépendance.

Idée : on n'arrose pas seulement parce que le sol est sec, on regarde aussi
  - s'il vient d'être mouillé (pluie, arrosage) : la tendance est à la hausse -> on attend ;
  - s'il s'assèche vite : on prévient plus tôt.
Les seuils dépendent de la plante et du sol : ce sont des valeurs de départ à ajuster.
"""
from datetime import datetime, timedelta

SEUIL_ARROSER = 30.0      # % d'humidité en dessous duquel on conseille d'arroser
SEUIL_ATTENTION = 40.0    # en dessous, on surveille de près
HAUSSE_PLUIE = 5.0        # hausse (points de %) en 2 h qui signale un arrosage ou une pluie récente
FENETRE_H = 3             # durée sur laquelle on mesure la tendance


def pente_par_heure(releves, maintenant):
    """Pente moyenne (points de % par heure) sur FENETRE_H heures, par régression linéaire simple.

    releves : liste de (datetime, pourcentage). Renvoie None s'il y a trop peu de points."""
    debut = maintenant - timedelta(hours=FENETRE_H)
    pts = [((t - debut).total_seconds() / 3600.0, v) for t, v in releves if t >= debut]
    if len(pts) < 4:
        return None
    n = len(pts)
    mx = sum(x for x, _ in pts) / n
    my = sum(y for _, y in pts) / n
    var = sum((x - mx) ** 2 for x, _ in pts)
    if var == 0:
        return None
    return sum((x - mx) * (y - my) for x, y in pts) / var


def conseil(releves, maintenant=None):
    """Renvoie (action, raison) avec action dans 'arroser', 'surveiller', 'attendre', 'donnees_insuffisantes'."""
    maintenant = maintenant or datetime.now()
    if not releves:
        return "donnees_insuffisantes", "aucune mesure"
    releves = sorted(releves)
    dernier_t, dernier = releves[-1]
    if maintenant - dernier_t > timedelta(hours=2):
        return "donnees_insuffisantes", "derniere mesure trop ancienne (capteur muet ?)"

    pente = pente_par_heure(releves, maintenant)
    deux_h = [v for t, v in releves if t >= maintenant - timedelta(hours=2)]
    if deux_h and dernier - min(deux_h) >= HAUSSE_PLUIE:
        return "attendre", "humidite en hausse : pluie ou arrosage recent"

    if dernier < SEUIL_ARROSER:
        return "arroser", "sol sec (%.0f %% < %.0f %%)" % (dernier, SEUIL_ARROSER)
    if dernier < SEUIL_ATTENTION and pente is not None and pente < -1.0:
        return "arroser", "sol en train de secher vite (%.1f points/h)" % pente
    if dernier < SEUIL_ATTENTION:
        return "surveiller", "sol assez sec (%.0f %%)" % dernier
    return "attendre", "humidite suffisante (%.0f %%)" % dernier


if __name__ == "__main__":
    # Démonstration avec des mesures fictives : le sol sèche de 45 % à 32 % en 3 heures.
    maintenant = datetime(2026, 1, 1, 12, 0)
    exemple = [(maintenant - timedelta(minutes=15 * k), 32 + 13 * (k / 12.0)) for k in range(13)]
    print(conseil(exemple, maintenant))

Pour aller plus loin