Regensensor Arduino-gids: bedrading, code en automatisch raam
Regensensor met Arduino: FC-37/YL-83 aansluiten, AO- en DO-uitgang, drempel instellen, corrosie voorkomen, buzzeralarm, servoraam, ESP32- en Pico-code.
Met een regensensor merkt je Arduino regendruppels op en meldt hij binnen milliseconden: "het is gaan regenen". Het is een van de goedkoopste en leukste sensoren die je kunt kopen. Hij bestaat uit een sensorpad dat het water opvangt en een klein printje met een LM393-comparator, en hij sluit met slechts vier draden op de Arduino aan. Een herinnering om de was binnen te halen voordat die doorweekt raakt, een raam of luifel die vanzelf dichtgaat als het begint te regenen, een tuinsysteem dat bij regen niet sproeit en een klein weerstation beginnen allemaal met deze module.
In deze gids leer je wat er in de regensensormodule zit die als FC-37, YL-83 en MH-RD wordt verkocht, wat het verschil is tussen de analoge (AO) en digitale (DO) uitgang, hoe je de drempel met de potentiometer instelt en het meest vergeten onderwerp van allemaal: hoe je voorkomt dat het pad corrodeert. Daarna bouwen we stap voor stap een regenalarm met intensiteitsniveaus op de Arduino, een automatische raamsluiter met een servomotor, meldingen op je telefoon met de ESP32 en een MicroPython-voorbeeld voor de Raspberry Pi Pico.

Wat is een regensensor en hoe werkt hij?
Het sensorpad heeft twee geleidende sporen die als de tanden van twee kammen in elkaar grijpen zonder elkaar ooit te raken. Als het pad droog is, ligt de weerstand ertussen in het megaohmbereik, dus de schakeling is praktisch open. Als een regendruppel over twee sporen valt, vormt het water een brug ertussen en daalt de weerstand. Hoe meer druppels er vallen en hoe meer van het pad nat wordt, hoe lager de weerstand wordt. Op de printplaat vormt het pad samen met een weerstand, op de meeste modellen 10 kΩ, een spanningsdeler: bij een droog pad ligt de spanning op de AO-pin dicht bij de voedingsspanning (VCC), en die daalt naarmate het pad natter wordt. Met de spanningsdelercalculator kun je uitproberen hoe de uitgang verandert bij verschillende weerstanden.
De LM393 op het printje is een comparator-IC die twee spanningen vergelijkt. De ene ingang krijgt de spanning van het pad en de andere een referentiespanning die je met de potentiometer instelt. Zodra de padspanning onder de referentie zakt, dus als er genoeg water wordt gedetecteerd, gaat de DO-uitgang LOW en gaat de DO-led op het printje branden. De LM393 heeft een open-collectoruitgang; dankzij een pull-upweerstand op het printje blijft DO HIGH als het niet regent. De andere led (PWR) laat gewoon zien dat de module spanning heeft.
| Eigenschap | Waarde |
|---|---|
| Sensorpad | Ongeveer 5,4 × 4 cm; in elkaar grijpende sporen op FR4, op de meeste modellen vernikkeld |
| Printplaat | Ongeveer 3 × 1,5 cm, LM393-comparator |
| Voedingsspanning | 3,3–5 V |
| Stroom | Ongeveer 8 mA (bij 5 V met beide leds aan) |
| Analoge uitgang (AO) | Tussen 0 V en VCC; daalt als het pad nat wordt |
| Digitale uitgang (DO) | HIGH als het droog is, LOW zodra de drempel wordt overschreden |
| Indicatoren | PWR-led (voeding) en DO-led (regen gedetecteerd) |
| Afstelling | Gevoeligheidspotentiometer (verandert alleen de DO-drempel) |
| Aansluitingen | 2 pinnen aan de padkant (richting maakt niet uit), 4 pinnen aan de Arduino-kant: VCC, GND, DO, AO |
FC-37, YL-83 en MH-RD: is er verschil?
Kort gezegd: nee. FC-37, YL-83 en MH-RD zijn namen die verschillende fabrikanten aan dezelfde schakeling geven; ze bestaan allemaal uit een sensorpad en een LM393-printplaat en werken met dezelfde code. De verschillen zitten meestal in de grootte van het pad, kleine wijzigingen in het sporenpatroon en de kwaliteit van de beplating. De printplaat is bijna identiek aan die van de bodemvochtsensor, dus de printjes van de twee modules zijn uitwisselbaar. De twee pinnen tussen pad en printje hebben geen plus of min, dus het maakt niet uit hoe je de kabel aansluit. Als het pad na verloop van tijd versleten is, hoef je alleen het pad te vervangen.
Analoge (AO) versus digitale (DO) uitgang
Welke uitgang je gebruikt, hangt van je project af. DO zegt alleen "het regent" of "het regent niet"; je stelt de drempel in met de potentiometer op het printje en één digitalRead() op de Arduino is genoeg. AO geeft je daarentegen een getal van 0 tot 1023 dat laat zien hoe nat het pad is, zodat je motregen van een stortbui kunt onderscheiden, de drempel in code kunt aanpassen en aan de hand van opeenvolgende metingen kunt bepalen wanneer de regen begonnen of gestopt is. Je kunt ook beide uitgangen tegelijk gebruiken.
| Eigenschap | DO (digitaal) | AO (analog) |
|---|---|---|
| Wat het je vertelt | Het regent / het regent niet | Hoe nat het pad is (0–1023 op de Uno) |
| Drempel instellen | Potentiometer op het printje | In code, zoals je wilt |
| Arduino-pin | Elke digitale pin | Analog pin (A0–A5) |
| Onderscheidt intensiteit | Nee | Ja (motregen, regen, stortbui) |
| Werkt met interrupts | Ja | Nee |
| Het best voor | Eenvoudige alarmen, wekimpulsen | Niveaumeting, automatisering met hysterese |
Regensensor aansluiten: Arduino Uno, ESP32 en Pico
| Modulepin / onderdeel | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | D7 (om hem alleen tijdens het meten te voeden) of 5V | GPIO 25 of 3V3 | GP15 of 3V3(OUT) |
| GND | GND | GND | GND |
| AO | A0 | GPIO 34 (ADC1) | GP26 (ADC0) |
| DO | D2 | Optioneel (bijv. GPIO 27) | GP14 |
| Actieve buzzer (+) | D8 | Optioneel | GP13 |
| Servosignaaldraad | D9 | Optioneel | GP16 |
Je hebt waarschijnlijk gezien dat VCC in de tabel op een digitale pin zit in plaats van op 5V. De module neemt bij 5 V maar ongeveer 8 mA op, dus een Arduino-pin kan hem makkelijk voeden (de aanbevolen limiet is 20 mA per pin). Zo zet je de module alleen aan voor de paar milliseconden dat je meet en houd je hem de rest van de tijd uit. In het corrosiegedeelte zien we waarom dit zo belangrijk is. De pinnen van de Pico staan standaard op een stuurkracht van 4 mA; omdat de module bij 3,3 V maar een paar mA opneemt, is dat meestal genoeg, maar als je metingen instabiel zijn, kun je de module voeden vanaf de 3V3(OUT)-pin.
De gevoeligheid instellen: de drempel afstellen met de potentiometer
- Veeg het pad droog en geef de module spanning; de PWR-led hoort aan te zijn en de DO-led uit.
- Draai de potentiometer langzaam met een klein schroevendraaiertje tot de DO-led gaat branden. Als de led bij een droog pad al aan is, draai je de andere kant op.
- Ga terug naar het exacte punt waar de led uitgaat. Dit is de gevoeligste stand waarbij DO bij een droog pad HIGH blijft.
- Draai nog iets verder in dezelfde richting voor een veiligheidsmarge; anders kunnen zelfs vochtige lucht of dauw het alarm activeren.
- Laat twee of drie druppels water van je vinger op het pad vallen. De DO-led hoort te gaan branden; zo niet, verhoog dan de gevoeligheid iets.
- Droog het pad en kijk hoe lang het duurt voordat de led uitgaat; zo krijg je een idee hoe lang je systeem moet wachten voordat het besluit dat de regen is gestopt.
Stap voor stap: je eerste meting met Arduino
- Sluit VCC van de module aan op D7, GND op GND, AO op A0 en DO op D2. Steek het pad met de tweedraads kabel in het printje.
- Open de onderstaande code in de Arduino IDE, kies Arduino Uno als board en upload hem.
- Open de Serial Monitor op 9600 baud en noteer de AO-waarde bij een droog pad.
- Laat een paar druppels water op het pad vallen, daarna meer, en noteer telkens de AO-waarde.
- Noteer ook de waarde als het pad helemaal nat is; deze waarden worden de constanten DRY en WET die je in de volgende sketches gebruikt.
1// Yağmur sensörü: AO ve DO okuma / Rain sensor: reading AO and DO
2const int SENSOR_POWER = 7; // modülün VCC'si bu pinden beslenir / module VCC is fed from this pin
3const int RAIN_AO = A0; // analog çıkış / analog output
4const int RAIN_DO = 2; // dijital çıkış / digital output
5
6void setup() {
7 Serial.begin(9600);
8 pinMode(SENSOR_POWER, OUTPUT);
9 digitalWrite(SENSOR_POWER, LOW); // başlangıçta kapalı / off at start-up
10 pinMode(RAIN_DO, INPUT);
11}
12
13void loop() {
14 digitalWrite(SENSOR_POWER, HIGH); // modülü aç / power the module
15 delay(50); // değerin oturmasını bekle / let the reading settle
16 int analogValue = analogRead(RAIN_AO); // 0-1023: kuruyken yüksek / high when dry
17 bool raining = digitalRead(RAIN_DO) == LOW; // yağmurda DO = LOW / DO goes LOW in rain
18 digitalWrite(SENSOR_POWER, LOW); // modülü kapat / power it off
19
20 Serial.print(F("AO: "));
21 Serial.print(analogValue);
22 Serial.print(F(" DO: "));
23 Serial.println(raining ? F("YAGMUR / RAIN") : F("KURU / DRY"));
24 delay(2000); // 2 sn'de bir ölç / measure every 2 s
25}Voor elke meting zet de code D7 HIGH om de module te voeden, wacht 50 ms zodat de condensatoren op het printje zich opladen en de meting stabiliseert, leest AO en DO uit en schakelt de module meteen weer uit. Zo staat de module van elke lus van 2 seconden maar 50 ms aan, oftewel 2,5% van de tijd. Omdat DO bij regen LOW wordt, hebben we de voorwaarde geschreven als digitalRead(RAIN_DO) == LOW. De Turkse woorden in de geprinte berichten zijn zonder bijzondere tekens geschreven, omdat sommige terminals die tekens verminkt weergeven.
| Toestand van het pad | Ca. AO (Uno, 5 V) | DO (afgesteld printje) |
|---|---|---|
| Droog en schoon | 1000–1023 | HIGH |
| Een paar druppels | 750–950 | HIGH of LOW, afhankelijk van de instelling |
| Motregen, deel van het pad nat | 500–750 | LOW |
| Zware regen | 300–500 | LOW |
| Helemaal nat, kraanwater | 150–350 | LOW |
Deze getallen zijn slechts een ruwe indicatie; de grootte van het pad, de staat van de beplating, de zuiverheid van het water en stof op het pad veranderen ze merkbaar. Zelfs de waarden van dezelfde module verschuiven nadat het pad een paar maanden buiten heeft gehangen. Daarom rekenen we in de volgende sketches de ruwe waarde niet rechtstreeks door, maar zetten we hem om in een natheidspercentage van 0 tot 100 met de door jou zelf gemeten droge (DRY) en natte (WET) waarden; dan hoef je alleen deze twee constanten bij te werken zonder de drempels aan te passen.
Arduino-regenalarm: intensiteitsniveaus en een buzzer
Laten we de meting nu omzetten in een bruikbaar alarm. De code leest 8 keer achter elkaar AO uit, middelt ze, zet het resultaat met map() om in een natheidspercentage en deelt het in een van vier niveaus in: droog, motregen, regen en stortbui. Naarmate de regen zwaarder wordt, piept de actieve buzzer zo vaak als het niveaunummer: één keer bij motregen, twee keer bij regen en drie keer bij een stortbui. Sluit de pluspoot van de buzzer aan op D8 en de minpoot op GND; het verschil tussen actieve en passieve buzzers vind je in Wat is een buzzer?.
1// Yağmur şiddeti seviyeleri ve sesli alarm / Rain intensity levels and audible alarm
2const int SENSOR_POWER = 7; // modülün VCC'si / module VCC
3const int RAIN_AO = A0; // analog çıkış / analog output
4const int BUZZER = 8; // aktif buzzer / active buzzer
5const int DRY = 1015; // kuru panel değeri / dry pad reading (kendin ölç / measure yours)
6const int WET = 350; // tamamen ıslak panel / fully wet pad (kendin ölç / measure yours)
7
8const char* const LEVEL_NAMES[] = {"Kuru / Dry", "Ciseleme / Drizzle", "Yagmur / Rain", "Saganak / Downpour"};
9int lastLevel = 0;
10
11int readWetness() {
12 digitalWrite(SENSOR_POWER, HIGH);
13 delay(50);
14 long sum = 0;
15 for (int i = 0; i < 8; i++) sum += analogRead(RAIN_AO); // 8 ölçümün ortalaması / average of 8 readings
16 digitalWrite(SENSOR_POWER, LOW);
17 return constrain(map(sum / 8, DRY, WET, 0, 100), 0, 100); // % ıslaklık / % wetness
18}
19
20void beep(int count) {
21 for (int i = 0; i < count; i++) {
22 digitalWrite(BUZZER, HIGH);
23 delay(150);
24 digitalWrite(BUZZER, LOW);
25 delay(150);
26 }
27}
28
29void setup() {
30 Serial.begin(9600);
31 pinMode(SENSOR_POWER, OUTPUT);
32 pinMode(BUZZER, OUTPUT);
33}
34
35void loop() {
36 int wet = readWetness();
37 int level;
38 if (wet < 10) level = 0; // kuru / dry
39 else if (wet < 40) level = 1; // çiseleme / drizzle
40 else if (wet < 75) level = 2; // yağmur / rain
41 else level = 3; // sağanak / downpour
42
43 Serial.print(F("Islaklik / Wetness: %"));
44 Serial.print(wet);
45 Serial.print(F(" "));
46 Serial.println(LEVEL_NAMES[level]);
47
48 if (level > lastLevel) beep(level); // şiddet artınca seviye kadar bip / beep once per level when it gets heavier
49 lastLevel = level;
50 delay(3000); // 3 sn'de bir ölç / measure every 3 s
51}Het percentage geeft hier aan hoeveel van het pad nat is; het is geen neerslagmeting in millimeters per uur zoals meteorologen gebruiken. Toch is het in de praktijk erg nuttig: lichte motregen overbrugt maar een paar sporen, terwijl een stortbui bijna het hele oppervlak bedekt. Je kunt de niveaugrenzen (10, 40 en 75) aanpassen aan je eigen waarnemingen. Omdat de buzzer alleen klinkt als het niveau stijgt, hoor je niet om de 3 seconden een piep zolang de regen op hetzelfde niveau blijft.
Corrosie: waarom roest het pad en hoe zorg je dat het langer meegaat?
Het grootste probleem van regensensoren is dat ze na verloop van tijd slijten. Als er continu gelijkstroom (DC) op het pad staat, werkt het water tussen de sporen als elektrolyt en begint er elektrolyse: het metaal van het spoor aan de pluskant lost langzaam op, de nikkellaag wordt dunner en het koper eronder wordt donker of groen. Daardoor daalt de weerstand van het droge pad, drijven de metingen weg en breken uiteindelijk de sporen. Een pad dat buiten op een constante 5 V hangt, kan binnen een paar weken merkbaar slijten. Het goede nieuws: de slijtage is evenredig met de tijd dat het pad onder spanning staat, en die tijd bepaal jij.
- Voed hem alleen tijdens het meten: Voed VCC via een digitale pin en houd de module per meting maar 50 ms aan. In een systeem dat elke 2 seconden meet, staat het pad 2,5% van de tijd onder spanning, waardoor de slijtage ongeveer 40 keer langzamer gaat.
- Meet minder vaak: Regen verandert niet binnen seconden. Voor raam- of meldingsprojecten is één meting per 5–30 seconden genoeg; bij een systeem dat elke 30 seconden meet, staat het pad maar ongeveer 0,2% van de tijd onder spanning.
- Wissel de polariteit (gevorderd): Als je het pad rechtstreeks op twee digitale pinnen aansluit en bij elke meting wisselt welk uiteinde HIGH is, wordt de slijtage gelijk over de twee sporen verdeeld. Bij deze methode gebruik je de printplaat niet; je bouwt de spanningsdeler zelf met een weerstand en meet in elke richting.
- Houd het pad schoon: Stof, pollen en vogelpoep verhogen de geleiding en verlagen de droge meting. Maak het pad af en toe schoon met isopropylalcohol en een zachte borstel; schuurpapier of een schuurspons krast de beplating.
- Bescherm het printje, niet het pad: Zet de printplaat in een waterdichte doos of geef hem een conformal coating. Bedek het pad nooit met lak, siliconen of tape; het water moet de sporen raken.
- Houd een reservepad achter de hand: Het pad is een goedkoop verbruiksonderdeel. Als de metingen merkbaar wegdrijven of de sporen donker worden, vervang je gewoon het pad en meet je DRY en WET opnieuw.
Automatisch raam of luifel sluiten met een servomotor
De populairste toepassing van de regensensor is een systeem dat een raam, luifel of kasdak vanzelf sluit als het gaat regenen. Je kunt het bouwen op een model met een SG90-servomotor. Twee regels zijn hier belangrijk. De eerste is bevestiging: één druppel of een insect op het pad mag het raam niet sluiten, dus wachten we op 3 natte metingen achter elkaar voordat we sluiten. De tweede is hysterese: als de regen stopt, droogt het pad niet meteen en schommelt de waarde rond de drempel. Om te voorkomen dat het raam steeds opent en sluit, gebruiken we twee aparte drempels voor "het regent" en "droog", en openen we het raam pas nadat het pad 10 minuten onafgebroken droog is gebleven. Voor servobedrading en hoekbesturing, zie Wat is een servomotor?.


1// Yağmurda pencereyi servo ile kapatan sistem / Closes a window with a servo when it rains
2#include <Servo.h>
3
4const int SENSOR_POWER = 7; // modülün VCC'si / module VCC
5const int RAIN_AO = A0; // analog çıkış / analog output
6const int BUZZER = 8; // aktif buzzer / active buzzer
7const int SERVO_PIN = 9; // servo sinyal kablosu / servo signal wire
8
9const int DRY = 1015; // kuru panel / dry pad (kendin ölç / measure yours)
10const int WET = 350; // ıslak panel / wet pad (kendin ölç / measure yours)
11const int RAIN_ON = 25; // %25 ve üstü: yağıyor / 25% and above: raining
12const int RAIN_OFF = 8; // %8 ve altı: panel kurudu / 8% and below: pad is dry
13const int CONFIRM_COUNT = 3; // art arda 3 ıslak ölçüm / 3 wet readings in a row
14const unsigned long SAMPLE_MS = 2000UL; // 2 sn'de bir ölç / measure every 2 s
15const unsigned long DRY_MS = 600000UL; // 10 dk kuru kalmalı / must stay dry for 10 min
16
17const int OPEN_ANGLE = 90; // pencere açık / window open
18const int CLOSED_ANGLE = 0; // pencere kapalı / window closed
19
20Servo windowServo;
21bool closed = false;
22int wetCount = 0;
23unsigned long lastSample = 0;
24unsigned long drySince = 0;
25
26int readWetness() {
27 digitalWrite(SENSOR_POWER, HIGH);
28 delay(50); // değerin oturmasını bekle / let it settle
29 int raw = analogRead(RAIN_AO);
30 digitalWrite(SENSOR_POWER, LOW);
31 return constrain(map(raw, DRY, WET, 0, 100), 0, 100); // % ıslaklık / % wetness
32}
33
34void beep(int count) {
35 for (int i = 0; i < count; i++) {
36 digitalWrite(BUZZER, HIGH);
37 delay(150);
38 digitalWrite(BUZZER, LOW);
39 delay(150);
40 }
41}
42
43void setup() {
44 Serial.begin(9600);
45 pinMode(SENSOR_POWER, OUTPUT);
46 pinMode(BUZZER, OUTPUT);
47 windowServo.write(OPEN_ANGLE); // attach'tan önce açı ver, servo zıplamasın / set the angle before attach to avoid a jump
48 windowServo.attach(SERVO_PIN);
49}
50
51void loop() {
52 unsigned long now = millis();
53 if (now - lastSample < SAMPLE_MS) return; // ölçüm zamanı gelmedi / not time to measure yet
54 lastSample = now;
55
56 int wet = readWetness();
57 Serial.print(F("Islaklik / Wetness: %"));
58 Serial.println(wet);
59
60 if (wet >= RAIN_ON) {
61 drySince = now; // kuruma sayacını sıfırla / reset the drying timer
62 if (wetCount < CONFIRM_COUNT) wetCount++;
63 if (!closed && wetCount >= CONFIRM_COUNT) {
64 closed = true;
65 beep(3);
66 windowServo.write(CLOSED_ANGLE); // pencereyi kapat / close the window
67 Serial.println(F("Yagmur: pencere kapandi / Rain: window closed"));
68 }
69 } else {
70 wetCount = 0;
71 if (wet > RAIN_OFF) {
72 drySince = now; // ara bölge kuru sayılmaz / the middle zone does not count as dry
73 } else if (closed && now - drySince >= DRY_MS) {
74 closed = false;
75 windowServo.write(OPEN_ANGLE); // 10 dk kuruysa aç / open after 10 dry minutes
76 Serial.println(F("Kuru: pencere acildi / Dry: window opened"));
77 }
78 }
79}| Constante | Wat hij doet | Beginwaarde |
|---|---|---|
| DRY / WET | De door jou zelf gemeten waarden van het droge en natte pad | 1015 / 350 |
| RAIN_ON | Vanaf dit percentage telt het als "het regent" | 25% |
| RAIN_OFF | Tot dit percentage telt het als "droog" | 8% |
| CONFIRM_COUNT | Aantal natte metingen achter elkaar dat nodig is om het raam te sluiten | 3 (ongeveer 6 s) |
| DRY_MS | Hoe lang het pad droog moet blijven voordat het raam opent | 10 minuten |
| OPEN_ANGLE / CLOSED_ANGLE | Servohoek in de open en gesloten stand | 90° / 0° |
Regenmeldingen op je telefoon met de ESP32
Om te weten te komen dat het gaat regenen terwijl je van huis bent, kun je een ESP32 gebruiken. De onderstaande code stuurt via Telegram een bericht "haal de was binnen" zodra het begint te regenen en een bericht "het regent niet meer" nadat het pad 15 minuten droog is geweest. Je moet de bibliotheken UniversalTelegramBot en ArduinoJson installeren via de Library Manager. Hoe je een bot maakt en je chat-ID vindt, leggen we stap voor stap uit in ESP32 Telegram-bot.
1// ESP32 yağmur bildirimi (Telegram) / ESP32 rain notification (Telegram)
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <UniversalTelegramBot.h> // ArduinoJson kütüphanesi de gerekir / also needs the ArduinoJson library
5
6const char* WIFI_SSID = "WIFI_ADI"; // Wi-Fi ağının adı / your Wi-Fi name
7const char* WIFI_PASS = "WIFI_SIFRESI"; // Wi-Fi şifren / your Wi-Fi password
8#define BOT_TOKEN "1234567890:ABCdefGhIJKlmNoPQRstuVWXyz" // BotFather'dan / from BotFather
9#define CHAT_ID "123456789" // senin chat ID'n / your chat ID
10
11const int SENSOR_POWER = 25; // modülün VCC'si (3,3 V) / module VCC (3.3 V)
12const int RAIN_AO = 34; // ADC1 pini, Wi-Fi ile çalışır / ADC1 pin, works with Wi-Fi
13const int DRY = 4095; // kuru panel / dry pad (kendin ölç / measure yours)
14const int WET = 1500; // ıslak panel / wet pad (kendin ölç / measure yours)
15const int RAIN_ON = 25; // %25 ve üstü: yağıyor / 25% and above: raining
16const int RAIN_OFF = 8; // %8 ve altı: kuru / 8% and below: dry
17const unsigned long SAMPLE_MS = 5000UL; // 5 sn'de bir ölç / measure every 5 s
18const unsigned long DRY_MS = 900000UL; // 15 dk kuru: yağmur bitti / 15 dry minutes: rain is over
19
20WiFiClientSecure client;
21UniversalTelegramBot bot(BOT_TOKEN, client);
22
23bool raining = false;
24int wetCount = 0;
25unsigned long lastSample = 0;
26unsigned long drySince = 0;
27
28int readWetness() {
29 digitalWrite(SENSOR_POWER, HIGH);
30 delay(50); // değerin oturmasını bekle / let it settle
31 int raw = analogRead(RAIN_AO); // 0-4095
32 digitalWrite(SENSOR_POWER, LOW);
33 return constrain(map(raw, DRY, WET, 0, 100), 0, 100);
34}
35
36void connectWiFi() {
37 WiFi.mode(WIFI_STA);
38 WiFi.begin(WIFI_SSID, WIFI_PASS);
39 unsigned long start = millis();
40 while (WiFi.status() != WL_CONNECTED && millis() - start < 15000) { // en fazla 15 sn bekle / wait up to 15 s
41 delay(500);
42 }
43}
44
45void notify(const String& text) {
46 if (WiFi.status() != WL_CONNECTED) connectWiFi(); // bağlantı koptuysa yeniden bağlan / reconnect if dropped
47 if (WiFi.status() == WL_CONNECTED) {
48 bot.sendMessage(CHAT_ID, text, "");
49 }
50}
51
52void setup() {
53 Serial.begin(115200);
54 pinMode(SENSOR_POWER, OUTPUT);
55 digitalWrite(SENSOR_POWER, LOW);
56 client.setCACert(TELEGRAM_CERTIFICATE_ROOT); // api.telegram.org kök sertifikası / root certificate
57 connectWiFi();
58 notify("Yagmur sensoru devrede / Rain sensor is online");
59}
60
61void loop() {
62 unsigned long now = millis();
63 if (now - lastSample < SAMPLE_MS) return;
64 lastSample = now;
65
66 int wet = readWetness();
67 Serial.printf("Islaklik / Wetness: %%%d\n", wet);
68
69 if (!raining) {
70 wetCount = (wet >= RAIN_ON) ? wetCount + 1 : 0;
71 if (wetCount >= 2) { // art arda 2 ıslak ölçüm (~10 sn) / 2 wet readings in a row (~10 s)
72 raining = true;
73 drySince = now;
74 String msg = "Yagmur basladi, camasirlari topla! / It's raining, bring in the laundry! %";
75 msg += wet;
76 notify(msg);
77 }
78 } else {
79 if (wet > RAIN_OFF) {
80 drySince = now; // hâlâ ıslak / still wet
81 } else if (now - drySince >= DRY_MS) {
82 raining = false;
83 wetCount = 0;
84 notify("Yagmur durdu / The rain has stopped");
85 }
86 }
87}De ADC van de ESP32 is 12 bits, dus de waarden lopen van 0 tot 4095, en als de module op 3,3 V wordt gevoed, leest een droog pad meestal heel dicht bij 4095; toch moet je de DRY- en WET-waarden zelf meten. Omdat het versturen van een bericht een seconde of twee kan duren, hebben we het meetinterval op 5 seconden gehouden en gebruiken we de vlag raining zodat dezelfde bui niet bericht na bericht veroorzaakt. Als je het systeem op batterijen wilt laten draaien, kun je de ESP32 tussen de metingen in deep sleep zetten, en als je Home Assistant gebruikt, kun je de gegevens via MQTT versturen.
Regensensor met de Raspberry Pi Pico en MicroPython
De logica is op de Raspberry Pi Pico hetzelfde. Voed de module met 3,3 V via GP15 en sluit AO aan op GP26, DO op GP14, de actieve buzzer op GP13 en het signaaldraad van de servo op GP16. De ADC van de Pico geeft met read_u16() waarden van 0 tot 65535. De onderstaande code piept drie keer als hij regen detecteert en trekt met de servo een luifel in; zodra het pad 10 minuten droog is geweest, opent hij de luifel weer.
1# Raspberry Pi Pico yağmur sensörü + servo tente / Raspberry Pi Pico rain sensor + servo awning
2from machine import Pin, ADC, PWM
3import time
4
5power = Pin(15, Pin.OUT, value=0) # modülün VCC'si (3,3 V) / module VCC (3.3 V)
6rain_ao = ADC(26) # GP26 = ADC0, AO çıkışı / AO output
7rain_do = Pin(14, Pin.IN) # DO: yağmurda 0 / DO: 0 in rain
8buzzer = Pin(13, Pin.OUT, value=0) # aktif buzzer / active buzzer
9servo = PWM(Pin(16))
10servo.freq(50) # servolar 50 Hz ister / servos expect 50 Hz
11
12DRY, WET = 65000, 24000 # kendi değerlerinle değiştir / replace with your readings
13RAIN_ON, RAIN_OFF = 25, 8 # % eşikler / % thresholds
14DRY_MS = 10 * 60 * 1000 # 10 dk kuru kalmalı / must stay dry for 10 min
15OPEN_ANGLE, CLOSED_ANGLE = 90, 0
16
17def set_angle(deg):
18 us = 544 + deg * (2400 - 544) // 180 # Arduino Servo ile aynı aralık / same range as Arduino Servo
19 servo.duty_u16(us * 65535 // 20000) # 20 ms periyodun oranı / share of the 20 ms period
20
21def read_sensor():
22 power.value(1)
23 time.sleep_ms(50) # değerin oturmasını bekle / let it settle
24 raw = rain_ao.read_u16() # 0-65535
25 do_wet = rain_do.value() == 0
26 power.value(0)
27 pct = (DRY - raw) * 100 // (DRY - WET)
28 return max(0, min(100, pct)), do_wet
29
30def beep(count):
31 for _ in range(count):
32 buzzer.value(1)
33 time.sleep_ms(150)
34 buzzer.value(0)
35 time.sleep_ms(150)
36
37closed = False
38wet_count = 0
39dry_since = time.ticks_ms()
40set_angle(OPEN_ANGLE) # tente açık başlar / awning starts open
41
42while True:
43 wet, do_wet = read_sensor()
44 print("Islaklik / Wetness: %", wet, " DO:", "YAGMUR / RAIN" if do_wet else "KURU / DRY")
45 now = time.ticks_ms()
46 if wet >= RAIN_ON:
47 dry_since = now # kuruma sayacını sıfırla / reset the drying timer
48 wet_count += 1
49 if not closed and wet_count >= 3: # art arda 3 ıslak ölçüm / 3 wet readings in a row
50 closed = True
51 beep(3)
52 set_angle(CLOSED_ANGLE) # tenteyi kapat / retract the awning
53 else:
54 wet_count = 0
55 if wet > RAIN_OFF:
56 dry_since = now
57 elif closed and time.ticks_diff(now, dry_since) >= DRY_MS:
58 closed = False
59 set_angle(OPEN_ANGLE) # 10 dk kuruysa aç / open after 10 dry minutes
60 time.sleep(2)MicroPython heeft geen ingebouwde servoklasse, dus we rekenen de hoek zelf om naar een pulsbreedte: servo's worden gepositioneerd door pulsen van ruwweg 0,5–2,5 ms die elke 20 ms binnenkomen. De functie set_angle() zet 0–180 graden om naar hetzelfde bereik van 544–2400 microseconden dat de Arduino Servo-bibliotheek gebruikt en rekent die tijd vervolgens om naar een verhouding van 0–65535 voor duty_u16(). Als je de code met Thonny als main.py op de Pico opslaat, draait hij automatisch elke keer dat de Pico spanning krijgt.
Buiteninstallatie: tips voor de juiste plaatsing
- Monteer het pad schuin: Met een helling van 20–45 graden lopen druppels af en droogt het pad sneller nadat het is gestopt met regenen. Op een vlak pad blijft water staan en kan het systeem uren blijven zeggen dat het regent.
- Kies een plek met open lucht: Plaats het pad niet onder een dakrand, bomen of een druipende airconditioner; op zulke plekken mist het echte regen en wordt het door losse druppels geactiveerd.
- Houd de elektronica binnen: Alleen het pad hoort buiten te zitten. Zet de printplaat en de Arduino in een waterdichte doos en dicht de kabeldoorvoer af met een kabelwartel of siliconen.
- Houd de kabel kort: De kabel tussen pad en printje kan tot een paar meter worden verlengd; bij langere kabels neemt de ruis toe. Het middelen van de metingen vermindert deze fluctuatie.
- Let op dauw en mist: Op koele nachten kan vocht dat op het pad condenseert een kleine natheidswaarde geven. Een iets hoger ingestelde RAIN_ON-drempel en bevestiging met opeenvolgende metingen voorkomen de meeste van deze valse alarmen.
- Sneeuw detecteert hij traag: Droge sneeuw geleidt geen elektriciteit; de sensor reageert pas als de sneeuw tot water smelt. Beschouw de sensor in koude klimaten alleen voor regen als betrouwbaar.
Regensensor versus bodemvocht- en waterniveausensoren: de verschillen
| Sensor | Wat meet hij? | Uitgang | Typisch gebruik |
|---|---|---|---|
| Regensensor (FC-37, YL-83) | Waterdruppels die op het oppervlak vallen | AO en DO | Regenalarm, raam- en luifelautomatisering |
| Bodemvochtsensor | Vocht in de grond | AO en DO (hetzelfde LM393-printje) | Planten water geven |
| Waterniveausensor (parallelle sporen) | Hoogte van het water in een reservoir | Analog (S) | Niveau van tank en aquarium |
| Kantelbakregenmeter | Hoeveelheid neerslag (mm) | Eén puls per kanteling | Weerstation |


Een regensensor kan de vraag "hoeveel heeft het geregend?" niet beantwoorden; daarvoor heb je de kantelbakregenmeter uit weerstations nodig. Water uit een trechter vult een klein bakje, het bakje kantelt bij een vaste hoeveelheid (in gangbare weerstationkits staat één kanteling gelijk aan 0,2794 mm regen), en bij elke kanteling sluit een magneet kortstondig een reedschakelaar. De Arduino telt deze pulsen met een interrupt en vermenigvuldigt het aantal met de bakwaarde om de neerslag in millimeters te krijgen. Beide sensoren samen gebruiken is ook zinvol: de regensensor meldt direct dat het is gaan regenen, terwijl de bakmeter het totaal registreert. Wil je de hoogte meten van water dat zich in een reservoir verzamelt, dan is een waterniveausensor een betere keuze.
Projectideeën met een regensensor
- Wasalarm: Een buzzer die klinkt en een led die gaat branden als het begint te regenen; met een ESP32 krijg je ook een bericht op je telefoon.
- Slim kasdak: Sluit de dakluchtklep met een servo bij regen en open hem voor ventilatie op basis van de temperatuur. Zie het slimme-kasproject voor details.
- Niet sproeien bij regen: Voorkom dat het automatische bewateringssysteem dat je met een bodemvochtsensor hebt gebouwd de pomp laat draaien terwijl het regent.
- Mini-weerstation: Toon de regenstatus op een OLED-display samen met de temperatuur, luchtvochtigheid en luchtdruk die je met een BME280 meet.
- Ruitenwissermodel: Een leuk project dat de automatische ruitenwissers van een auto nabootst door een servo sneller te laten zwaaien naarmate de regen zwaarder wordt.
- Smart-homescenario: Voor een systeem dat de ramen sluit, de luifel intrekt en je waarschuwt als het begint te regenen, bekijk je de gids Arduino smart-homeproject.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Mogelijke oorzaak | Oplossing |
|---|---|---|
| AO is altijd 1023 en verandert nooit | De padkabel zit los of is kapot; DO is op A0 aangesloten in plaats van AO | Controleer de twee draden tussen pad en printje en de A0-aansluiting |
| AO is erg laag, zelfs bij een droog pad | Het pad is vuil of nog nat; iets overbrugt de sporen; de meting gebeurt voordat de module voeding heeft | Maak het pad schoon en droog; lees in code pas uit nadat je de voeding hebt ingeschakeld en hebt gewacht |
| DO verandert nooit | De potentiometer staat helemaal aan één kant | Herhaal de stappen voor het afstellen van de gevoeligheid vanaf het begin |
| Regenalarm bij droog weer | Dauw, mist, een vuil pad of een te gevoelige drempel | Verhoog RAIN_ON, bevestig met opeenvolgende metingen, maak het pad schoon |
| De regen is gestopt maar het systeem zegt nog steeds "het regent" | Het pad is vlak gemonteerd en droogt langzaam | Monteer het pad schuin, pas RAIN_OFF en DRY_MS aan |
| De metingen dreven binnen een paar weken weg en de sporen werden donker | Corrosie door continue voeding | Voed de module via een pin, meet minder vaak, vervang het pad |
| Op de ESP32 gaan de metingen fout als Wi-Fi aangaat | AO is aangesloten op een ADC2-pin | Verplaats AO naar een pin tussen GPIO 32 en 39 |
| De servo trilt of de Arduino reset | De servostroom trekt de 5V-lijn omlaag | Voed de servo met een aparte 5V-voeding, verbind de massa's en plaats een condensator van 470 µF over de voeding |
De regensensor is een goedkope maar leerzame module die je in één keer iets leert over spanningsdelers, comparators, hysterese en praktijkproblemen zoals corrosie. Als je eraan denkt het pad alleen tijdens het meten te voeden en de drempels op je eigen metingen te baseren, gaat hij lang mee. In de BlueGrays-app vind je stap-voor-stapprojecten met schakelschema's en code die de onderdelen uit dit artikel gebruiken, zoals een buzzer, een servomotor, een slim bewateringsstation en een ESP32 Telegram-alarm, en daar kun je eenvoudig een regensensor aan toevoegen.
Veelgestelde vragen
Hoe werkt een regensensor?
De twee in elkaar grijpende geleidende sporen op het sensorpad zijn in droge toestand van elkaar geïsoleerd. Als regendruppels de sporen overbruggen, daalt de weerstand van het pad en zakt de uitgang (AO) van de spanningsdeler op het printje. De LM393-comparator vergelijkt deze spanning met de drempel die de potentiometer instelt en trekt de DO-uitgang LOW zodra de drempel wordt overschreden.
Kan een regensensor de hoeveelheid neerslag meten?
Nee. Een regensensor laat zien hoeveel van het pad nat is; dat is genoeg om te zien dat het is gaan regenen en ongeveer hoe hard, maar het geeft geen neerslag in millimeters. Om de hoeveelheid regen te meten gebruik je een kantelbakregenmeter, die bij elke kanteling via een reedschakelaar een puls geeft.
Waarom corrodeert een regensensor en hoe lang gaat hij mee?
Als er continu gelijkstroom op het pad staat, vindt in het water tussen de sporen elektrolyse plaats en lost het metaal van het spoor aan de pluskant op. Een pad dat buiten op een constante 5 V hangt, kan binnen een paar weken merkbaar slijten. Als je de module voedt via een digitale pin en hem per meting maar een paar milliseconden aanhoudt, gaat het pad veel langer mee en werkt het vaak vele maanden zonder problemen.
Geeft een regensensor LOW of HIGH als het regent?
Op de gangbare LM393-modules is de DO-uitgang HIGH als het droog is; hij gaat LOW en de DO-led gaat branden zodra het water op het pad de met de potentiometer ingestelde drempel overschrijdt. De AO-uitgang is bij droog weer het hoogst en daalt als het pad nat wordt; op een Arduino Uno leest een droog pad meestal boven 1000.
Werkt een regensensor met de ESP32 en 3,3 V?
Ja, de module werkt op 3,3 tot 5 V. Op de ESP32 en Raspberry Pi Pico moet je hem op 3,3 V voeden, zodat ook de AO- en DO-uitgangen nooit boven 3,3 V komen. Sluit AO op de ESP32 aan op een van de ADC1-pinnen (GPIO 32–39), die blijven werken terwijl Wi-Fi aanstaat.
Kan een regensensor sneeuw, dauw of mist detecteren?
Droge sneeuw geleidt geen elektriciteit, dus de sensor detecteert sneeuw pas als die smelt. Dauw en dichte mist kunnen daarentegen een dun laagje vocht op het pad achterlaten, wat een kleine natheidswaarde en soms een vals alarm geeft. Om dat te voorkomen houd je de drempel iets hoger, bevestig je het alarm met meerdere opeenvolgende metingen en monteer je het pad schuin.
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.

Temperatuur en luchtvochtigheid met DHT11
Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

Een servomotor gebruiken
De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

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

Een vlamsensor gebruiken
Een kleine bewaker die vuur eerder opmerkt dan jij, in de keuken of de werkplaats.

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.

ESP32 HTTPClient + weer-API (met lcd-scherm)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Het JSON-antwoord wordt verwerkt met ArduinoJson v7 en stad, temperatuur, luchtvochtigheid, weer en wind verschijnen op een I2C-LCD. wttr.in vraagt geen API-sleutel; typ gewoon de naam van een willekeurige stad.
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

