Gidsen · 10 min leestijd

ESP32-plantenbewatering: Wi-Fi-bedieningspaneel en bodemvochtsensor

Bouw een ESP32-plantenbewatering: capacitieve bodemvochtsensor, relais en pomp, webpaneel voor drempel en timing, kalibratie, deep sleep, droogloopbeveiliging.

Een ESP32-plantenbewatering combineert een sensor die meet hoe nat de grond in een pot is met een kleine waterpomp, zodat je plant op het juiste moment water krijgt, ook als je weg bent. Als de grond droger wordt dan het niveau dat je hebt ingesteld, laat de ESP32 de pomp via een relais een paar seconden draaien, wacht tot het water is ingetrokken en meet opnieuw. Dankzij Wi-Fi volg je het vochtniveau op je telefoon en pas je de bewateringsdrempel en -duur aan via een webpaneel.

In deze gids gaan we stap voor stap te werk: van het kalibreren van de capacitieve bodemvochtsensor tot een complete bewateringssketch met webpaneel, en daarna een deep-sleepversie op batterijen voor balkons zonder stopcontact. We bespreken ook hoe je per plantsoort een drempel kiest, hoe je de pomptijd berekent uit het debiet en, het belangrijkste, hoe je de pomp beschermt tegen droogdraaien als het reservoir leeg is.

Mini-dompelpomp
3–6 V mini-dompelpomp: hij zit in het reservoir, duwt water via een dun slangetje naar de pot en trekt ongeveer 100–200 mA.

Hoe werkt een ESP32-plantenbewatering?

Het systeem draait een eenvoudige lus. Elke 10 seconden neemt de ESP32 16 metingen van de sensor, middelt ze en zet het resultaat om in een vochtwaarde tussen 0% (helemaal droog) en 100% (in water). Is het vochtniveau lager dan je drempel, zit er water in het reservoir en is er genoeg tijd verstreken sinds de laatste beurt, dan laat hij de pomp de ingestelde tijd draaien. Daarna begint een intrekperiode, zodat het water zich door de grond kan verspreiden; tot die voorbij is volgt er geen nieuwe beurt. Al deze instellingen pas je aan via het webpaneel en worden opgeslagen in het flashgeheugen van de ESP32.

OnderdeelTaakOpmerking
ESP32 DevKitMeten, beslissen en het webpaneel aanbiedenAlleen 2,4 GHz Wi-Fi
Capacitieve bodemvochtsensor v1.2Zet bodemvocht om in een analoge spanningCorrodeert niet; werkt op 3,3–5,5 V
1-kanaals relaismoduleSchakelt de pomp aan en uitKies een model dat schakelt op een 3,3 V-signaal
3–6 V mini-dompelpomp en slangPompt water van het reservoir naar de potOngeveer 100–200 mA
VlotterschakelaarMeldt wanneer het reservoir leeg isBeschermt de pomp tegen droogdraaien
5 V 2 A-adapterVoedt de ESP32, het relais en de pompAlle massa's (GND) zijn met elkaar verbonden
1N4007- of 1N5819-diodeVangt de spanningspiek op wanneer de pomp uitschakeltKathode naar de +-aansluiting van de pomp

Capacitief of resistief? Zo kies je de juiste bodemvochtsensor

Goedkope resistieve sensoren (twee metalen pinnen als een vork) meten door stroom rechtstreeks door de grond te sturen. Die stroom veroorzaakt elektrolyse op de pinnen: binnen een paar weken corrodeert het metaal, lopen de metingen uit de pas en komen er metaalionen in de grond. Bij een capacitieve sensor zitten de elektroden onder een isolerende coating en maken ze nooit elektrisch contact met de grond; de sensor meet hoe het water in de grond zijn capaciteit verandert. Daarom kan hij maanden of zelfs jaren in de grond blijven. Voor een bewateringssysteem dat continu draait is een capacitieve sensor praktisch een must. Een uitgebreide vergelijking van de twee vind je in Bodemvochtsensor.

Bedrading: ESP32, sensor, relais en pomp

VerbindingESP32-pinOpmerking
Sensor AOUTGPIO 34ADC1-kanaal; uitleesbaar met Wi-Fi aan
Sensor VCC3V3 (GPIO 25 in de batterijversie)Op batterijen krijgt hij alleen stroom tijdens het meten
Sensor GNDGNDGemeenschappelijke massa
Relais INGPIO 26De meeste modules schakelen op LOW
Relais VCC / GNDVIN (5 V) / GNDDe relaisspoel heeft 5 V nodig
VlotterschakelaarGPIO 27 en GNDINPUT_PULLUP; contact gesloten zolang er water is
Pomp5 V, via relais COM–NODe pompstroom loopt nooit door de ESP32
Op de ESP32 kunnen pins op de ADC2-kanalen (GPIO 0, 2, 4, 12–15 en 25–27) niet met analogRead() worden uitgelezen zolang Wi-Fi aan staat, omdat Wi-Fi die converter zelf gebruikt. Sluit de sensor dus altijd aan op een van de ADC1-kanalen, oftewel GPIO 32–39. Let ook op het relais: sommige optisch geïsoleerde relaismodules op 5 V zien de 3,3 V HIGH van de ESP32 niet als "uit", waardoor het relais de hele tijd aan blijft. Kies een module die schakelt op 3,3 V, of stuur de pomp aan met een logic-level MOSFET.

Wanneer de pompmotor uitschakelt, ontstaat er een omgekeerde spanningspiek die de ESP32 kan resetten. Plaats daarom een diode in sperrichting over de aansluitingen van de pomp (kathode naar +) en zet een condensator van 100–470 µF vlak bij de 5 V-ingang van de ESP32. De massa's van de relaismodule, de pomp en de ESP32 moeten allemaal met elkaar verbonden zijn. Houd het reservoir onder de pot en laat de slang boven het waterniveau in het reservoir eindigen; anders blijft het water door hevelwerking doorstromen, ook nadat de pomp is gestopt, en loopt de pot over. Hoe je de pomp aanstuurt, leggen we uitgebreid uit in Arduino-waterpomp.

Stap 1: de sensor kalibreren (droge en natte waarde)

Elke capacitieve sensor, kabellengte en voedingsspanning geeft net andere waarden, dus je moet de code afstemmen op de twee uiterste waarden van je eigen sensor. Upload de onderstaande code en open de Serial Monitor op 115200 baud. Houd de sensor eerst in de lucht en noteer de waarde: dat is RAW_DRY, oftewel 0%. Dompel de sensor daarna in een glas water tot aan de lijn op het printje en noteer de nieuwe waarde: dat is RAW_WET, oftewel 100%. Bij een capacitieve sensor daalt de waarde naarmate het vocht toeneemt; het percentage krijg je met vocht % = (RAW_DRY − raw) × 100 / (RAW_DRY − RAW_WET).

C++ (Arduino IDE)
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}
SituatieRuwe waarde (voorbeeld)Vocht (%)
In de lucht (helemaal droog)≈ 30000 (RAW_DRY)
Droge grond≈ 2500–270017–29
Vochtige grond (ideaal voor de meeste planten)≈ 1800–220046–69
Net bewaterde grond≈ 1500–170074–86
In een glas water≈ 1250100 (RAW_WET)
Steek de sensor alleen in water of grond tot aan de lijn die erop staat; als de elektronica bovenaan nat wordt, is de sensor kapot. Voor consistente metingen steek je de sensor altijd even diep in de grond en druk je de grond er stevig omheen aan; luchtgaten laten de grond droger lijken dan hij is. Wil je de meest realistische "natte" referentie, geef de pot dan flink water, wacht een uur en gebruik de waarde die je dan ziet.

Een bewateringsdrempel kiezen voor je plant

PlantsoortBewateringsdrempelOpmerking
Cactussen en vetplanten15–25%Laat de grond bijna helemaal uitdrogen
Kamerplanten (pothos, monstera, ficus)30–40%Als de bovenste 2–3 cm droog zijn
Groenten en zaailingen (tomaat, basilicum, paprika)45–60%Houd de grond steeds licht vochtig
Varens en vochtminnende planten55–70%Laat de grond nooit helemaal uitdrogen

Twee instellingen zijn net zo belangrijk als de drempel: pomptijd en intrektijd. Een minipomp van 100 L/u verplaatst in theorie ongeveer 28 ml per seconde, maar met een dun slangetje en een paar tientallen centimeters hoogteverschil haal je in de praktijk zo'n 15–20 ml per seconde. Het beste is om de pomp 10 seconden in een maatbeker te laten pompen en het echte debiet te meten. Voor een pot van 15 cm is 80–150 ml per beurt meestal genoeg, dus 5–8 seconden. De intrektijd geeft het water de kans om zich door de grond te verspreiden en de sensor te bereiken: zonder die tijd is de sensor nog niet nat, laat het systeem de pomp steeds opnieuw draaien en loopt de pot over. 30 minuten is een goed beginpunt.

Stap 2: ESP32-bewateringscode met webpaneel

De hoofdsketch regelt het automatisch bewateren en serveert ook een klein paneel dat je op je telefoon opent. Het paneel ververst elke 3 seconden het vochtniveau, de status van pomp en reservoir en de tijd sinds de laatste beurt. In het formulier pas je de drempel, pomptijd en intrektijd aan, en met de knop "Nu water geven" geef je handmatig water. De instellingen worden met de bibliotheek Preferences naar flash geschreven en overleven dus een stroomuitval. Zelfs als Wi-Fi geen verbinding krijgt, gaat de code na 20 seconden door en blijft het automatisch bewateren werken. Vergeet niet de twee waarden uit je kalibratie in de regels RAW_DRY en RAW_WET te zetten:

C++ (Arduino IDE)
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> &middot; 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}
CodeWat het doet
RAW_DRY / RAW_WETDe twee uiterste waarden die je tijdens de kalibratie hebt gevonden
map() + constrain()Zet de ruwe waarde om naar 0–100% en houdt hem binnen het bereik
PreferencesSlaat de drempel, pomptijd en intrektijd op in flash
soakMinWacht tussen twee beurten, zodat het water zich door de grond kan verspreiden
waterAvailable()Meldt de vlotter dat het reservoir leeg is, dan start de pomp nooit of stopt hij meteen
/save en /waterSlaan de formulierinstellingen op en starten een handmatige beurt

Open na het uploaden het IP-adres dat in de Serial Monitor staat op een telefoon die met hetzelfde Wi-Fi-netwerk is verbonden. Afhankelijk van hoe de vlotterschakelaar is gemonteerd, kan het contact open zijn zolang er water is; toont het paneel het reservoir altijd als "LEEG", verander dan LOW in HIGH in waterAvailable(). Het paneel heeft geen wachtwoord, gebruik het dus alleen op je thuisnetwerk; wil je een makkelijk te onthouden adres in plaats van een IP-adres en een levendiger interface, voeg dan de technieken uit ESP32 Async Web Server en WebSocket toe.

De pomp beschermen als het water op is

Mini-dompelpompen worden gekoeld en gesmeerd door het water dat erdoorheen stroomt. Draaien ze droog, dan worden ze binnen enkele minuten heet en slijten hun afdichtingen en waaier; een pomp die een hele vakantie in een leeg reservoir blijft draaien, is meestal kapot. Daarom beschermt een goede bewatering de pomp in meerdere lagen:

  • Vlotterschakelaar: Zakt het water in het reservoir onder een bepaald niveau, dan opent het contact en start de code de pomp nooit; raakt het water midden in een beurt op, dan stopt de code de pomp meteen. Bedradingsdetails staan in Vlotterschakelaar.
  • Tijdslimiet: De pomp draait nooit langer dan de ingestelde tijd (maximaal 60 s); zelfs als het relais softwarematig blijft hangen, schakelt de code hem uit.
  • Intrektijd: Tussen twee beurten zitten minstens soakMin minuten, zodat een defecte sensor het systeem niet kan dwingen non-stop water te geven.
  • Controle op vochtstijging: Houd desgewenst een foutteller bij als de waarde na het bewateren niet is gestegen; stop na drie mislukte beurten het automatisch bewateren en stuur een melding via een Telegram-bot. Zo ontdek je een slang die losgeraakt is of een sensor die niet meer in de grond zit.
  • Contactloze niveausensor: Gebruik in plaats van een vlotter een XKC-Y25, die van buiten de reservoirwand meet, zodat er niets in het water hoeft te zitten.

Bewateren op batterijen met deep sleep

Wil je het systeem op batterijen laten draaien op een balkon of in een tuin zonder stopcontact, zet de ESP32 dan tussen de metingen in deep sleep. De onderstaande versie slaat het webpaneel over, omdat Wi-Fi aanhouden de batterij in een paar dagen zou leegtrekken. Het board wordt elke 30 minuten wakker, voedt de sensor alleen tijdens het meten via GPIO 25, laat zo nodig de pomp draaien en gaat weer slapen. Het aantal keren wakker worden en bewateren wordt met RTC_DATA_ATTR in het RTC-geheugen bewaard, zodat het de slaap overleeft. In de batterijversie trekt een 5 V-relaisspoel veel stroom en schakelt hij bij lage spanning mogelijk niet meer in, dus het is verstandiger de pomp met een logic-level MOSFET aan te sturen; details in Een MOSFET gebruiken met Arduino.

C++ (Arduino IDE)
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}

De batterijduur wordt vooral bepaald door de slaapstroom van het board. Een gewone ESP32 DevKit kan in slaap 5–10 mA trekken door de regelaar en de USB-naar-serieel-chip: bij 10 mA gaat een batterij van 3000 mAh maar 300 uur mee, zo'n 12 dagen. Met een board met laag verbruik dat slaapt op 0,15 mA verandert het beeld: 48 keer per dag wakker worden (elk 0,5 seconde op 50 mA), 0,15 mA slaapstroom en één pompbeurt van 5 seconden per dag komen samen op ongeveer 4,3 mAh; dezelfde batterij zou in theorie bijna twee jaar meegaan, al beperkt zelfontlading dat in de praktijk tot maanden. Reken met je eigen cijfers via de tool Batterijduur, en lees ESP32 Deep Sleep voor manieren om de slaapstroom te verlagen.

Tijdens deep sleep zweven de pins van de ESP32. De meeste relaismodules behandelen een zwevende ingang als "uit", maar gebruik je een MOSFET, plaats dan een weerstand van 100 kΩ tussen gate en GND; anders zweeft de gate en kan de pomp zichzelf inschakelen terwijl het board slaapt. Schakel de pomp in de code altijd uit voordat je gaat slapen en houd de opstelling de eerste paar dagen in de gaten.

Projectideeën en uitbreidingen

  • Systeem voor meerdere potten: Geef elke pot een eigen sensor en pomp; de ADC1-pins van de ESP32 volstaan voor maximaal zes potten.
  • Meldingen: Stuur met Telegram een bericht naar je telefoon als het reservoir leeg is of de grond te droog blijft.
  • Vochtlogboek: Sla de metingen op in Google Sheets en zie in een grafiek hoe vaak je plant water nodig heeft.
  • Bewatering op zonne-energie: Laad overdag de batterij op met een klein zonnepaneel en een TP4056.
  • Regencontrole: Voeg buiten een regensensor toe en sla het bewateren over als het regent.
  • Slimme kas: Voeg temperatuur, luchtvochtigheid en een ventilator toe en maak er een project voor een slimme kas van.

Veelvoorkomende problemen en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
Vocht altijd 0% of verandert nooitSensor op een ADC2-pin met Wi-Fi aanVerplaats de sensor naar een van GPIO 32–39
Metingen springen heen en weerRuis, of de sensor zit niet goed in de grondNeem het gemiddelde van 16 metingen en druk de sensor stevig aan
ESP32 reset wanneer de pomp startSpanningsval, geen diodeVoeg de diode en een condensator van 470 µF toe, gebruik een adapter van 2 A
Relais valt nooit afEen 5 V-relais herkent de 3,3 V HIGH nietGebruik een relais dat met 3,3 V werkt of een MOSFET, controleer RELAY_ACTIVE_LOW
Pot loopt overIntrektijd te kort, of hevelwerkingVerhoog soakMin, laat de slang boven het waterniveau van het reservoir eindigen
Pomp draait maar er komt geen water uitLucht in de pomp, of het reservoir is leegDompel de pomp volledig onder, controleer de vlotterschakelaar
Instellingen worden gereset na een stroomuitvalWaarden worden niet in flash opgeslagenZorg dat de regels met prefs.putInt() worden uitgevoerd
Test het systeem met een glas water en een handdoek voordat je het op een echte plant uitprobeert: controleer of de pomp start als de sensor in de lucht hangt, stopt als je hem in water dompelt en meteen uitschakelt als je de vlotter laat zakken. Zet de elektronica in een gesloten doos uit de buurt van het water en houd de ESP32 en het reservoir niet op dezelfde plank.

Doordat dit project meten, beslissen, veiligheid en bediening op afstand combineert, is deze ESP32-plantenbewatering ook een mooie eerste stap in domotica. Wil je een bewateringsschakeling stap voor stap bekijken, dan heeft het project Smart Irrigation Station in de BlueGrays-app het bedradingsschema en kant-en-klare code om te uploaden voor een Arduino-versie.

Veelgestelde vragen

Hoe maak ik een automatische plantenbewatering met een ESP32?

Sluit een capacitieve bodemvochtsensor aan op een van de ADC1-pins van de ESP32 en een relaismodule op een digitale pin, en voed de minipomp via het relais met een aparte 5 V-voeding. Kalibreer de sensor in lucht en in water en stel in de code een vochtdrempel in; zakt het vocht eronder, dan draait de pomp een paar seconden en wacht het systeem tot het water is ingetrokken.

Welke ESP32-pin moet ik voor de bodemvochtsensor gebruiken?

Sluit de analoge uitgang aan op een van de ADC1-pins tussen GPIO 32 en 39; in deze gids gebruiken we GPIO 34. ADC2-pins kunnen niet met analogRead() worden uitgelezen zolang Wi-Fi aan staat, dus in Wi-Fi-projecten hoort de sensor altijd op ADC1.

Bij welk bodemvochtpercentage moet ik mijn planten water geven?

Dat hangt van de plant af: 15–25% voor cactussen en vetplanten, 30–40% voor de meeste kamerplanten en 45–60% voor groenten zoals tomaten en basilicum zijn goede beginpunten. Omdat de percentages afhangen van de kalibratie van je sensor, bekijk je de plant een paar dagen en stel je de drempel bij.

Moet ik de pomp met een relais of een MOSFET aansturen?

Voor een systeem op netvoeding is een relaismodule die schakelt op 3,3 V praktisch en veilig. Voor systemen op batterijen, of als je de pompsnelheid met PWM wilt regelen, verbruikt een logic-level MOSFET minder en werkt hij geruisloos; plaats in beide gevallen een diode in sperrichting over de pomp.

Raakt een mini-waterpomp beschadigd als hij droogdraait?

Ja. Mini-dompelpompen worden gekoeld en gesmeerd door het water dat erdoorheen gaat, en als ze droogdraaien worden ze binnen enkele minuten heet en slijten ze. Een vlotterschakelaar of een contactloze niveausensor in het reservoir die de pomp softwarematig stopt, is de eenvoudigste bescherming.

Hoe lang draait een ESP32-plantenbewatering op batterijen?

Met Wi-Fi de hele tijd aan is de batterij binnen een paar dagen leeg. Met deep sleep hangt het af van de slaapstroom van het board: een gewone DevKit die in slaap 10 mA trekt, haalt ongeveer 12 dagen uit een batterij van 3000 mAh, terwijl een board met laag verbruik op 0,15 mA maandenlang meegaat.

Alle projecten bekijken
Slim bewateringsstation
AR-83Gevorderd
Premium

Slim bewateringsstation

Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.

5.0(42)
57
ESP32 asynchrone webserver (met IP-weergave op lcd)
ES-27Gevorderd

ESP32 asynchrone webserver (met IP-weergave op lcd)

In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

4.8(16)
26
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
ES-25Gevorderd

ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)

In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

4.4(21)
38
ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)

De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

4.3(10)
16
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)

Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

4.8(38)
57
ESP32 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

ESP32 slimme verlichting (PIR + LDR + relais + OLED)

Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

4.3(6)
11
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12