Potager 2.0 : Vision ESP32

Le jardinage connecté se limite souvent à remonter le taux d’humidité du sol via MQTT. C’est utile, mais basique. Avec l’avènement des microcontrôleurs dopés à l’IA, nous pouvons littéralement donner des “yeux” à notre potager.

L’objectif de ce projet est de déployer une caméra dans le jardin qui prendra des photos de vos tomates, analysera en local si les feuilles présentent des signes de maladie (comme le mildiou), et enverra une alerte sur votre téléphone. Tout cela en consommant si peu d’énergie qu’un petit panneau solaire suffira.

C’est ce qu’on appelle la Vision par Ordinateur (Computer Vision) en Edge AI.

Le Matériel Requis

1. L’entraînement de l’IA (Edge Impulse)

Un ESP32 ne peut pas faire tourner ChatGPT. Il faut un modèle minuscule (quelques centaines de kilo-octets) spécialisé dans une seule tâche. Le moyen le plus simple est d’utiliser la plateforme Open Source Edge Impulse [2].

  1. Collecte : Prenez 50 photos de feuilles de tomates saines et 50 photos de feuilles malades.
  2. Entraînement : Edge Impulse va créer un réseau de neurones convolutif (CNN) spécialisé dans le tri de ces deux catégories.
  3. Déploiement : Edge Impulse exporte ce modèle directement sous forme de bibliothèque C++ prête à être flashée sur l’ESP32.

2. Le Code C++ (Arduino IDE)

Une fois la bibliothèque importée dans votre IDE Arduino, voici la logique du code embarqué. Le principe est d’utiliser le Deep Sleep (sommeil profond) pour économiser la batterie, se réveiller, analyser, alerter via MQTT, et se rendormir.

#include <WiFi.h>
#include <PubSubClient.h>
#include <esp_camera.h>
#include <Mon_Modele_Tomates_inferencing.h> // La librairie générée par Edge Impulse

// Configuration WiFi et MQTT
const char* ssid = "VOTRE_WIFI";
const char* password = "VOTRE_MOT_DE_PASSE";
const char* mqtt_server = "192.168.1.10"; // Votre broker (ex: Mosquitto / Home Assistant)

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(115200);
  
  // 1. Initialisation de la caméra (Paramètres spécifiques au modèle de carte)
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = 4; // ... configurer les pins selon la datasheet
  // ...
  config.pixel_format = PIXFORMAT_RGB565;
  config.frame_size = FRAMESIZE_96X96; // L'IA a besoin de petites images
  
  esp_err_t err = esp_camera_init(&config);
  
  // 2. Capture de l'image
  camera_fb_t * fb = esp_camera_fb_get();
  if (!fb) {
    Serial.println("Erreur caméra");
    aller_dormir();
  }

  // 3. Exécution de l'inférence IA (en local sur la puce !)
  signal_t signal;
  // (Code pour convertir l'image fb->buf vers le format attendu par Edge Impulse)
  // ...
  
  ei_impulse_result_t result = { 0 };
  run_classifier(&signal, &result, false);

  // 4. Analyse du résultat et alerte MQTT
  float proba_malade = result.classification[0].value; // Index 0 = Maladie
  
  if (proba_malade > 0.80) {
    Serial.println("ALERTE : Mildiou détecté à plus de 80% !");
    connecter_wifi();
    client.publish("potager/tomates/alerte", "Mildiou possible. Vérifier les plants !");
  } else {
    Serial.println("Plantes saines. Tout va bien.");
    // Optionnel : remonter un status "OK"
  }

  // 5. Retour en sommeil profond pour préserver la batterie (Réveil dans 4 heures)
  aller_dormir();
}

void loop() {
  // Vide, car nous utilisons le Deep Sleep
}

void aller_dormir() {
  esp_camera_fb_return(fb); // Libérer la mémoire
  esp_sleep_enable_timer_wakeup(4 * 3600 * 1000000); // 4h en microsecondes
  esp_deep_sleep_start();
}

Pourquoi l’Edge AI change tout ?

Si nous avions dû envoyer la photo brute (même de mauvaise qualité) vers un serveur Cloud ou un Raspberry Pi via le Wi-Fi toutes les heures, la batterie de l’ESP32 se serait vidée en quelques jours.

En déplaçant l’intelligence à la périphérie (sur le capteur lui-même), nous n’allumons le gourmand module Wi-Fi que s’il y a un problème. Le reste du temps, l’ESP32 utilise sa puce S3 pour traiter l’image en quelques millisecondes et se rendort.

Conclusion

Le “Potager 2.0” n’est plus de la science-fiction. La combinaison de l’ESP32-S3 et d’outils comme Edge Impulse démocratise la vision par ordinateur. C’est l’essence même du mouvement Maker : reprendre le contrôle de ses données, construire des systèmes résilients fonctionnant sur panneaux solaires, et utiliser des technologies de pointe (Machine Learning embarqué) pour des problèmes très concrets du quotidien, comme sauver sa récolte de tomates !

Sources

  1. Spécifications techniques de l’ESP32-S3 - Esspresif
  2. Edge Impulse - Plateforme de Machine Learning embarqué
  3. TensorFlow Lite for Microcontrollers

Si vous voulez plus d’information sur l’infrastructure vous pouvez voir l’ repo à ce sujet : https://github.com/ravindrajob/InfraAtHome

See Also

Guide complet des Microcontrôleurs ESP
Le Détective Domotique IA
Solaire Prédictif avec IA