Défi : De Zéro à Héros de la Domotique avec un Pot de Basilic.

Soyons clairs : mes plantes et moi, on s’entend très bien. Elles poussent, je suis content, tout le monde a du pesto. J’ai la main verte comme on dit, et mon bilan botanique est largement positif.

Mais il y a un secret. Un secret qui se cache derrière chaque feuille luxuriante : la routine. L’arrosage régulier. Cette tâche aussi essentielle que … répétitive. Et soyons honnêtes, un bon jardinier peut aussi être un jardinier pragmatiquement paresseux.

J’ai donc décidé de résoudre ce léger inconvénient avec une solution complètement et glorieusement …

disproportionnée

Mon objectif : construire de A à Z un système d’arrosage 100% automatisé, intelligent et connecté. Pour un unique pot de basilic.

Le twist ? Mon expertise s’arrête là où la terre s’arrête (bon ok, pas tout à fait, je reste un geek malgré tout). Je n’ai JAMAIS touché à Home Assistant et si j’ai déjà un (modeste) bagage en Arduino, c’est ma première fois avec un ESP32 (parce que bon, wifi oblige).

Ce post est donc mon journal de bord, brut et sans filtre. C’est le carnet d’une aventure où je vais tout documenter : les choix du matériel, l’installation qui foire, le code qui refuse de fonctionner, et, je l’espère, l’immense satisfaction de voir une petite pompe s’activer toute seule.

Embarquez avec moi. Vous y trouverez mes galères de débutant en tech, mes victoires, et tout le code et les plans pour faire la même chose (en évitant mes erreurs).

La question n’est plus de savoir si le basilic survivra à mes soins, mais s’il survivra à mon code. Le combat commence ⚔️

L’aventure commence comme toutes les grandes histoires du 21ème siècle : avec un carton qui arrive de l’autre bout du monde. La théorie, c’est bien, mais il n’y a rien de tel que l’odeur du plastique antistatique pour savoir que les choses sérieuses commencent.

Chapitre 1 : Le Déballage et le Premier Contact Électrique (Mise à jour du 05/09/25)

1.1. Le Déballage Rituel : Nos deux héros entrent en scène

Sur le bureau, deux petits sachets. Dans le premier, la star du show : un microcontrôleur ESP32. C’est le cerveau de notre opération. Petit, bardé de broches, il promet de connecter notre basilic au monde numérique. Le mien vient d’AliExpress, une source inépuisable de technologies fascinantes et … de petites surprises, comme nous le verrons.

Dans le second sachet, le fidèle acolyte : le capteur d’humidité du sol (ou Soil Moisture Sensor pour les intimes). Avec sa grande « langue » destinée à plonger dans la terre, il sera nos yeux et nos mains pour « sentir » si notre plante a soif.

1.2. Le Chantier Logiciel : Préparer l’Atelier

Avant de brancher quoi que ce soit, il faut préparer notre atelier numérique. La première étape, un classique : installer l’IDE Arduino. C’est notre établi, le logiciel qui va nous permettre d’écrire le code et de le « téléverser » dans le cerveau de l’ESP32.

C’est là qu’arrive la première surprise. En branchant l’ESP32 à mon ordinateur, rien. Le silence. Mon port COM reste désespérément vide. C’est le « baptême du feu » de tout acheteur sur AliExpress : la quête des bons pilotes ! Après quelques recherches, il s’avère que ma version nécessite un driver spécifique pour que l’ordinateur daigne lui adresser la parole.

Pour vous épargner des heures de frustration, j’ai suivi à la lettre une procédure trouvée via Perplexity. Elle explique comment identifier la puce de communication de votre carte (dans mon cas, une CP2102) et où trouver le bon pilote.

GUIDE D’INSTALLATION RAPIDE DE L’ESP32

Étape 1 : Le Pilote CP2102

1. Connectez votre ESP32 à votre PC.
2. Ouvrez le Gestionnaire de périphériques (touche Windows + X).
3. Si dans « Ports (COM et LPT) » vous voyez « Silicon Labs CP210x… », c’est gagné ! Sinon, il faut l’installer manuellement.
4. Téléchargez le pilote depuis le site de Silicon Labs et installez la version correspondant à votre système (x64 pour la plupart des PC récents).

Étape 2 : Configurer l’IDE Arduino

1. Dans l’IDE, allez dans Fichier > Préférences.
2. Dans « URL du gestionnaire de cartes supplémentaires », ajoutez cette ligne :https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
3. Allez dans Outils > Type de carte > Gestionnaire de cartes.
4. Recherchez « esp32 » et installez le paquet « esp32 by Espressif Systems ».

Étape 3 : Sélectionner la carte

1. Allez dans Outils > Type de carte > esp32.
2. Choisissez « ESP32 Dev Module ». C’est le choix générique qui fonctionne quasi à tous les coups.
3. Dans Outils > Port, sélectionnez le port COM qui est apparu.

Une fois cette procédure suivie, l’IDE a enfin reconnu ma carte. Pour fêter ça, j’ai téléversé le code d’exemple Blink. La petite LED rouge intégrée à l’ESP32 (sur la broche GPIO2) qui se met à clignoter, c’est le signe officiel que notre cerveau est bien vivant !

1.3. Le Mariage des Composants : Premiers branchements

Maintenant que le logiciel est prêt, passons au matériel. J’ai sorti ma breadboard – cette plaque de prototypage qui est un peu le Lego de l’électronique. Pas de soudure, juste des branchements.

Le plan est simple, il y a trois connexions vitales à faire entre le capteur et l’ESP32 :

– L’alimentation : Le fil VCC du capteur (le +) sur la broche 3V de l’ESP32.

– La masse : Le fil GND du capteur (le -) sur une broche GND de l’ESP32.

– Les données : Le fil AOUT (sortie analogique) du capteur sur une broche capable de lire un signal analogique. J’ai choisi la GP34.

[PHOTO : Un gros plan très clair du montage sur la breadboard, montrant les fils connectés aux bonnes broches de l’ESP32 et du module du capteur.]

1.4. Le Premier Souffle Numérique : On écoute la Terre

Branchements faits. Cœur qui bat un peu plus vite. Il est temps de voir si notre montage communique. Pour gagner du temps, j’ai demandé à Perplexity de me générer un petit bout de code pour lire la valeur du capteur et l’afficher.

#include <Arduino.h>

const int SENSOR_PIN = 34;   // GPIO34 = ADC1_CH6 (input-only)
int DRY_mV = 3000;           // placeholder: measure in-air dry and set here
int WET_mV = 1500;           // placeholder: measure fully wet/saturated and set here

void setup() {
  Serial.begin(115200);
  analogSetAttenuation(ADC_11db); // extend range toward ~3.3V
  pinMode(SENSOR_PIN, INPUT);
}

int readSensorMilliVolts() {
  const int N = 15;
  int v[N];
  for (int i = 0; i < N; i++) {
    v[i] = analogReadMilliVolts(SENSOR_PIN);
    delay(5);
  }
  // median
  for (int i = 0; i < N - 1; i++) {
    for (int j = i + 1; j < N; j++) {
      if (v[j] < v[i]) { int t = v[i]; v[i] = v[j]; v[j] = t; }
    }
  }
  return v[N / 2];
}

void loop() {
  int mv = readSensorMilliVolts();
  int pct = map(mv, DRY_mV, WET_mV, 0, 100);  // higher mV(dry) → lower %
  pct = constrain(pct, 0, 100);
  Serial.print("Soil: "); Serial.print(pct); Serial.print("%  (");
  Serial.print(mv); Serial.println(" mV)");
  delay(1000);
}

Je copie, je colle, je téléverse … Le code est envoyé avec succès. J’ouvre l’outil « Moniteur Série » dans l’IDE Arduino et … des chiffres apparaissent ! Ça fonctionne !

1.5. L’Art du Réglage Fin : La Calibration

Ces chiffres, c’est bien, mais ils ne veulent rien dire. Il faut leur donner un sens. C’est l’étape de la calibration. L’idée est de dire au programme : « cette valeur, c’est 0% d’humidité, et cette autre valeur, c’est 100% ».

Pour cela, j’ai d’abord laissé le capteur à l’air libre pour avoir la valeur « complètement sec ». Puis, je l’ai plongé dans un verre d’eau pour avoir la valeur « complètement trempé ».

J’ai ensuite modifié deux constantes dans le code pour intégrer ces valeurs. Après un nouveau téléversement, le résultat était parfait. Quand je sors le capteur de l’eau, le moniteur affiche progressivement des valeurs proches de 0%. Quand je le plonge, il atteint 100%.

Victoire ! En une session, nous sommes passés d’une boîte de composants à un capteur fonctionnel, précis et calibré. Le premier pas est franchi. Maintenant que l’on sait lire l’humidité du sol, la prochaine étape sera d’agir en conséquence. Le basilic n’a qu’à bien se tenir.