Arrosage automatique ESP32 : système Wi-Fi et capteur d'humidité
Arrosage automatique ESP32 : capteur d'humidité capacitif, relais et mini-pompe, seuil et durée via une page web, étalonnage, deep sleep, protection à sec.
Un système d'arrosage automatique avec ESP32 associe un capteur qui mesure l'humidité du terreau d'un pot à une petite pompe à eau, pour que ta plante soit arrosée au bon moment même quand tu n'es pas là. Quand la terre descend sous le niveau d'humidité que tu as fixé, l'ESP32 fait tourner la pompe quelques secondes via un relais, attend que l'eau pénètre et mesure à nouveau. Grâce au Wi-Fi, tu suis l'humidité depuis ton téléphone et tu modifies le seuil et la durée d'arrosage dans une page web.
Dans ce guide, on avance pas à pas : de l'étalonnage du capteur d'humidité capacitif à un programme d'arrosage complet avec page web, puis à une version sur batterie avec deep sleep pour les balcons sans prise. On verra aussi comment choisir le seuil selon le type de plante, calculer la durée de pompage à partir du débit et, surtout, empêcher la pompe de tourner à sec quand le réservoir est vide.

Comment fonctionne un arrosage automatique ESP32 ?
Le système tourne en boucle de façon simple. Toutes les 10 secondes, l'ESP32 prend 16 mesures du capteur, en fait la moyenne et la convertit en humidité comprise entre 0 % (complètement sec) et 100 % (dans l'eau). Si l'humidité est sous ton seuil, qu'il y a de l'eau dans le réservoir et que le dernier arrosage date d'assez longtemps, il fait tourner la pompe pendant la durée choisie. Ensuite, un temps d'attente commence pour laisser l'eau se répartir dans la terre ; aucun nouvel arrosage n'a lieu avant la fin. Tous ces réglages se modifient depuis la page web et sont enregistrés dans la mémoire flash de l'ESP32.
| Composant | Rôle | Remarque |
|---|---|---|
| ESP32 DevKit | Mesure, décision et page web | Wi-Fi 2,4 GHz uniquement |
| Capteur d'humidité du sol capacitif v1.2 | Convertit l'humidité de la terre en tension analogique | Ne s'oxyde pas ; fonctionne de 3,3 à 5,5 V |
| Module relais 1 voie | Allume et éteint la pompe | Choisis un modèle qui se déclenche en 3,3 V |
| Mini-pompe immergée 3–6 V et tuyau | Envoie l'eau du réservoir vers le pot | Environ 100 à 200 mA |
| Capteur de niveau à flotteur | Signale que le réservoir est vide | Protège la pompe du fonctionnement à sec |
| Alimentation 5 V 2 A | Alimente l'ESP32, le relais et la pompe | Toutes les masses reliées |
| Diode 1N4007 ou 1N5819 | Absorbe la surtension à l'arrêt de la pompe | Cathode sur le + de la pompe |
Capacitif ou résistif ? Bien choisir son capteur d'humidité du sol
Les capteurs résistifs bon marché (deux pointes métalliques en forme de fourche) mesurent en faisant passer un courant directement dans la terre. Ce courant provoque une électrolyse sur les pointes : en quelques semaines le métal se corrode, les mesures dérivent et des ions métalliques se retrouvent dans la terre. Dans un capteur capacitif, les électrodes sont sous un revêtement isolant et n'ont aucun contact électrique avec la terre ; le capteur mesure comment l'eau du sol modifie sa capacité. Il peut donc rester enfoui des mois, voire des années. Pour un arrosage qui tourne en permanence, le capteur capacitif est quasiment indispensable. Tu trouveras une comparaison détaillée des deux dans Capteur d'humidité du sol.
Câblage : ESP32, capteur, relais et pompe
| Liaison | Broche ESP32 | Remarque |
|---|---|---|
| AOUT du capteur | GPIO 34 | Voie ADC1 ; lisible avec le Wi-Fi actif |
| VCC du capteur | 3V3 (GPIO 25 dans la version batterie) | Sur batterie, alimenté seulement pendant la mesure |
| GND du capteur | GND | Masse commune |
| IN du relais | GPIO 26 | La plupart des modules s'activent à LOW |
| VCC / GND du relais | VIN (5 V) / GND | La bobine du relais a besoin de 5 V |
| Flotteur | GPIO 27 et GND | INPUT_PULLUP ; contact fermé tant qu'il y a de l'eau |
| Pompe | 5 V, via COM–NO du relais | Le courant de la pompe ne traverse pas l'ESP32 |
À l'arrêt, le moteur de la pompe produit une surtension inverse capable de réinitialiser l'ESP32 : branche donc une diode en inverse aux bornes de la pompe (cathode sur le +) et ajoute un condensateur de 100 à 470 µF près de l'entrée 5 V de l'ESP32. Les masses du module relais, de la pompe et de l'ESP32 doivent être reliées. Place le réservoir plus bas que le pot et fais sortir le tuyau au-dessus du niveau d'eau du réservoir ; sinon l'eau continue de couler par effet siphon même après l'arrêt de la pompe, et le pot déborde. On explique en détail comment piloter la pompe dans Pompe à eau avec Arduino.
Étape 1 : étalonner le capteur (valeur sèche et mouillée)
Chaque capteur capacitif, chaque longueur de câble et chaque tension d'alimentation donnent des valeurs un peu différentes : il faut donc régler le code sur les deux valeurs extrêmes de ton propre capteur. Téléverse le code ci-dessous et ouvre le moniteur série à 115200 bauds. Tiens d'abord le capteur en l'air et note la valeur : c'est RAW_DRY, soit 0 %. Plonge-le ensuite dans un verre d'eau jusqu'au trait imprimé et note la nouvelle valeur : c'est RAW_WET, soit 100 %. Avec un capteur capacitif, la valeur diminue quand l'humidité augmente ; le pourcentage se calcule avec humidité % = (RAW_DRY − brut) × 100 / (RAW_DRY − RAW_WET).
1// Kalibrasyon: sensörü önce havada, sonra bardak suda tut / calibration: hold the sensor in air, then in a glass of water
2const int SOIL_PIN = 34; // sensör AOUT, ADC1 kanalı / sensor AOUT, an ADC1 channel
3
4void setup() {
5 Serial.begin(115200);
6}
7
8void loop() {
9 long sum = 0;
10 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 readings
11 sum += analogRead(SOIL_PIN);
12 delay(5);
13 }
14 Serial.print("Ham deger / raw value: ");
15 Serial.println(sum / 16); // havada → RAW_DRY, suda → RAW_WET / in air → RAW_DRY, in water → RAW_WET
16 delay(1000);
17}| État | Valeur brute (exemple) | Humidité (%) |
|---|---|---|
| En l'air (complètement sec) | ≈ 3000 | 0 (RAW_DRY) |
| Terre sèche | ≈ 2500–2700 | 17–29 |
| Terre humide (idéale pour la plupart des plantes) | ≈ 1800–2200 | 46–69 |
| Terre fraîchement arrosée | ≈ 1500–1700 | 74–86 |
| Dans un verre d'eau | ≈ 1250 | 100 (RAW_WET) |
Choisir le seuil d'arrosage selon ta plante
| Type de plante | Seuil d'arrosage | Remarque |
|---|---|---|
| Cactus et plantes grasses | 15–25 % | Laisser la terre sécher presque complètement |
| Plantes d'intérieur (pothos, monstera, ficus) | 30–40 % | Quand les 2–3 cm du dessus sont secs |
| Légumes et semis (tomates, basilic, poivrons) | 45–60 % | Garder la terre toujours légèrement humide |
| Fougères et plantes aimant l'humidité | 55–70 % | Ne jamais laisser sécher complètement |
Deux réglages comptent autant que le seuil : la durée de pompage et le temps d'attente. Une mini-pompe annoncée à 100 L/h débite en théorie environ 28 ml par seconde, mais avec un tuyau fin et quelques dizaines de centimètres de hauteur, on obtient plutôt 15 à 20 ml par seconde en pratique. Le mieux est de faire tourner la pompe 10 secondes dans un verre doseur et de mesurer le vrai débit. Pour un pot de 15 cm, 80 à 150 ml par arrosage suffisent en général, soit 5 à 8 secondes. Le temps d'attente laisse l'eau se répartir dans la terre et atteindre le capteur : sans lui, le capteur n'est pas encore mouillé, le système relance la pompe encore et encore et noie le pot. 30 minutes, c'est un bon point de départ.
Étape 2 : code d'arrosage ESP32 avec page web
Le programme principal gère l'arrosage automatique et sert en plus une petite page que tu ouvres sur ton téléphone. Elle actualise toutes les 3 secondes l'humidité, l'état de la pompe et du réservoir et le temps écoulé depuis le dernier arrosage. Le formulaire permet de changer le seuil, la durée de pompage et le temps d'attente, et le bouton « Water now » lance un arrosage manuel. Les réglages sont écrits en flash avec la bibliothèque Preferences : ils résistent à une coupure de courant. Même si le Wi-Fi ne se connecte pas, le code continue au bout de 20 secondes et l'arrosage automatique fonctionne quand même. N'oublie pas de reporter les deux valeurs d'étalonnage dans les lignes RAW_DRY et RAW_WET :
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7
8const int SOIL_PIN = 34; // sensör AOUT (ADC1) / sensor AOUT (ADC1)
9const int RELAY_PIN = 26; // röle IN / relay IN
10const int FLOAT_PIN = 27; // şamandıra, diğer ucu GND / float switch, other leg to GND
11const bool RELAY_ACTIVE_LOW = true; // çoğu röle modülü LOW'da çeker / most relay modules switch on LOW
12const int RAW_DRY = 3000; // havadaki değer (%0) / reading in air (0%)
13const int RAW_WET = 1250; // sudaki değer (%100) / reading in water (100%)
14
15WebServer server(80);
16Preferences prefs;
17
18int threshold = 35; // bu nemin altında sula (%) / water below this moisture (%)
19int durationS = 5; // pompa süresi (sn) / pump run time (s)
20int soakMin = 30; // iki sulama arası bekleme (dk) / soak time between waterings (min)
21
22int moisture = 0; // son nem (%) / last moisture (%)
23bool pumpOn = false, tankLow = false, everWatered = false;
24unsigned long pumpStart = 0, lastWater = 0, lastCheck = 0;
25
26const char PAGE[] PROGMEM = R"HTML(<!DOCTYPE html><html><head><meta charset="utf-8">
27<meta name="viewport" content="width=device-width,initial-scale=1"><title>ESP32 Sulama</title>
28<style>body{font-family:sans-serif;margin:16px;max-width:420px}input{width:70px}button{padding:8px 14px;margin-top:8px}</style></head>
29<body><h2>ESP32 Sulama / Watering</h2>
30<p>Nem / Moisture: <b id="m">--</b> %</p>
31<p>Pompa / Pump: <b id="p">--</b> · Depo / Tank: <b id="k">--</b></p>
32<p>Son sulama / Last watering: <b id="l">--</b></p>
33<form action="/save" method="POST">
34<p>Esik / Threshold (%): <input name="th" type="number" min="5" max="90" value="%TH%"></p>
35<p>Sure / Duration (s): <input name="du" type="number" min="1" max="60" value="%DU%"></p>
36<p>Bekleme / Soak (min): <input name="so" type="number" min="1" max="720" value="%SO%"></p>
37<button>Kaydet / Save</button></form>
38<form action="/water" method="POST"><button>Simdi sula / Water now</button></form>
39<script>
40function upd() {
41 fetch('/data').then(r => r.json()).then(d => {
42 document.getElementById('m').textContent = d.m;
43 document.getElementById('p').textContent = d.p ? 'ON' : 'OFF';
44 document.getElementById('k').textContent = d.k ? 'BOS / EMPTY' : 'OK';
45 document.getElementById('l').textContent = d.l < 0 ? '--' : Math.round(d.l / 60) + ' dk / min';
46 });
47}
48upd(); setInterval(upd, 3000);
49</script></body></html>)HTML";
50
51void setPump(bool on) {
52 pumpOn = on;
53 digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
54}
55
56bool waterAvailable() { // şamandıra yukarıda: kontak kapalı, LOW / float up: contact closed, LOW
57 return digitalRead(FLOAT_PIN) == LOW;
58}
59
60int readMoisture() {
61 long sum = 0;
62 for (int i = 0; i < 16; i++) { sum += analogRead(SOIL_PIN); delay(5); }
63 int pct = map(sum / 16, RAW_DRY, RAW_WET, 0, 100); // kuru → 0, ıslak → 100 / dry → 0, wet → 100
64 return constrain(pct, 0, 100);
65}
66
67void startWatering() {
68 if (pumpOn || !waterAvailable()) return; // su yoksa pompayı asla çalıştırma / never run the pump dry
69 setPump(true);
70 pumpStart = lastWater = millis();
71 everWatered = true;
72}
73
74void handleRoot() {
75 String page = PAGE;
76 page.replace("%TH%", String(threshold));
77 page.replace("%DU%", String(durationS));
78 page.replace("%SO%", String(soakMin));
79 server.send(200, "text/html", page);
80}
81
82void handleData() {
83 long ago = everWatered ? (long)((millis() - lastWater) / 1000) : -1;
84 server.send(200, "application/json", "{\"m\":" + String(moisture) + ",\"p\":" + String(pumpOn ? 1 : 0) +
85 ",\"k\":" + String(tankLow ? 1 : 0) + ",\"l\":" + String(ago) + "}");
86}
87
88void handleSave() {
89 threshold = constrain(server.arg("th").toInt(), 5, 90);
90 durationS = constrain(server.arg("du").toInt(), 1, 60);
91 soakMin = constrain(server.arg("so").toInt(), 1, 720);
92 prefs.putInt("th", threshold); // flaşa kaydet, elektrik kesilse de kalır / saved to flash, survives power cuts
93 prefs.putInt("du", durationS);
94 prefs.putInt("so", soakMin);
95 server.sendHeader("Location", "/");
96 server.send(303);
97}
98
99void handleWater() {
100 startWatering(); // elle sulama / manual watering
101 server.sendHeader("Location", "/");
102 server.send(303);
103}
104
105void setup() {
106 Serial.begin(115200);
107 pinMode(RELAY_PIN, OUTPUT);
108 setPump(false); // açılışta pompa kapalı / pump off at boot
109 pinMode(FLOAT_PIN, INPUT_PULLUP);
110 prefs.begin("sulama", false);
111 threshold = prefs.getInt("th", threshold);
112 durationS = prefs.getInt("du", durationS);
113 soakMin = prefs.getInt("so", soakMin);
114
115 WiFi.mode(WIFI_STA);
116 WiFi.begin(ssid, password);
117 for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) delay(500); // en fazla 20 sn bekle / wait 20 s at most
118 Serial.print("IP: ");
119 Serial.println(WiFi.localIP()); // Wi-Fi yoksa da sulama çalışır / watering works even without Wi-Fi
120
121 server.on("/", handleRoot);
122 server.on("/data", handleData);
123 server.on("/save", HTTP_POST, handleSave);
124 server.on("/water", HTTP_POST, handleWater);
125 server.begin();
126}
127
128void loop() {
129 server.handleClient();
130 unsigned long now = millis();
131 if (pumpOn) {
132 tankLow = !waterAvailable();
133 if (now - pumpStart >= (unsigned long)durationS * 1000UL || tankLow) setPump(false); // süre ya da su bitti / time or water ran out
134 }
135 if (now - lastCheck >= 10000) { // 10 sn'de bir kontrol / check every 10 s
136 lastCheck = now;
137 moisture = readMoisture();
138 tankLow = !waterAvailable();
139 bool soaked = !everWatered || now - lastWater >= (unsigned long)soakMin * 60000UL;
140 if (!pumpOn && !tankLow && moisture < threshold && soaked) startWatering();
141 Serial.printf("Nem / Moisture: %d %% Depo / Tank: %s\n", moisture, tankLow ? "BOS / EMPTY" : "OK");
142 }
143}| Partie du code | Rôle |
|---|---|
| RAW_DRY / RAW_WET | Les deux valeurs extrêmes trouvées à l'étalonnage |
| map() + constrain() | Convertit la valeur brute en 0–100 % et l'empêche de sortir de la plage |
| Preferences | Enregistre en flash le seuil, la durée de pompage et le temps d'attente |
| soakMin | Attend entre deux arrosages que l'eau se répartisse dans la terre |
| waterAvailable() | Si le flotteur signale un réservoir vide, la pompe ne démarre pas ou s'arrête aussitôt |
| /save et /water | Enregistrent les réglages du formulaire et lancent un arrosage manuel |
Après le téléversement, ouvre l'adresse IP affichée dans le moniteur série sur un téléphone connecté au même Wi-Fi. Selon le sens de montage du flotteur, son contact peut être ouvert quand il y a de l'eau ; si la page affiche toujours le réservoir comme « EMPTY », remplace LOW par HIGH dans waterAvailable(). La page n'a pas de mot de passe : utilise-la seulement sur ton réseau domestique ; si tu veux une adresse facile à retenir à la place de l'IP et une interface plus vivante, ajoute les méthodes de Serveur web asynchrone ESP32 et WebSocket.
Protéger la pompe quand l'eau vient à manquer
Les mini-pompes immergées sont refroidies et lubrifiées par l'eau qui les traverse. À sec, elles chauffent en quelques minutes et usent leurs joints et leur turbine ; une pompe qui tourne dans un réservoir vide pendant des vacances entières est le plus souvent hors d'usage. Un bon système d'arrosage protège donc la pompe à plusieurs niveaux :
- Flotteur : Quand l'eau du réservoir descend sous un certain niveau, le contact s'ouvre et le code ne démarre jamais la pompe ; si l'eau manque en plein arrosage, il l'arrête immédiatement. Les détails du câblage sont dans Capteur à flotteur.
- Limite de durée : La pompe ne tourne jamais plus longtemps que la durée réglée (60 s au maximum) ; le logiciel la coupe dans tous les cas.
- Temps d'attente : Au moins soakMin minutes séparent deux arrosages, si bien qu'un capteur défectueux ne peut pas forcer le système à arroser sans arrêt.
- Contrôle de la hausse d'humidité : Si tu veux, tiens un compteur d'erreurs quand l'humidité n'a pas augmenté après un arrosage ; après trois échecs, coupe l'arrosage automatique et envoie une alerte avec un bot Telegram. Utile si le tuyau s'est décroché ou si le capteur est sorti de la terre.
- Capteur de niveau sans contact : À la place d'un flotteur, un XKC-Y25 mesure à travers la paroi du réservoir, sans rien plonger dans l'eau.
Arrosage sur batterie avec le deep sleep
Pour faire tourner le système sur batterie sur un balcon ou dans un jardin sans prise, tu places l'ESP32 en deep sleep entre deux mesures. La version ci-dessous se passe de la page web, car garder le Wi-Fi allumé viderait la batterie en quelques jours. La carte se réveille toutes les 30 minutes, alimente le capteur par le GPIO 25 uniquement pendant la mesure, fait tourner la pompe si nécessaire et se rendort. Les compteurs de réveils et d'arrosages sont stockés en mémoire RTC grâce à RTC_DATA_ATTR et survivent ainsi au sommeil. Dans la version batterie, la bobine d'un relais 5 V consomme beaucoup et peut ne pas coller à basse tension : mieux vaut piloter la pompe avec un MOSFET à niveau logique, détails dans Utiliser un MOSFET avec Arduino.
1// Pilli sürüm: 30 dk'da bir uyan, ölç, gerekirse sula, uyu / battery version: wake every 30 min, measure, water if needed, sleep
2const int SOIL_PIN = 34; // sensör AOUT / sensor AOUT
3const int SENSOR_PWR = 25; // sensör VCC bu pinden / sensor VCC from this pin
4const int PUMP_PIN = 26; // röle IN ya da MOSFET gate / relay IN or MOSFET gate
5const int FLOAT_PIN = 27; // şamandıra / float switch
6const bool PUMP_ACTIVE_LOW = true; // MOSFET kullanıyorsan false / false if you use a MOSFET
7const int RAW_DRY = 3000, RAW_WET = 1250;
8const int THRESHOLD = 35; // %
9const int DURATION_S = 5; // sn / s
10const uint64_t SLEEP_US = 30ULL * 60 * 1000000; // 30 dakika / 30 minutes
11
12RTC_DATA_ATTR int wakeCount = 0; // deep sleep'te silinmez / survives deep sleep
13RTC_DATA_ATTR int waterCount = 0;
14
15void pump(bool on) {
16 digitalWrite(PUMP_PIN, (on != PUMP_ACTIVE_LOW) ? HIGH : LOW);
17}
18
19void setup() {
20 Serial.begin(115200);
21 wakeCount++;
22 pinMode(PUMP_PIN, OUTPUT);
23 pump(false);
24 pinMode(FLOAT_PIN, INPUT_PULLUP);
25 pinMode(SENSOR_PWR, OUTPUT);
26 digitalWrite(SENSOR_PWR, HIGH); // sensörü yalnız ölçerken aç / power the sensor only while measuring
27 delay(200); // çıkışın oturmasını bekle / let the output settle
28 long sum = 0;
29 for (int i = 0; i < 16; i++) { sum += analogRead(SOIL_PIN); delay(5); }
30 digitalWrite(SENSOR_PWR, LOW);
31 int pct = constrain(map(sum / 16, RAW_DRY, RAW_WET, 0, 100), 0, 100);
32 bool water = digitalRead(FLOAT_PIN) == LOW;
33 Serial.printf("Uyanma / Wake %d: nem / moisture %d %%, depo / tank %s, sulama / waterings %d\n",
34 wakeCount, pct, water ? "OK" : "BOS / EMPTY", waterCount);
35
36 if (pct < THRESHOLD && water) {
37 pump(true);
38 unsigned long start = millis();
39 while (millis() - start < DURATION_S * 1000UL && digitalRead(FLOAT_PIN) == LOW) delay(10); // su biterse hemen dur / stop at once if the tank empties
40 pump(false);
41 waterCount++;
42 }
43 esp_sleep_enable_timer_wakeup(SLEEP_US);
44 esp_deep_sleep_start(); // uyanınca setup() baştan başlar / wakes up into setup()
45}
46
47void loop() {
48}C'est surtout le courant de veille de la carte qui décide de l'autonomie. Un ESP32 DevKit ordinaire peut consommer 5 à 10 mA en veille à cause de son régulateur et de sa puce USB-série : à 10 mA, une batterie de 3000 mAh ne tient que 300 heures, environ 12 jours. Avec une carte basse consommation qui dort à 0,15 mA, tout change : 48 réveils par jour (0,5 seconde chacun à 50 mA), 0,15 mA de veille et un pompage quotidien de 5 secondes font environ 4,3 mAh au total ; la même batterie tiendrait en théorie près de deux ans, même si en pratique l'autodécharge limite cela à quelques mois. Fais le calcul avec tes valeurs grâce à l'outil Autonomie de la batterie, et découvre comment réduire le courant de veille dans ESP32 Deep Sleep.
Idées de projets et améliorations
- Plusieurs pots : Donne à chaque pot son propre capteur et sa pompe ; les broches ADC1 de l'ESP32 suffisent pour six pots.
- Notifications : Envoie un message sur ton téléphone avec Telegram quand le réservoir est vide ou que la terre reste trop sèche.
- Journal d'humidité : Enregistre les mesures dans Google Sheets et vois sur un graphique à quelle fréquence ta plante a besoin d'eau.
- Arrosage solaire : Recharge la batterie le jour avec un petit panneau solaire et un TP4056.
- Contrôle de la pluie : En extérieur, ajoute un capteur de pluie et saute l'arrosage quand il pleut.
- Serre connectée : Ajoute température, humidité de l'air et ventilateur pour en faire un projet de serre connectée.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| L'humidité reste à 0 % ou ne bouge pas | Capteur sur une broche ADC2 avec le Wi-Fi actif | Déplace le capteur sur l'une des GPIO 32–39 |
| Les mesures sautent sans arrêt | Parasites ou capteur mal enfoncé | Fais la moyenne de 16 mesures et enfonce bien le capteur |
| L'ESP32 redémarre quand la pompe démarre | Chute de tension, pas de diode | Ajoute la diode et un condensateur de 470 µF, prends une alimentation 2 A |
| Le relais ne retombe jamais | Un relais 5 V ne reconnaît pas le HIGH à 3,3 V | Prends un relais compatible 3,3 V ou un MOSFET, vérifie RELAY_ACTIVE_LOW |
| Le pot déborde | Temps d'attente trop court ou effet siphon | Augmente soakMin, fais sortir le tuyau au-dessus du niveau du réservoir |
| La pompe tourne mais l'eau ne sort pas | Air dans la pompe ou réservoir vide | Immerge complètement la pompe, vérifie le flotteur |
| Les réglages disparaissent après une coupure | Les valeurs ne sont pas enregistrées en flash | Vérifie que les lignes prefs.putInt() s'exécutent |
Parce qu'il réunit mesure, prise de décision, sécurité et contrôle à distance dans un seul projet, cet arrosage automatique ESP32 est aussi une excellente première marche vers la domotique. Si tu veux voir un circuit d'arrosage pas à pas, le projet Station d'irrigation intelligente de l'application BlueGrays propose le schéma de câblage et le code prêt à téléverser pour une version Arduino.
Questions fréquentes
Comment faire un arrosage automatique avec un ESP32 ?
Branche un capteur d'humidité du sol capacitif sur une broche ADC1 de l'ESP32 et un module relais sur une broche numérique, puis alimente la mini-pompe à travers le relais avec une alimentation 5 V séparée. Étalonne le capteur en l'air et dans l'eau et fixe un seuil d'humidité dans le code ; quand l'humidité passe en dessous, la pompe tourne quelques secondes et le système attend que l'eau pénètre.
Sur quelle broche de l'ESP32 brancher le capteur d'humidité du sol ?
Branche la sortie analogique sur l'une des broches ADC1, entre GPIO 32 et 39 ; ce guide utilise la GPIO 34. Les broches ADC2 ne sont pas lisibles avec analogRead() quand le Wi-Fi est actif : dans un projet Wi-Fi, le capteur va donc toujours sur ADC1.
À quel pourcentage d'humidité faut-il arroser ?
Tout dépend de la plante : 15–25 % pour les cactus et plantes grasses, 30–40 % pour la plupart des plantes d'intérieur et 45–60 % pour des légumes comme les tomates ou le basilic sont de bons points de départ. Comme les pourcentages dépendent de l'étalonnage du capteur, observe la plante quelques jours puis ajuste le seuil.
Faut-il piloter la pompe avec un relais ou un MOSFET ?
Pour un montage branché sur secteur, un module relais qui se déclenche en 3,3 V est pratique et sûr. Sur batterie, ou si tu veux régler la vitesse de la pompe en PWM, un MOSFET à niveau logique consomme moins et reste silencieux ; dans les deux cas, ajoute une diode en inverse sur la pompe.
Une mini-pompe s'abîme-t-elle si elle tourne à sec ?
Oui. Les mini-pompes immergées sont refroidies et lubrifiées par l'eau qui les traverse ; à sec, elles chauffent et s'usent en quelques minutes. Un flotteur ou un capteur de niveau sans contact dans le réservoir, qui arrête la pompe par logiciel, est la protection la plus simple.
Combien de temps un arrosage ESP32 tient-il sur batterie ?
Avec le Wi-Fi allumé en permanence, la batterie est vide en quelques jours. Avec le deep sleep, tout dépend du courant de veille de la carte : un DevKit ordinaire à 10 mA en veille tient environ 12 jours avec 3000 mAh, alors qu'une carte basse consommation à 0,15 mA tient des mois.
Projets à réaliser après cet article
Voir tous les projets
Station d'irrigation intelligente
Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

Connexion Wi-Fi STA ESP32 (avec écran LCD)
Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

ESP32 DHT22 Température et humidité (avec écran LCD)
Il s'agit d'un projet permettant de mesurer la température ambiante et le taux d'humidité à l'aide d'un capteur DHT22 et d'afficher ces données en temps réel sur un écran LCD I2C 16x2. Les données du capteur sont lues à l'aide du protocole one-wire grâce à la bibliothèque Adafruit DHT. Ce projet constitue la base des stations météo IoT, de la domotique ou des systèmes de surveillance de l'environnement dans les serres.

Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
Avec un ESP32, un capteur de mouvement PIR, un capteur de lumière LDR et un module relais, on transforme ton couloir, tes toilettes ou ton cellier en éclairage intelligent. Si la pièce est déjà claire, la lumière reste éteinte malgré le mouvement : pas de gaspillage d'énergie en journée. La lumière reste allumée 30 secondes et la durée se prolonge automatiquement tant que le mouvement continue.

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

