Waterniveausensor met Arduino: kalibratie, overloopalarm en pomp
Een waterniveausensor gebruiken met Arduino: kalibratie voor leeg/half/vol, pin-voeding tegen corrosie, overloopalarm met buzzer, pompbesturing, code voor ESP32 en Pico.
Een waterniveausensor is de goedkoopste en makkelijkste manier om met een Arduino te zien hoe hoog het water staat in een glas, een aquarium, een plantenschoteltje of een kleine tank. Zodra de blootliggende geleidende sporen op de print onder water komen, stijgt de spanning op de analoge uitgang; de Arduino leest die spanning met analogRead() en bepaalt of het water "leeg", "half" of "vol" is. Hij wordt met drie draden aangesloten, werkt met een paar regels code en is het startpunt van veel projecten, van overloopalarmen tot automatische pompbesturing.
In deze gids leer je wat er in de module zit, waarom de meetwaarde nooit 1023 haalt, hoe je een kalibratie voor leeg/half/vol uitvoert en hoe je de corrosie voorkomt die de sensor binnen enkele weken opvreet. Daarna bouw je een overloopalarm met buzzer en een pompbesturing die een tank zelf bijvult, vergelijk je de sensor kort met een vlotterschakelaar en de contactloze XKC-Y25, en zie je ten slotte hoe je hetzelfde doet met de ESP32 en de Raspberry Pi Pico.

Wat is een waterniveausensor en hoe werkt hij?
Het onderste deel van de module heeft tien geleidende sporen die elkaar niet raken en in elkaar grijpen als de tanden van twee kammen. Vijf ervan zijn voedingssporen die aan de +voeding hangen; de andere vijf zijn meetsporen die naar de basis van de S8050 NPN-transistor bovenaan de print lopen. Als de print droog is, zit er alleen lucht tussen de sporen, staat de transistor uit en ligt de S-pin dicht bij 0 V. Zodra de print in water staat, overbrugt het water de voedings- en meetsporen; er vloeit een kleine stroom naar de basis van de transistor, de transistor gaat geleiden en de spanning op de S-uitgang, genomen van de emitter, stijgt. Hoe hoger het water, hoe langer het natte deel van de sporen, hoe lager de weerstand tussen de sporen en hoe hoger de uitgangsspanning.
Deze werking heeft drie belangrijke gevolgen. Ten eerste meet de sensor niet echt water maar de geleidbaarheid van het water: de opgeloste mineralen in kraanwater drijven de meetwaarde op, terwijl zuiver (gedestilleerd) water bijna niets geeft. Ten tweede haalt de uitgangsspanning nooit de voedingsspanning, omdat de uitgang van een transistor komt die als emittervolger werkt; een volledig natte sensor op 5 V leest op een Arduino Uno meestal rond 500–650 en komt nooit in de buurt van 1023. Ten derde is het verband niet lineair: de waarde stijgt snel over de eerste millimeters en vlakt daarna steeds meer af. Deze sensor is dus geen liniaal met millimeternauwkeurigheid, maar een praktische indicator die een paar niveaus betrouwbaar onderscheidt.
| Kenmerk | Waarde |
|---|---|
| Werkspanning | 3,3–5 V DC |
| Stroomverbruik | Minder dan 20 mA (het hoogst als hij volledig nat is) |
| Uitgang | Analoge spanning (S-pin), stijgt naarmate het water stijgt |
| Meetoppervlak | Ongeveer 40 × 16 mm, dus hooguit ongeveer 4 cm waterhoogte |
| Afmetingen van de print | Ongeveer 62 × 20 mm |
| Werktemperatuur | 10–30 °C (opgave van de fabrikant) |
| Pinnen | S (signaal), + (VCC), − (GND) |
Bedrading van de waterniveausensor: Arduino Uno, ESP32 en Pico
| Sensorpin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| S (signaal) | A0 | GPIO 34 (ADC1) | GP26 (ADC0) |
| + (VCC) | D7 (alleen onder spanning tijdens het meten) | GPIO 25 | GP15 |
| − (GND) | GND | GND | GND |
De makkelijkste manier om corrosie te voorkomen is de sensor te voeden vanaf een digitale pin, zoals in de tabel: de code zet de pin vlak voor een meting op HIGH, wacht 10 ms, leest de waarde en zet de pin weer op LOW. In een systeem dat één keer per seconde meet, staan de sporen maar 1 procent van de tijd onder spanning, waardoor de slijtage ongeveer honderd keer langzamer gaat. Als de module volledig nat is, trekt hij hooguit ongeveer 20 mA. De aanbevolen limiet voor een pin van een Arduino Uno is 20 mA en het absolute maximum is 40 mA, en de pin staat maar enkele milliseconden aan, dus deze aansluiting is veilig; ook ESP32-pinnen leveren deze stroom makkelijk. De pinnen van de Pico werken echter met een lagere standaardinstelling voor de stuurstroom (drive strength), dus als de sensor volledig nat is, zakt de pinspanning een beetje in en worden de meetwaarden kleiner. Zolang je met dezelfde bedrading kalibreert is dat geen probleem; wil je stabielere waarden, dan kun je de + van de sensor schakelen met een kleine PNP-transistor zoals de BC557: de emitter gaat naar de 3V3-pin van het board, de collector naar de + van de sensor en de basis via een weerstand van 1 kΩ naar de GPIO-pin, en de sensor gaat dan aan als de pin LOW is. Bekijk de transistortool om een geschikte transistor te kiezen.
Stap voor stap: je eerste meting met Arduino
- Sluit de S-pin van de sensor aan op A0, de +-pin op D7 en de −-pin op GND. Houd de print rechtop met de sporen naar beneden.
- Open de onderstaande code in de Arduino IDE, kies Arduino Uno als board, selecteer de juiste poort en upload.
- Open de Serial Monitor en stel hem in op 9600 baud. Controleer of de waarde dicht bij 0 ligt als de sensor droog is.
- Laat de sensor langzaam in een glas water zakken: eerst alleen de punt, dan halverwege, dan tot de lijn waar de sporen eindigen. Wacht bij elke stap een paar seconden en noteer de waarde.
1const int SENSOR_PIN = A0; // S → A0
2const int POWER_PIN = 7; // + → D7 (yalnızca ölçerken besle / power only while measuring)
3
4int readSensor() {
5 digitalWrite(POWER_PIN, HIGH); // sensörü aç / power the sensor
6 delay(10); // değerin oturmasını bekle / let the reading settle
7 long sum = 0;
8 for (int i = 0; i < 8; i++) { // 8 ölçümün ortalaması / average of 8 readings
9 sum += analogRead(SENSOR_PIN);
10 }
11 digitalWrite(POWER_PIN, LOW); // sensörü kapat / power off
12 return sum / 8;
13}
14
15void setup() {
16 pinMode(POWER_PIN, OUTPUT);
17 digitalWrite(POWER_PIN, LOW); // kapalı başla / start powered off
18 Serial.begin(9600);
19}
20
21void loop() {
22 int raw = readSensor();
23 Serial.print("Ham deger / Raw value: ");
24 Serial.println(raw);
25 delay(1000); // saniyede bir ölç / measure once a second
26}De functie readSensor() houdt de sensor per meting maar ongeveer 11 ms aan. Door de wachttijd van 10 ms kunnen de transistor en het water tussen de sporen tot een stabiele waarde komen; daarna middelt het gemiddelde van 8 metingen de kleine schommelingen van losse samples uit. Op de Uno duurt elke analogRead() ongeveer 0,1 ms, dus 8 metingen duren minder dan 1 ms. Als je het water roert of het glas schudt, zie je de waarden in de Serial Monitor heen en weer springen; dat is normaal, want het bewegende wateroppervlak verandert steeds de natte lengte van de sporen.
Leeg, half, vol: zo kalibreer je
Gebruik de drempelwaarden uit code die je online vindt niet zomaar; elke sensor, elk soort water en elke voedingsspanning geeft andere waarden. Kalibreer in het reservoir waar de sensor echt wordt gebruikt en met hetzelfde water: aquariumwater voor een aquarium, bemest water voor een bemeste irrigatietank. Trek met een stift lijnen op de sensor op 0, 10, 20, 30 en 40 mm, dompel de print tot elke lijn, wacht 3–4 seconden tot de waarde stabiel is en noteer het getal in de Serial Monitor. De onderstaande tabel toont typische bereiken voor kraanwater en een voeding van 5 V; noteer er je eigen waarden naast.
| Niveau | Onderdompeldiepte | Typische Uno-waarde (5 V, kraanwater) |
|---|---|---|
| Leeg | 0 mm (droog) | 0–20 |
| Laag | Ongeveer 5–10 mm | 250–400 |
| Half | Ongeveer 20 mm | 400–480 |
| Vol | Ongeveer 40 mm (lijn waar de sporen eindigen) | 480–650 |
Wat in de tabel opvalt, is hoe snel de waarden in de eerste centimeter stijgen en daarna dicht bij elkaar komen te liggen: tussen 0 en 10 mm kan een verschil van enkele honderden eenheden zitten, maar tussen 20 en 40 mm slechts enkele tientallen. Daarom geeft stuksgewijze lineaire interpolatie, die tussen elk paar meetpunten een eigen verhouding gebruikt, een veel nauwkeuriger resultaat dan één rechte lijn met map(). De onderstaande code bewaart de vijf gemeten punten in twee arrays, rekent de ruwe waarde om naar millimeters en print het niveau bij naam. Je hoeft alleen je eigen meetwaarden in oplopende volgorde in de array RAW te zetten.
1const int SENSOR_PIN = A0;
2const int POWER_PIN = 7;
3
4// Kendi kalibrasyon ölçümlerin / your own calibration readings
5const int N = 5;
6const int RAW[N] = {0, 330, 440, 490, 520}; // ham değer, küçükten büyüğe / raw value, ascending
7const int MM[N] = {0, 10, 20, 30, 40}; // batma derinliği (mm) / immersion depth (mm)
8
9int readSensor() {
10 digitalWrite(POWER_PIN, HIGH);
11 delay(10);
12 long sum = 0;
13 for (int i = 0; i < 8; i++) sum += analogRead(SENSOR_PIN);
14 digitalWrite(POWER_PIN, LOW);
15 return sum / 8;
16}
17
18int rawToMm(int raw) {
19 if (raw <= RAW[0]) return MM[0];
20 for (int i = 1; i < N; i++) {
21 if (raw <= RAW[i]) { // iki nokta arasında oran kur / interpolate between two points
22 return map(raw, RAW[i - 1], RAW[i], MM[i - 1], MM[i]);
23 }
24 }
25 return MM[N - 1]; // en üst noktanın üstü / above the top point
26}
27
28const char* levelName(int mm) {
29 if (mm < 3) return "Bos / Empty";
30 if (mm < 15) return "Az / Low";
31 if (mm < 30) return "Yarim / Half";
32 return "Dolu / Full";
33}
34
35void setup() {
36 pinMode(POWER_PIN, OUTPUT);
37 digitalWrite(POWER_PIN, LOW);
38 Serial.begin(9600);
39}
40
41void loop() {
42 int raw = readSensor();
43 int mm = rawToMm(raw);
44 Serial.print(raw);
45 Serial.print(" -> ");
46 Serial.print(mm);
47 Serial.print(" mm, ");
48 Serial.println(levelName(mm));
49 delay(1000);
50}Overloopalarm met een buzzer
Een van de nuttigste taken van een waterniveausensor is waarschuwen voor een overloop: onder de wasmachine of de boiler, in een plantenschoteltje, in de afvoerbak van een airco of op de rand van een emmer die volloopt, start de sensor het alarm zodra het water de punt raakt. Zelfs het niveau "laag" uit de kalibratietabel is hiervoor genoeg. De onderstaande code gebruikt een actieve buzzer en de ingebouwde led van de Uno; als de waarde ALARM_ON overschrijdt, piept de buzzer elk kwartseconde, en als de waarde onder ALARM_OFF zakt, wordt hij stil. Omdat de timing met millis() in plaats van delay() gebeurt, blokkeren de meting en de buzzer elkaar niet. Over de soorten buzzers lees je meer in Wat is een buzzer? en over het idee achter millis() in millis() en delay().
1const int SENSOR_PIN = A0; // S → A0
2const int POWER_PIN = 7; // + → D7
3const int BUZZER_PIN = 8; // aktif buzzer + ucu / active buzzer +
4const int LED_PIN = 13; // Uno'nun dahili LED'i / Uno's built-in LED
5
6const int ALARM_ON = 200; // bu değer ve üstü taşma / at or above: overflow (kendin ölç / measure yours)
7const int ALARM_OFF = 100; // bunun altına inince alarm biter / alarm clears below this
8
9bool alarmActive = false;
10bool buzzerOn = false;
11unsigned long lastRead = 0;
12unsigned long lastBeep = 0;
13
14int readSensor() {
15 digitalWrite(POWER_PIN, HIGH);
16 delay(10);
17 long sum = 0;
18 for (int i = 0; i < 8; i++) sum += analogRead(SENSOR_PIN);
19 digitalWrite(POWER_PIN, LOW);
20 return sum / 8;
21}
22
23void setup() {
24 pinMode(POWER_PIN, OUTPUT);
25 pinMode(BUZZER_PIN, OUTPUT);
26 pinMode(LED_PIN, OUTPUT);
27 digitalWrite(POWER_PIN, LOW);
28 Serial.begin(9600);
29}
30
31void loop() {
32 unsigned long now = millis();
33
34 if (now - lastRead >= 1000) { // saniyede bir ölç / measure once a second
35 lastRead = now;
36 int level = readSensor();
37 if (!alarmActive && level >= ALARM_ON) alarmActive = true; // taşma başladı / overflow started
38 if (alarmActive && level < ALARM_OFF) alarmActive = false; // su çekildi / water receded
39 Serial.print("Seviye / Level: ");
40 Serial.println(level);
41 }
42
43 if (alarmActive) {
44 if (now - lastBeep >= 250) { // 250 ms öt, 250 ms sus / 250 ms on, 250 ms off
45 lastBeep = now;
46 buzzerOn = !buzzerOn;
47 digitalWrite(BUZZER_PIN, buzzerOn ? HIGH : LOW);
48 }
49 } else if (buzzerOn) {
50 buzzerOn = false;
51 digitalWrite(BUZZER_PIN, LOW);
52 }
53 digitalWrite(LED_PIN, alarmActive ? HIGH : LOW);
54}Pompbesturing: een tank zelf bijvullen
De tweede klassieke toepassing is automatisch bijvullen waarbij het niveau binnen een band blijft. Je wilt misschien het water dat uit een aquarium verdampt aanvullen uit een reserveemmer, de drinkbak van je huisdier gevuld houden of een kasreservoir voeden. De logica is simpel: als het niveau onder START_BELOW zakt, draait de pomp, en als het STOP_ABOVE bereikt, stopt hij. Het verschil tussen deze twee drempels is de hysterese die voorkomt dat de pomp voortdurend aan en uit gaat. Bedenk dat de sensor maar een meetbereik van ongeveer 4 cm heeft; monteer de print op een hoogte waarbij de waterband die je wilt aanhouden binnen die 4 cm valt.

De pomp trekt veel meer stroom dan een Arduino-pin kan leveren, dus stuur hem aan met een relaismodule of met een logic-level MOSFET en een vrijloopdiode, voed de pomp met een aparte voeding en verbind de GND's van beide voedingen met elkaar. Meer details vind je in Wat is een relaismodule?, een MOSFET gebruiken en de mini-waterpomp. Het belangrijkste onderdeel van de code is een veiligheidsmaatregel: als de pomp de hele periode MAX_RUN_MS draait en het niveau het doel nog steeds niet heeft bereikt, vergrendelt het systeem de pomp en waarschuwt het je met korte piepjes. De slang kan eruit geschoten zijn, de reserveemmer kan leeg zijn of de sensor kan verschoven zijn; zonder deze vergrendeling zou de pomp urenlang droog kunnen draaien of de hele ruimte onder water kunnen zetten.
1const int SENSOR_PIN = A0;
2const int POWER_PIN = 7;
3const int PUMP_PIN = 8; // röle IN / relay IN
4const int BUZZER_PIN = 9; // aktif buzzer / active buzzer
5const bool RELAY_ACTIVE_LOW = true; // çoğu röle modülü LOW ile çeker / most relay modules switch on LOW
6
7const int START_BELOW = 300; // bunun altında doldur / start filling below this (kendin ölç / measure yours)
8const int STOP_ABOVE = 480; // bu değerde dur / stop at this value
9const unsigned long MAX_RUN_MS = 30000; // en uzun çalışma 30 sn / max run time 30 s
10
11bool pumpOn = false;
12bool fault = false;
13unsigned long pumpStart = 0;
14
15int readSensor() {
16 digitalWrite(POWER_PIN, HIGH);
17 delay(10);
18 long sum = 0;
19 for (int i = 0; i < 8; i++) sum += analogRead(SENSOR_PIN);
20 digitalWrite(POWER_PIN, LOW);
21 return sum / 8;
22}
23
24void setPump(bool on) {
25 pumpOn = on;
26 bool pinHigh = RELAY_ACTIVE_LOW ? !on : on;
27 digitalWrite(PUMP_PIN, pinHigh ? HIGH : LOW);
28}
29
30void setup() {
31 setPump(false); // pin çıkış olmadan önce kapalı konuma al / set off before the pin becomes an output
32 pinMode(PUMP_PIN, OUTPUT);
33 pinMode(POWER_PIN, OUTPUT);
34 pinMode(BUZZER_PIN, OUTPUT);
35 digitalWrite(POWER_PIN, LOW);
36 Serial.begin(9600);
37}
38
39void loop() {
40 if (fault) { // arıza: pompa kilitli, kesik kesik öt / fault: pump locked out, beep
41 digitalWrite(BUZZER_PIN, HIGH);
42 delay(200);
43 digitalWrite(BUZZER_PIN, LOW);
44 delay(1800);
45 return; // yeniden başlatmak için reset / press reset to restart
46 }
47
48 int level = readSensor();
49
50 if (!pumpOn && level < START_BELOW) {
51 setPump(true); // seviye düştü, doldur / level low, start filling
52 pumpStart = millis();
53 } else if (pumpOn && level >= STOP_ABOVE) {
54 setPump(false); // istenen seviyeye ulaşıldı / target level reached
55 } else if (pumpOn && millis() - pumpStart > MAX_RUN_MS) {
56 setPump(false); // süre doldu, seviye yükselmedi / timed out, level did not rise
57 fault = true;
58 }
59
60 Serial.print("Seviye / Level: ");
61 Serial.print(level);
62 Serial.println(pumpOn ? " pompa / pump ON" : " pompa / pump OFF");
63 delay(500);
64}Waterniveausensor vs vlotterschakelaar vs XKC-Y25
| Kenmerk | Waterniveausensor (geleidende sporen) | Vlotterschakelaar | XKC-Y25 (contactloos) |
|---|---|---|---|
| Meetprincipe | Geleidbaarheid van het water | Drijvende magneet en reedcontact | Verandering in capaciteit achter de wand van het reservoir |
| Uitgang | Analoog (een paar niveaus) | Open of gesloten contact | Digitaal (vloeistof aanwezig of niet) |
| Meetbereik | Ongeveer 0–4 cm | Eén punt (montagehoogte) | Eén punt (montagehoogte) |
| Contact met water | Ja, sporen in het water | Ja, behuizing in het water | Nee, plakt aan de buitenkant van het reservoir |
| Corrosie | Ja; voeden vanaf een pin is een must | Praktisch geen | Geen |
| Voeding | 3,3–5 V | Niet nodig (passief contact) | 5–24 V, ongeveer 5 mA |
| Het best voor | Experimenten, overloopalarmen, kleine reservoirs | Vaste tanks, pompbeveiliging | Gesloten kunststof of glazen tanks, corrosieve vloeistoffen |
| Prijs | Goedkoopst | Goedkoop | Duurder dan de andere |
Een vlotterschakelaar bestaat uit een staaf met een reedcontact erin en een vlotter met een magneet die eroverheen glijdt. Als het water stijgt, komt de vlotter omhoog, komt de magneet ter hoogte van het reedcontact en sluit of opent het contact. Door de vlotter ondersteboven op de staaf te monteren, wissel je tussen normaal open (NO) en normaal gesloten (NC) gedrag. Om hem op een Arduino aan te sluiten, verbind je de ene draad met een digitale pin en de andere met GND en stel je de pin in op INPUT_PULLUP; omdat er geen slijtage door elektrolyse is, gaat hij in vaste installaties veel langer mee. De contacten van kleine modellen zijn meestal beperkt tot ongeveer 0,5 A en 10 W, dus stuur de pomp aan via een relais, niet rechtstreeks. Hoe een reedcontact werkt, lees je in het artikel Reedschakelaar.

1const int FLOAT_PIN = 2; // bir kablo D2'ye, diğeri GND'ye / one wire to D2, the other to GND
2
3void setup() {
4 pinMode(FLOAT_PIN, INPUT_PULLUP); // dahili pull-up direnci / internal pull-up resistor
5 Serial.begin(9600);
6}
7
8void loop() {
9 // Kontak kapalıyken pin LOW okunur / the pin reads LOW when the contact is closed
10 if (digitalRead(FLOAT_PIN) == LOW) {
11 Serial.println("Kontak kapali / Contact closed");
12 } else {
13 Serial.println("Kontak acik / Contact open");
14 }
15 delay(500);
16}De XKC-Y25 daarentegen is een capacitieve sensor die het water nooit aanraakt: je plakt hem aan de buitenkant van een kunststof of glazen tank en hij detecteert of er vloeistof achter de wand zit. Volgens de fabrikant werkt hij op 5–24 V, trekt hij ongeveer 5 mA, kan hij door niet-metalen wanden tot 13 mm dik heen meten en reageert hij in ongeveer 500 ms. Het hoge niveau van zijn uitgang is gelijk aan de voedingsspanning, dus als je een XKC-Y25 op 5 V aansluit op een ESP32 of Pico, moet je een spanningsdeler gebruiken (de spanningsdelertool berekent de juiste weerstanden). De gevoeligheidsinstelling en de modellen met andere uitgangen behandelen we uitgebreid in het artikel XKC-Y25 contactloze niveausensor.

Het waterniveau op je telefoon volgen met de ESP32
Met de ESP32 breng je de meting via Wi-Fi naar je telefoon. Sluit de S-pin van de sensor altijd aan op een ADC1-pin (GPIO 32–39); ADC2-pinnen kunnen niet worden gelezen terwijl Wi-Fi aan staat. De ADC van de ESP32 is 12-bits, dus de waarden lopen van 0 tot 4095, en omdat de sensor op 3,3 V wordt gevoed, zijn de getallen niet te vergelijken met die van de Uno; je moet opnieuw kalibreren. De ADC van de ESP32 is dicht bij 0 V en bovenin zijn bereik niet helemaal lineair, maar omdat het hier om het verschil tussen niveaus gaat en niet om de absolute spanning, is dat geen probleem. De onderstaande code leest elke twee seconden een waarde en serveert een kleine webpagina die zichzelf elke vijf seconden ververst en die je op hetzelfde netwerk vanaf je telefoon kunt openen.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "WIFI_ADIN"; // ağ adın / your network name
5const char* WIFI_PASS = "WIFI_SIFREN"; // ağ şifren / your network password
6
7const int SENSOR_PIN = 34; // S → GPIO 34 (ADC1, Wi-Fi ile çalışır / works with Wi-Fi)
8const int POWER_PIN = 25; // + → GPIO 25
9const int HALF = 1500; // yarım eşiği / half threshold (kendin ölç / measure yours)
10const int FULL = 2000; // dolu eşiği / full threshold (kendin ölç / measure yours)
11
12WebServer server(80);
13int lastRaw = 0;
14unsigned long lastRead = 0;
15
16int readSensor() {
17 digitalWrite(POWER_PIN, HIGH);
18 delay(10);
19 long sum = 0;
20 for (int i = 0; i < 16; i++) sum += analogRead(SENSOR_PIN); // 0–4095
21 digitalWrite(POWER_PIN, LOW);
22 return sum / 16;
23}
24
25const char* levelName(int raw) {
26 if (raw < 100) return "Bos / Empty";
27 if (raw < HALF) return "Az / Low";
28 if (raw < FULL) return "Yarim / Half";
29 return "Dolu / Full";
30}
31
32void handleRoot() {
33 String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
34 "<meta name='viewport' content='width=device-width'>"
35 "<meta http-equiv='refresh' content='5'></head><body>"
36 "<h1>Su seviyesi / Water level</h1><h2>";
37 html += levelName(lastRaw);
38 html += "</h2><p>Ham deger / Raw: ";
39 html += lastRaw;
40 html += "</p></body></html>";
41 server.send(200, "text/html", html);
42}
43
44void setup() {
45 Serial.begin(115200);
46 pinMode(POWER_PIN, OUTPUT);
47 digitalWrite(POWER_PIN, LOW);
48 WiFi.begin(WIFI_SSID, WIFI_PASS);
49 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
50 delay(500);
51 Serial.print(".");
52 }
53 Serial.println();
54 Serial.print("Adres / Address: http://");
55 Serial.println(WiFi.localIP());
56 server.on("/", handleRoot);
57 server.begin();
58}
59
60void loop() {
61 server.handleClient();
62 if (millis() - lastRead >= 2000) { // 2 sn'de bir ölç / measure every 2 s
63 lastRead = millis();
64 lastRaw = readSensor();
65 }
66}Vervang vóór het uploaden WIFI_SSID en WIFI_PASS door je eigen netwerkgegevens; de ESP32 maakt alleen verbinding met 2,4 GHz-netwerken. Als je de Serial Monitor op 115200 baud opent, hoef je alleen het adres dat hij toont in de browser van je telefoon in te typen. Als je een melding op je telefoon wilt zodra het niveau "vol" is, kun je dezelfde meting omzetten in een bericht met de methode uit het artikel ESP32 Telegram-bot.
Overloopalarm met Raspberry Pi Pico en MicroPython
Op de Raspberry Pi Pico worden de pinnen GP26, GP27 en GP28 voor analoge metingen gebruikt. De functie read_u16() van MicroPython schaalt de 12-bits meting van de Pico naar het bereik 0–65535, dus je drempels zijn veel grotere getallen dan op de Uno. De onderstaande code voedt de sensor vanaf GP15, leest de S-uitgang op GP26 en geeft een overloopwaarschuwing met drie korte pieptonen van een actieve buzzer op GP14. Net als bij de eerste sketch stel je de drempels in op basis van je eigen metingen.
1from machine import ADC, Pin
2import time
3
4sensor = ADC(26) # GP26 (ADC0) → S
5power = Pin(15, Pin.OUT, value=0) # GP15 → sensör + / sensor +
6buzzer = Pin(14, Pin.OUT, value=0) # GP14 → aktif buzzer / active buzzer
7
8ALARM_ON = 20000 # bu değer ve üstü taşma / at or above: overflow (kendin ölç / measure yours)
9ALARM_OFF = 10000 # bunun altında alarm biter / alarm clears below this
10
11def read_level(samples=8):
12 power.value(1)
13 time.sleep_ms(10) # değerin oturmasını bekle / let the reading settle
14 total = 0
15 for _ in range(samples):
16 total += sensor.read_u16() # 0–65535
17 power.value(0)
18 return total // samples
19
20alarm = False
21while True:
22 level = read_level()
23 if not alarm and level >= ALARM_ON:
24 alarm = True
25 elif alarm and level < ALARM_OFF:
26 alarm = False
27 print("Seviye / Level:", level, "ALARM" if alarm else "")
28 if alarm:
29 for _ in range(3): # üç kısa bip / three short beeps
30 buzzer.value(1)
31 time.sleep_ms(150)
32 buzzer.value(0)
33 time.sleep_ms(150)
34 else:
35 time.sleep(1)Projectideeën met een waterniveausensor
- Overloopwaarschuwing voor plantenschoteltje: Een buzzer die klinkt als er na het gieten water in het schoteltje blijft staan; combineer hem met een bodemvochtsensor en je hebt een compleet bewateringssysteem.
- Automatisch aquarium bijvullen: Een bijvulsysteem met tijdslimiet dat verdampt water met een minipomp aanvult uit een reserveemmer.
- Waterbak voor huisdieren: Een herinnering die een led laat branden of via de ESP32 een melding naar je telefoon stuurt als de bak bijna leeg is.
- Waterlekdetector: Een lekalarm met de sensor plat op de vloer onder een wasmachine of boiler, of in een kelder.
- Slimme kastank: Een beveiliging die het niveau van de irrigatietank bewaakt en de pomp vergrendelt als die droog loopt; hij past makkelijk in het slimme-kasproject.
- Regenton-meter: Een paneel dat het niveau als leeg, half of vol toont op een I2C-lcd-display; je kunt ook een regensensor toevoegen om het moment te vangen waarop het gaat regenen.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De waarde is altijd 0, ook in water | De +-pin krijgt geen spanning (POWER_PIN wordt nooit HIGH) of S zit op de verkeerde pin | Controleer de regels met pinMode en digitalWrite en of S op een analoge pin is aangesloten |
| De waarde springt willekeurig rond, ook als de sensor droog is | De S-pin zweeft of GND is niet aangesloten | Controleer alle drie de draden; de GND moet gemeenschappelijk zijn |
| Hij haalt nooit 1023, ook niet volledig ondergedompeld | Dat is normaal; de uitgang komt van een emittervolger | Stel je drempels in op basis van de hoogste waarde die je zelf hebt gemeten |
| Helemaal geen meetwaarde in zuiver water | Gedestilleerd of gezuiverd water heeft een zeer lage geleidbaarheid | Gebruik bij dit soort water een XKC-Y25 of een vlotterschakelaar |
| De waarden dalen of lopen na enkele weken af | Elektrolyse en aanslag op de sporen | Voed de sensor vanaf een pin, maak de sporen schoon met een zachte borstel en vervang de sensor indien nodig |
| De pomp of buzzer schakelt steeds om bij de drempel | Er wordt één drempel gebruikt; het bewegende wateroppervlak laat de waarde schommelen | Gebruik twee aparte drempels voor aan en uit (hysterese) en neem het gemiddelde van de metingen |
| Op de ESP32 kan de waarde niet meer worden gelezen zodra Wi-Fi verbinding maakt | De sensor zit op een ADC2-pin | Verplaats S naar een ADC1-pin tussen GPIO 32 en 39 |
De waterniveausensor leert je met één goedkope module analoge metingen, kalibratie, hysterese en praktijkproblemen zoals corrosie. Als je het niveau van een grote tank centimeter voor centimeter wilt meten, kun je overstappen op een ultrasone oplossing zoals de HC-SR04-afstandssensor. In de BlueGrays-app vind je de projecten voor het slimme irrigatiestation en het buzzeralarm met stap-voor-stap schakelschema's en code, en je kunt er makkelijk de waterniveausensor aan toevoegen.
Veelgestelde vragen
Hoe werkt een waterniveausensor?
Als de in elkaar grijpende geleidende sporen op de print in het water komen, overbrugt het water ze en vloeit er stroom naar de basis van de S8050-transistor op de print. Hoe meer de transistor geleidt, hoe hoger de spanning op de S-pin; de Arduino leest die spanning met analogRead() om te bepalen hoe hoog het water staat.
Waarom corrodeert mijn waterniveausensor?
Als er voortdurend gelijkstroom door de natte sporen loopt, begint elektrolyse en lost de coating op de sporen aan + op. Als je de sensor voedt vanaf een digitale pin in plaats van vanaf 5V en hem per meting maar enkele milliseconden inschakelt, gaat de slijtage drastisch langzamer en gaat de sensor maanden mee.
Werkt een waterniveausensor in gedestilleerd water?
Niet echt. Omdat de sensor de geleidbaarheid van het water meet, geeft gedestilleerd of gezuiverd water zonder opgeloste mineralen zeer lage waarden. Voor dit soort water zijn sensoren die niet van geleidbaarheid afhangen, zoals de contactloze XKC-Y25 of een vlotterschakelaar, de betere keuze.
Waarom haalt de meetwaarde van de waterniveausensor 1023 niet?
De S-uitgang komt van de emitter van de transistor, dus de spanning blijft onder de voedingsspanning en de basisstroom wordt beperkt door de weerstand van het water. Op een Arduino Uno op 5 V leest een volledig natte sensor meestal rond 500–650, dus stel je drempels in op basis van dat maximum.
Mag een waterniveausensor volledig onder water?
Nee. Alleen het onderste deel met de geleidende sporen mag in het water; als het bovenste deel met de transistor, led en pinnen nat wordt, ontstaat er kortsluiting en leest de sensor verkeerd of valt hij uit. De elektronica beschermen met lijm uit een lijmpistool of lak zorgt dat hij langer meegaat.
Hoe meet je het niveau van een grote watertank?
Deze sensor bestrijkt maar een bereik van ongeveer 4 cm, dus hij is niet geschikt voor grote tanks. Om het niveau continu te meten gebruikt men waterdichte ultrasone sensoren zoals de JSN-SR04T, gemonteerd in het deksel van de tank; om slechts een paar kritieke punten te bewaken, plaatst men vlotterschakelaars op verschillende hoogtes.
Projecten om hierna te bouwen
Alle projecten bekijken
Een buzzer gebruiken
Heb je je ooit afgevraagd hoe een deurbel of alarm geluid maakt? De Arduino laat een kleine buzzer met korte tussenpozen piepen: piep, pauze, piep, pauze.

Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

Lichtsterkte meten met de ESP32 en een LDR-module
Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

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

Een reedschakelaar uitlezen
Heb je je ooit afgevraagd hoe de magneetschakelaar in deur- en raamalarmen werkt?

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.

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

