Regensensor Arduino: Anschluss, Code und automatisches Fenster

Mit einem Regensensor erkennt dein Arduino Regentropfen und meldet innerhalb von Millisekunden „es regnet“ – er gehört zu den günstigsten und unterhaltsamsten Sensoren überhaupt. Er besteht aus einer Sensorplatte, auf die das Wasser fällt, und einer kleinen Auswerteplatine mit LM393-Komparator und wird mit nur vier Kabeln an den Arduino angeschlossen. Eine Erinnerung, die Wäsche reinzuholen, bevor sie nass wird, ein Fenster oder eine Markise, die sich bei Regen von selbst schließt, eine Gartenbewässerung, die an Regentagen pausiert, und eine kleine Wetterstation – all das beginnt mit diesem Modul.

In dieser Anleitung erfährst du, was im Regensensor-Modul steckt, das als FC-37, YL-83 oder MH-RD verkauft wird, worin sich der analoge (AO) und der digitale (DO) Ausgang unterscheiden, wie du den Schwellwert mit dem Poti einstellst und – das am häufigsten übersehene Thema – wie du die Sensorplatte vor Korrosion schützt. Danach bauen wir Schritt für Schritt einen Regenalarm mit Intensitätsstufen am Arduino, eine automatische Fensterschließung mit Servomotor, Benachrichtigungen aufs Handy mit dem ESP32 und ein MicroPython-Beispiel für den Raspberry Pi Pico.

Was ist ein Regensensor und wie funktioniert er?

Auf der Sensorplatte befinden sich zwei Leiterbahnen, die wie die Zinken zweier Kämme ineinandergreifen, sich aber nie berühren. Ist die Platte trocken, liegt der Widerstand zwischen ihnen im Megaohm-Bereich – der Stromkreis ist praktisch offen. Fällt ein Regentropfen quer über zwei Bahnen, bildet das Wasser eine Brücke und der Widerstand sinkt. Je mehr Tropfen fallen und je größer die nasse Fläche ist, desto kleiner wird der Widerstand. Auf der Auswerteplatine bildet die Sensorplatte zusammen mit einem Widerstand, bei den meisten Modellen 10 kΩ, einen Spannungsteiler: Bei trockener Platte liegt die Spannung am AO-Pin nahe an der Versorgungsspannung (VCC), mit zunehmender Nässe sinkt sie. Wie sich der Ausgang bei verschiedenen Widerständen ändert, kannst du mit dem Spannungsteiler-Rechner selbst ausprobieren.

Der LM393 auf der Platine ist ein Komparator-IC, der zwei Spannungen vergleicht. An einem Eingang liegt die Spannung der Sensorplatte, am anderen eine Referenzspannung, die du mit dem Poti einstellst. Sobald die Spannung der Platte unter die Referenz fällt, also genug Wasser erkannt wird, geht der DO-Ausgang auf LOW und die DO-LED auf der Platine leuchtet. Der LM393 hat einen Open-Collector-Ausgang; dank eines Pull-up-Widerstands auf der Platine bleibt DO ohne Regen auf HIGH. Die zweite LED (PWR) zeigt nur an, dass das Modul Strom bekommt.

FC-37, YL-83 und MH-RD: Gibt es Unterschiede?

Kurz gesagt: nein. FC-37, YL-83 und MH-RD sind Namen, die verschiedene Hersteller derselben Schaltung geben; alle bestehen aus einer Sensorplatte und einer Auswerteplatine mit LM393 und laufen mit demselben Code. Die Unterschiede liegen meist in der Plattengröße, in kleinen Änderungen am Leiterbahnmuster und in der Qualität der Beschichtung. Die Auswerteplatine ist nahezu identisch mit der des Bodenfeuchtesensors, daher sind die Platinen beider Module austauschbar. Die zwei Pins zwischen Platte und Platine haben kein Plus und Minus – es ist egal, wie herum du das Kabel aufsteckst. Ist die Platte irgendwann abgenutzt, tauschst du einfach nur die Platte aus.

Analoger (AO) und digitaler (DO) Ausgang im Vergleich

Welchen Ausgang du nutzt, hängt von deinem Projekt ab. DO sagt nur „Regen“ oder „kein Regen“; den Schwellwert stellst du mit dem Poti auf der Platine ein, und am Arduino genügt ein einziges digitalRead(). AO liefert dagegen eine Zahl von 0 bis 1023, die zeigt, wie nass die Platte ist. So kannst du Nieselregen von Starkregen unterscheiden, den Schwellwert im Code ändern und anhand aufeinanderfolgender Messungen entscheiden, wann der Regen beginnt oder aufhört. Du kannst auch beide Ausgänge gleichzeitig verwenden.

Regensensor anschließen: Arduino Uno, ESP32 und Pico

Dir ist sicher aufgefallen, dass VCC in der Tabelle an einem Digitalpin statt an 5V hängt. Das Modul zieht bei 5 V nur etwa 8 mA, das schafft ein Arduino-Pin problemlos (empfohlen sind höchstens 20 mA pro Pin). So schaltest du das Modul nur für die wenigen Millisekunden der Messung ein und lässt es die übrige Zeit aus. Warum das so wichtig ist, sehen wir im Abschnitt über Korrosion. Die Pins des Pico sind standardmäßig auf eine Treiberstärke von 4 mA eingestellt; da das Modul bei 3,3 V nur wenige mA zieht, reicht das meistens, aber bei unruhigen Messwerten kannst du das Modul auch am Pin 3V3(OUT) betreiben.

Empfindlichkeit einstellen: Schwellwert mit dem Poti festlegen

1. Wische die Platte trocken und versorge das Modul; die PWR-LED muss leuchten, die DO-LED aus sein.
2. Drehe das Poti mit einem kleinen Schraubendreher langsam, bis die DO-LED angeht. Leuchtet sie bei trockener Platte schon, drehe in die andere Richtung.
3. Drehe zurück bis genau zu dem Punkt, an dem die LED erlischt. Das ist die empfindlichste Einstellung, bei der DO mit trockener Platte HIGH bleibt.
4. Drehe ein Stück weiter in dieselbe Richtung, um eine Sicherheitsreserve zu haben; sonst lösen schon feuchte Luft oder Tau den Alarm aus.
5. Lass zwei, drei Wassertropfen vom Finger auf die Platte fallen. Die DO-LED muss angehen; wenn nicht, erhöhe die Empfindlichkeit etwas.
6. Trockne die Platte ab und beobachte, wie lange die LED zum Ausgehen braucht. Das gibt dir ein Gefühl dafür, wie lange dein System warten sollte, bevor es „Regen vorbei“ meldet.

Schritt für Schritt: die erste Messung mit dem Arduino

1. Verbinde VCC des Moduls mit D7, GND mit GND, AO mit A0 und DO mit D2. Stecke die Platte mit dem zweiadrigen Kabel an die Platine.
2. Öffne den folgenden Code in der Arduino IDE, wähle Arduino Uno als Board und lade ihn hoch.
3. Öffne den seriellen Monitor mit 9600 Baud und notiere den AO-Wert bei trockener Platte.
4. Gib erst ein paar Tropfen, dann mehr Wasser auf die Platte und schreibe jedes Mal den AO-Wert auf.
5. Notiere auch den Wert bei komplett nasser Platte; diese Werte werden die Konstanten DRY und WET in den folgenden Sketchen.

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}

Vor jeder Messung setzt der Code D7 auf HIGH und schaltet damit das Modul ein, wartet 50 ms, bis die Kondensatoren auf der Platine geladen sind und sich der Wert stabilisiert hat, liest AO und DO und schaltet das Modul sofort wieder ab. So ist das Modul in jeder 2-Sekunden-Schleife nur 50 ms lang, also 2,5 % der Zeit, unter Spannung. Weil DO bei Regen auf LOW geht, lautet die Bedingung digitalRead(RAIN_DO) == LOW. Die türkischen Wörter in den Ausgaben stehen ohne Sonderzeichen, weil manche Terminals diese Zeichen verstümmelt anzeigen.

Diese Zahlen dienen nur zur groben Orientierung: Plattengröße, Zustand der Beschichtung, Reinheit des Wassers und Staub auf der Platte verändern sie deutlich. Selbst die Werte desselben Moduls driften, wenn die Platte ein paar Monate draußen war. Deshalb verwenden wir in den folgenden Sketchen nicht den Rohwert, sondern rechnen ihn mit deinen selbst gemessenen Werten für trocken (DRY) und nass (WET) in einen Nässe-Prozentwert von 0 bis 100 um. So musst du nur diese zwei Konstanten anpassen und die Schwellwerte nicht anrühren.

Regenalarm mit Arduino: Intensitätsstufen und Buzzer

Jetzt machen wir aus der Messung einen nützlichen Alarm. Der Code nimmt 8 AO-Messungen hintereinander, bildet den Mittelwert, rechnet ihn mit map() in einen Nässe-Prozentwert um und ordnet ihn einer von vier Stufen zu: trocken, Niesel, Regen und Starkregen. Wird der Regen stärker, piept der aktive Buzzer so oft wie die Stufennummer: einmal bei Niesel, zweimal bei Regen, dreimal bei Starkregen. Schließe das Plus-Bein des Buzzers an D8 und das Minus-Bein an GND an; den Unterschied zwischen aktivem und passivem Buzzer findest du im Artikel Was ist ein 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}

Der Prozentwert zeigt, welcher Anteil der Platte nass ist; er ist keine Niederschlagsmessung in Millimetern pro Stunde, wie sie Meteorologen verwenden. Trotzdem ist er in der Praxis sehr nützlich: Leichter Nieselregen überbrückt nur wenige Leiterbahnen, Starkregen bedeckt fast die ganze Fläche. Die Stufengrenzen (10, 40 und 75) kannst du an deine eigenen Beobachtungen anpassen. Weil der Buzzer nur ertönt, wenn die Stufe steigt, hörst du nicht alle 3 Sekunden einen Piepton, solange der Regen gleich stark bleibt.

Korrosion: Warum rostet die Sensorplatte und wie hält sie länger?

Das größte Problem von Regensensoren ist der Verschleiß. Liegt dauerhaft Gleichstrom (DC) an der Platte, wirkt das Wasser zwischen den Leiterbahnen wie ein Elektrolyt und es setzt Elektrolyse ein: Das Metall der Bahn am Pluspol löst sich langsam auf, die Nickelschicht wird dünner und das Kupfer darunter wird dunkel oder grün. Dadurch sinkt der Widerstand der trockenen Platte, die Werte driften und irgendwann reißen die Bahnen. Eine Platte, die draußen dauerhaft an 5 V hängt, kann schon nach wenigen Wochen deutlich angegriffen sein. Die gute Nachricht: Der Verschleiß ist proportional zur Zeit, in der die Platte unter Spannung steht – und diese Zeit hast du selbst in der Hand.

• Nur während der Messung versorgen: Speise VCC aus einem Digitalpin und schalte das Modul pro Messung nur 50 ms ein. Misst dein System alle 2 Sekunden, steht die Platte nur 2,5 % der Zeit unter Spannung – das verlangsamt den Verschleiß etwa um den Faktor 40.
• Seltener messen: Regen ändert sich nicht im Sekundentakt. Für Fenster- oder Benachrichtigungsprojekte reicht eine Messung alle 5–30 Sekunden; bei einer Messung alle 30 Sekunden steht die Platte nur etwa 0,2 % der Zeit unter Spannung.
• Polarität wechseln (für Fortgeschrittene): Schließt du die Platte direkt an zwei Digitalpins an und wechselst bei jeder Messung, welches Ende HIGH ist, verteilt sich der Verschleiß gleichmäßig auf beide Bahnen. Dabei nutzt du die Auswerteplatine nicht, sondern baust den Spannungsteiler selbst mit einem Widerstand auf und misst in beide Richtungen getrennt.
• Platte sauber halten: Staub, Pollen und Vogelkot erhöhen die Leitfähigkeit und senken den Trockenwert. Reinige die Platte ab und zu mit Isopropylalkohol und einem weichen Pinsel; Schleifpapier oder ein Scheuerschwamm zerkratzt die Beschichtung.
• Platine schützen, Platte nicht beschichten: Setze die Auswerteplatine in ein wasserdichtes Gehäuse oder überziehe sie mit Schutzlack. Die Sensorplatte dagegen nie mit Lack, Silikon oder Klebeband abdecken – das Wasser muss die Bahnen berühren.
• Ersatzplatte bereithalten: Die Platte ist ein günstiges Verschleißteil. Wenn die Werte deutlich driften oder die Bahnen dunkel werden, tausche nur die Platte und miss DRY und WET neu.

Fenster oder Markise automatisch schließen mit einem Servomotor

Die beliebteste Anwendung des Regensensors ist ein System, das Fenster, Markise oder Gewächshausdach bei Regen von selbst schließt. An einem Modell kannst du das mit einem SG90-Servomotor aufbauen. Dabei kommt es auf zwei Regeln an. Erstens die Bestätigung: Ein einzelner Tropfen oder ein Insekt auf der Platte soll das Fenster nicht schließen, deshalb warten wir vor dem Schließen auf 3 nasse Messungen hintereinander. Zweitens die Hysterese: Hört der Regen auf, trocknet die Platte nicht sofort, und der Wert pendelt um den Schwellwert. Damit das Fenster nicht ständig auf- und zugeht, verwenden wir zwei getrennte Schwellwerte für „Regen“ und „trocken“ und öffnen das Fenster erst, wenn die Platte 10 Minuten ununterbrochen trocken war. Anschluss und Winkelsteuerung des Servos erklärt der Artikel Was ist ein 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}

Regenwarnung aufs Handy mit dem ESP32

Um auch unterwegs zu erfahren, dass es zu Hause regnet, kannst du einen ESP32 verwenden. Der folgende Code schickt bei Regenbeginn über Telegram die Nachricht „Wäsche reinholen“ und meldet „Regen vorbei“, sobald die Platte 15 Minuten trocken war. Dafür installierst du über den Bibliotheksverwalter die Bibliotheken UniversalTelegramBot und ArduinoJson. Wie du einen Bot erstellst und deine Chat-ID findest, zeigen wir Schritt für Schritt im Artikel 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}

Der ADC des ESP32 hat 12 Bit, die Werte liegen also zwischen 0 und 4095. Wird das Modul mit 3,3 V versorgt, liest eine trockene Platte meist fast genau 4095; DRY und WET solltest du trotzdem selbst messen. Weil das Senden einer Nachricht ein, zwei Sekunden dauern kann, haben wir das Messintervall auf 5 Sekunden gesetzt und nutzen das Flag raining, damit ein und derselbe Schauer nicht eine Nachricht nach der anderen auslöst. Für Batteriebetrieb kannst du den ESP32 zwischen den Messungen in den Deep Sleep schicken, und mit Home Assistant kannst du die Daten per MQTT übertragen.

Regensensor mit Raspberry Pi Pico und MicroPython

Am Raspberry Pi Pico funktioniert alles nach demselben Prinzip. Versorge das Modul über GP15 mit 3,3 V und verbinde AO mit GP26, DO mit GP14, den aktiven Buzzer mit GP13 und die Signalleitung des Servos mit GP16. Der ADC des Pico liefert mit read_u16() Werte von 0 bis 65535. Der folgende Code piept dreimal, wenn er Regen erkennt, und fährt mit dem Servo eine Markise ein; war die Platte 10 Minuten trocken, fährt er sie wieder aus.

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 hat keine fertige Servo-Klasse, deshalb rechnen wir den Winkel selbst in eine Pulsbreite um: Servos werden über Pulse von etwa 0,5–2,5 ms Länge gesteuert, die alle 20 ms kommen. Die Funktion set_angle() bildet 0–180 Grad auf denselben Bereich von 544–2400 Mikrosekunden ab, den auch die Arduino-Servo-Bibliothek nutzt, und wandelt diese Zeit in einen Anteil von 0–65535 für duty_u16() um. Speicherst du den Code mit Thonny als main.py auf dem Pico, startet er bei jedem Einschalten automatisch.

Montage im Freien: Tipps für den richtigen Standort

• Platte schräg montieren: Eine Neigung von 20–45 Grad lässt die Tropfen ablaufen und die Platte nach dem Regen schneller trocknen. Auf einer flachen Platte bleibt Wasser stehen, und das System meldet womöglich stundenlang „Regen“.
• Freien Himmel wählen: Montiere die Platte nicht unter Dachüberständen, Bäumen oder einer tropfenden Klimaanlage; dort verpasst sie echten Regen und wird zugleich von fremden Tropfen ausgelöst.
• Elektronik ins Trockene: Draußen sollte nur die Sensorplatte sein. Setze Auswerteplatine und Arduino in ein wasserdichtes Gehäuse und dichte die Kabeldurchführung mit einer Kabelverschraubung oder Silikon ab.
• Kabel kurz halten: Das Kabel zwischen Platte und Platine lässt sich auf einige Meter verlängern; bei längeren Kabeln nehmen Störungen zu. Mittelwerte aus mehreren Messungen glätten diese Schwankungen.
• Auf Tau und Nebel achten: In kühlen Nächten kann sich Feuchtigkeit auf der Platte niederschlagen und einen kleinen Nässewert erzeugen. Ein etwas höher gesetzter RAIN_ON-Schwellwert und die Bestätigung über mehrere Messungen verhindern die meisten Fehlalarme.
• Schnee erkennt er spät: Trockener Schnee leitet keinen Strom; der Sensor reagiert erst, wenn der Schnee zu Wasser schmilzt. In kalten Regionen solltest du den Sensor nur für Regen als zuverlässig betrachten.

Regensensor, Bodenfeuchtesensor und Wasserstandssensor: die Unterschiede

Die Frage „Wie viel hat es geregnet?“ kann ein Regensensor nicht beantworten. Dafür brauchst du einen Regenmesser mit Kippwaage, wie er in Wetterstationen steckt. Das Wasser aus einem Trichter füllt eine kleine Wippe, die bei einer festen Menge kippt (bei gängigen Wetterstations-Sets entspricht ein Kippvorgang 0,2794 mm Niederschlag), und bei jedem Kippen schließt ein Magnet kurz einen Reedkontakt. Der Arduino zählt diese Impulse per Interrupt und multipliziert die Anzahl mit dem Wippenwert, um die Niederschlagsmenge in Millimetern zu erhalten. Beide Sensoren zu kombinieren ist ebenfalls sinnvoll: Der Regensensor meldet den Regenbeginn sofort, der Kippwaagen-Messer erfasst die Gesamtmenge. Willst du die Höhe von Wasser in einem Behälter messen, ist ein Wasserstandssensor die bessere Wahl.

Projektideen mit dem Regensensor

• Wäsche-Warner: Ein Buzzer, der piept, und eine LED, die leuchtet, sobald es regnet; mit einem ESP32 bekommst du zusätzlich eine Nachricht aufs Handy.
• Smartes Gewächshausdach: Schließe die Dachklappe bei Regen per Servo und öffne sie je nach Temperatur zum Lüften. Details findest du im Artikel zum smarten Gewächshaus.
• Bewässerung bei Regen aussetzen: Sorge dafür, dass deine automatische Bewässerung mit Bodenfeuchtesensor bei Regen die Pumpe nicht einschaltet.
• Mini-Wetterstation: Zeige den Regenstatus zusammen mit Temperatur, Luftfeuchte und Luftdruck aus einem BME280 auf einem OLED-Display an.
• Scheibenwischer-Modell: Ein lustiges Projekt, das den Regensensor im Auto nachahmt und einen Servo umso schneller wischen lässt, je stärker es regnet.
• Smart-Home-Szenario: Für ein System, das bei Regen die Fenster schließt, die Markise einfährt und dich warnt, hilft dir die Anleitung Smart-Home-Projekt mit Arduino.

Häufige Fehler und ihre Lösungen

Der Regensensor ist ein günstiges, aber lehrreiches Modul, das dir Spannungsteiler, Komparatoren, Hysterese und echte Praxisprobleme wie Korrosion auf einmal näherbringt. Wenn du die Platte nur während der Messung versorgst und die Schwellwerte nach deinen eigenen Messungen einstellst, leistet er dir lange gute Dienste. In der BlueGrays-App findest du Schritt-für-Schritt-Projekte mit Schaltplänen und Code, die Bauteile aus diesem Artikel nutzen – etwa Buzzer, Servomotor, eine smarte Bewässerungsstation und einen ESP32-Alarm mit Telegram –, und kannst den Regensensor ganz einfach in diese Projekte einbauen.