Bauteile · 10 Min. Lesezeit

Durchflusssensor Arduino: YF-S201 für Durchfluss und Liter

YF-S201 Durchflusssensor am Arduino: Impulse zählen, Formel 7,5 Hz = 1 L/min, Kalibrierung, Wasserzähler, Leckalarm sowie Code für ESP32 und Raspberry Pi Pico.

Ein Durchflusssensor misst, wie schnell Wasser durch ein Rohr fließt (Durchflussmenge) und wie viel insgesamt durchgeflossen ist, und er gehört zu den Messbauteilen, die sich mit einem Arduino am leichtesten auslesen lassen. Der in Hobbyprojekten verbreitetste Typ, der YF-S201, passt auf ein Halbzollrohr und erzeugt umso häufiger Impulse, je mehr Wasser hindurchfließt. Durch Zählen dieser Impulse berechnest du, wie viele Liter pro Minute fließen, wie viele Liter eine Dusche oder ein Bewässerungszyklus verbraucht hat und ob irgendwo im Rohr ein Leck ist.

In dieser Anleitung lernst du, wie Turbine und Hall-Sensor im Inneren arbeiten, woher die Formel 7,5 Hz = 1 L/min stammt, wie du den Sensor sicher an Arduino Uno, ESP32 und Raspberry Pi Pico anschließt, wie du Impulse per Interrupt zählst und Durchfluss und Gesamtliter berechnest. Danach kalibrierst du den Sensor mit einem Messbecher, baust einen Leckalarm, verfolgst den Wasserverbrauch mit einem ESP32 über WLAN und erhältst praktische Hinweise zu Größe, Druck und Einbau.

Was ist ein Durchflusssensor und wie funktioniert er?

Im Kunststoffgehäuse des YF-S201 sitzt eine kleine Turbine (Flügelrad), die sich mit dem Wasserstrom dreht. Auf der Turbine sitzt ein Magnet, und in einer abgedichteten Kammer außerhalb des Wasserwegs befindet sich ein Hall-Sensor. Bei jeder Umdrehung läuft der Magnet am Hall-Sensor vorbei, und am Ausgang entsteht ein Rechteckimpuls. Je schneller das Wasser fließt, desto schneller dreht sich die Turbine und desto höher ist die Impulsfrequenz. So wird das Wasser gemessen, ohne die Elektronik je zu berühren. Wie Hall-Sensoren auf Magnete reagieren, erklärt der Artikel Hall-Sensor ausführlich.

EigenschaftYF-S201 (typische Werte)
Messbereich1–30 L/min
ImpulsbeziehungF (Hz) = 7,5 × Q (L/min)
Impulse pro LiterEtwa 450 Impulse/L (ein Impuls etwa 2,2 mL)
Versorgungsspannung5–18 V DC (in Hobbyprojekten 5 V)
StromHöchstens etwa 15 mA (bei 5 V)
AusgangRechteckimpulse, etwa 50 % Tastverhältnis, auf Versorgungspegel
GenauigkeitOhne Kalibrierung etwa ±10 %
AnschlussG1/2 (Halbzoll) Außengewinde
Maximaler Druck1,75 MPa (manche Händler nennen 2,0 MPa)
LeitungenRot: VCC, Schwarz: GND, Gelb: Signal

Was bedeutet die Formel 7,5 Hz = 1 L/min?

Die Herstellerangabe F = 7,5 × Q besagt, dass der Sensor bei einem Durchfluss von 1 Liter pro Minute 7,5 Impulse pro Sekunde liefert. Daraus ergeben sich zwei praktische Formeln: für den Durchfluss Q (L/min) = F / 7,5, für die Gesamtmenge Liter = Impulse gesamt / 450. Die Zahl 450 ist das Produkt aus 7,5 Impulsen pro Sekunde und den 60 Sekunden einer Minute. Zählst du zum Beispiel 60 Impulse in einer Sekunde, beträgt der Durchfluss 60 / 7,5 = 8 L/min; zählst du während einer Dusche 22.500 Impulse, wurden 22.500 / 450 = 50 Liter verbraucht.

Durchfluss (L/min)Frequenz (Hz)Impulse in 1 SekundeZeit für 1 L
1 (Untergrenze)7,57–860 Sekunden
5 (schwach laufender Hahn)37,537–3812 Sekunden
10 (Hahn voll offen)75756 Sekunden
201501503 Sekunden
30 (Obergrenze)2252252 Sekunden

Die erste Zeile zeigt eine wichtige Grenze: Werden in einem 1-Sekunden-Fenster nur 7–8 Impulse gezählt, verschiebt ein einziger Impuls Fehler das Ergebnis um etwa 13 %. Für einen ruhigeren Wert bei geringem Durchfluss verlängerst du das Fenster auf 2–5 Sekunden oder bildest den Mittelwert der letzten Messungen. Bei der Gesamtliter-Berechnung tritt das Problem nicht auf, weil sich die Impulse verlustfrei aufsummieren.

Durchflusssensor anschließen

SensorleitungArduino UnoESP32Raspberry Pi Pico
Rot (VCC)5VVIN (5 V vom USB)VBUS (5 V vom USB)
Schwarz (GND)GNDGNDGND
Gelb (Signal)D2 (direkt)GPIO 27, über SpannungsteilerGP15, über Spannungsteiler
TeilerwiderständeNicht nötig10 kΩ (Signal–Pin) + 20 kΩ (Pin–GND)10 kΩ (Signal–Pin) + 20 kΩ (Pin–GND)
High-Pegel am Pin5 VEtwa 3,3 VEtwa 3,3 V
Wird der YF-S201 mit 5 V versorgt, liegt auch sein Signalausgang bei 5 V. Die Pins von ESP32 und Pico vertragen höchstens 3,3 V; die gelbe Leitung direkt anzuschließen, kann den Pin mit der Zeit beschädigen. Ein Spannungsteiler aus 10 kΩ und 20 kΩ senkt 5 V auf 5 × 20 / 30 ≈ 3,3 V. Die Werte für deine eigenen Widerstände prüfst du mit dem Spannungsteiler-Rechner, das Prinzip erklärt der Artikel Spannungsteiler.

Am Uno muss das Signal an einen Interrupt-Pin: Bei Uno und Nano unterstützen nur D2 und D3 externe Interrupts. Manche Sensorplatinen haben einen Open-Collector-Ausgang ohne eigenen Pull-up-Widerstand; deshalb ist INPUT_PULLUP im Uno-Code für beide Sensorarten sicher. Bei langen Kabeln (einige Meter) führst du die Signalleitung abseits von Motor- und Pumpenkabeln und ergänzt bei Bedarf einen 100-nF-Kondensator zwischen Signal und GND, um Störimpulse zu verringern.

Warum zählt man Impulse per Interrupt?

Bei 30 L/min liefert der Sensor 225 Impulse pro Sekunde, also alle 4,4 Millisekunden einen. Ein Programm, das den Pin in loop() mit digitalRead abfragt, verpasst einen Teil davon, sobald ein delay(), eine LCD-Aktualisierung oder eine WLAN-Aktion dazwischenkommt, und das Ergebnis fällt unbemerkt zu niedrig aus. Ein Interrupt lässt den Prozessor in dem Moment, in dem sich der Pegel ändert, alles stehen und liegen und eine kleine Funktion ausführen; egal was das Programm gerade tut, kein Impuls geht verloren. Die Interrupt-Funktion sollte so kurz wie möglich sein: Sie erhöht nur den Zähler, Berechnungen und Ausgaben passieren in loop(). Details findest du im Artikel Arduino Interrupts.

Arduino-Code: Durchfluss und Gesamtliter

  1. Bau den Sensor so ein, dass das Wasser in Richtung des Pfeils auf dem Gehäuse fließt.
  2. Verbinde die rote Leitung mit 5V, die schwarze mit GND und die gelbe mit D2.
  3. Lade den folgenden Code hoch und öffne den seriellen Monitor mit 9600 Baud.
  4. Dreh den Hahn langsam auf; der Durchfluss steigt und die Gesamtliter summieren sich.
  5. Schließt du den Hahn, fällt der Durchfluss auf null, die Gesamtliter bleiben beim letzten Wert.
C++ (Arduino IDE)
1// YF-S201 su akış sensörü: debi ve toplam litre / flow rate and total litres
2const byte SENSOR_PIN = 2;          // sarı kablo, kesme pini / yellow wire, interrupt pin
3const float DARBE_LITRE = 450.0;    // 1 L = 450 darbe, kalibrasyonla değiştir / pulses per litre, calibrate
4
5volatile unsigned long darbe = 0;   // kesmede artan sayaç / counter incremented in the ISR
6unsigned long toplamDarbe = 0;      // açılıştan beri toplam / total since power-up
7unsigned long oncekiZaman = 0;
8
9void darbeSay() {                   // kesme fonksiyonu: kısa tut / ISR: keep it short
10  darbe++;
11}
12
13void setup() {
14  Serial.begin(9600);
15  pinMode(SENSOR_PIN, INPUT_PULLUP);
16  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), darbeSay, FALLING);
17}
18
19void loop() {
20  unsigned long simdi = millis();
21  if (simdi - oncekiZaman >= 1000) {          // saniyede bir hesapla / compute once a second
22    noInterrupts();                           // sayacı güvenle kopyala / copy the counter safely
23    unsigned long sayi = darbe;
24    darbe = 0;
25    interrupts();
26
27    float sure = (simdi - oncekiZaman) / 1000.0;   // gerçek pencere (s) / real window (s)
28    oncekiZaman = simdi;
29    toplamDarbe += sayi;
30
31    float debi = (sayi / sure) * 60.0 / DARBE_LITRE;   // L/dk = Hz * 60 / 450 = Hz / 7,5
32    float litre = toplamDarbe / DARBE_LITRE;
33
34    Serial.print(F("Debi / Flow: "));
35    Serial.print(debi, 2);
36    Serial.print(F(" L/dk   Toplam / Total: "));
37    Serial.print(litre, 3);
38    Serial.println(F(" L"));
39  }
40}
ZeileWas macht sie?
volatile unsigned long darbeZähler, den Interrupt und loop() teilen; volatile verhindert, dass der Compiler den Wert zwischenspeichert
attachInterrupt(..., FALLING)darbeSay() läuft bei jedem Wechsel des Signals von HIGH auf LOW
noInterrupts() / interrupts()Sperrt Interrupts kurz, damit keiner den 4-Byte-Zähler mitten im Lesen verfälscht
sure = (simdi - oncekiZaman) / 1000.0Rechnet mit dem echten Zeitfenster, auch wenn es nicht genau 1000 ms sind
(sayi / sure) * 60 / DARBE_LITREWandelt die Frequenz in L/min um; bei DARBE_LITRE = 450 entspricht das F / 7,5
toplamDarbe / DARBE_LITREBerechnet die Gesamtliter aus den aufsummierten Impulsen
Statt 7,5 die Konstante DARBE_LITRE in der Formel zu verwenden, reduziert die Kalibrierung auf eine Zeile: Du trägst den für deinen Sensor ermittelten Wert Impulse pro Liter ein, und Durchfluss und Gesamtliter stimmen gemeinsam. Damit die Summe einen Stromausfall übersteht, kannst du sie im EEPROM speichern; aber nicht bei jedem Impuls, sondern zum Beispiel alle 10 Liter, damit die Zellen nicht verschleißen.

Durchflusssensor kalibrieren

450 Impulse/L ist der Mittelwert des Herstellers; am echten Sensor sind 5–10 % Abweichung durch Einbaulage, Wasserdruck, Rohrdurchmesser und Durchfluss normal. Für die Kalibrierung reicht ein Gefäß mit bekanntem Volumen: ein Messbecher mit 1 oder 2 Litern, besser ein 5-Liter-Kanister. Am genauesten ist der Test im späteren Aufbau bei ungefähr gleichem Durchfluss, denn die Umdrehungen pro Liter unterscheiden sich bei niedrigem und hohem Durchfluss leicht.

  1. Lade den Kalibrier-Code unten hoch und öffne den seriellen Monitor (Zeilenende: Neue Zeile).
  2. Halte das Rohrende über den leeren Messbecher und setze den Zähler mit r im seriellen Monitor zurück.
  3. Öffne den Hahn mit deinem normalen Durchfluss und schließe ihn, wenn der Becher genau die Markierung erreicht.
  4. Gib das Volumen des Bechers in Litern ein (z. B. 2); der Code berechnet die Impulse pro Liter.
  5. Wiederhole das mindestens dreimal und trage den Mittelwert in die Konstante DARBE_LITRE des Hauptcodes ein.
C++ (Arduino IDE)
1// YF-S201 kalibrasyonu: litre başına darbe sayısını bul / find pulses per litre
2const byte SENSOR_PIN = 2;
3volatile unsigned long darbe = 0;
4
5void darbeSay() {
6  darbe++;
7}
8
9void setup() {
10  Serial.begin(9600);
11  pinMode(SENSOR_PIN, INPUT_PULLUP);
12  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), darbeSay, FALLING);
13  Serial.println(F("r: sifirla / reset, sayi: kap hacmi litre / container volume in litres"));
14}
15
16void loop() {
17  if (Serial.available()) {
18    String satir = Serial.readStringUntil('\n');   // kısa ömürlü, tek seferlik / short-lived, one-off
19    satir.trim();
20    noInterrupts();
21    unsigned long sayi = darbe;
22    interrupts();
23    if (satir == "r") {
24      noInterrupts();
25      darbe = 0;
26      interrupts();
27      Serial.println(F("Sayac sifirlandi / Counter reset"));
28    } else {
29      float litre = satir.toFloat();
30      if (litre > 0) {
31        Serial.print(F("Darbe / Pulses: "));
32        Serial.print(sayi);
33        Serial.print(F("   Darbe/L: "));
34        Serial.println(sayi / litre, 1);       // DARBE_LITRE için yeni değer / new DARBE_LITRE
35      }
36    }
37  }
38}

Hast du beim Füllen des 2-Liter-Bechers zum Beispiel 931 Impulse gezählt, liegt der Faktor deines Sensors bei 931 / 2 = 465,5 Impulsen/L; mit 450 würde er pro 100 Liter etwa 3,4 Liter zu viel anzeigen. Um auch den Durchfluss zu prüfen, stoppst du die Füllzeit: Sind 2 Liter in 15 Sekunden voll, beträgt der echte Durchfluss 2 / 15 × 60 = 8 L/min, und du kannst ihn mit dem Wert im seriellen Monitor vergleichen.

Wasserzähler und Leckalarm

Die nützlichste Aufgabe eines Durchflusssensors ist es, unerwarteten Durchfluss zu erkennen. Fließt Wasser, während niemand zu Hause etwas verbraucht, oder bleibt ein Hahn minutenlang offen, deutet das auf ein Leck oder einen vergessenen Schlauch hin. Der folgende Code lässt einen Summer ertönen und schließt über ein Relais ein Magnetventil, das das Wasser absperrt, wenn der Durchfluss ohne Unterbrechung eine festgelegte Zeit oder eine festgelegte Menge überschreitet. Ein Tastendruck setzt den Alarm zurück und öffnet das Ventil wieder.

C++ (Arduino IDE)
1// Sızıntı alarmı: uzun süreli ya da aşırı akışta vanayı kapat
2// Leak alarm: close the valve on long or excessive flow
3const byte SENSOR_PIN = 2;
4const byte ROLE_PIN = 7;            // selenoid vana rölesi (HIGH = vana açık) / valve relay (HIGH = open)
5const byte BUZZER_PIN = 8;
6const byte BUTON_PIN = 4;           // alarmı sıfırla / reset alarm
7const float DARBE_LITRE = 450.0;
8const unsigned long MAKS_SURE = 20UL * 60UL * 1000UL;   // 20 dk kesintisiz akış / 20 min continuous flow
9const float MAKS_LITRE = 150.0;                          // tek seferde en fazla / max per session
10
11volatile unsigned long darbe = 0;
12unsigned long akisBaslangic = 0;    // akışın başladığı an / when flow started
13unsigned long sonAkis = 0;          // son darbe görülen an / last time flow was seen
14float oturumLitre = 0;
15bool alarmVar = false;
16unsigned long oncekiZaman = 0;
17
18void darbeSay() {
19  darbe++;
20}
21
22void setup() {
23  Serial.begin(9600);
24  pinMode(SENSOR_PIN, INPUT_PULLUP);
25  pinMode(ROLE_PIN, OUTPUT);
26  pinMode(BUZZER_PIN, OUTPUT);
27  pinMode(BUTON_PIN, INPUT_PULLUP);
28  digitalWrite(ROLE_PIN, HIGH);     // vana açık / valve open
29  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), darbeSay, FALLING);
30}
31
32void loop() {
33  unsigned long simdi = millis();
34  if (simdi - oncekiZaman >= 1000) {
35    oncekiZaman = simdi;
36    noInterrupts();
37    unsigned long sayi = darbe;
38    darbe = 0;
39    interrupts();
40
41    if (sayi > 2) {                           // gerçek akış var / real flow present
42      if (simdi - sonAkis > 10000) {          // 10 s'den uzun aradan sonra yeni oturum / new session
43        akisBaslangic = simdi;
44        oturumLitre = 0;
45      }
46      sonAkis = simdi;
47      oturumLitre += sayi / DARBE_LITRE;
48      if (!alarmVar && (simdi - akisBaslangic > MAKS_SURE || oturumLitre > MAKS_LITRE)) {
49        alarmVar = true;
50        digitalWrite(ROLE_PIN, LOW);          // vanayı kapat / close the valve
51        Serial.println(F("SIZINTI ALARMI / LEAK ALARM"));
52      }
53    }
54  }
55  if (alarmVar) {
56    tone(BUZZER_PIN, 2000, 200);              // aralıklı bip / intermittent beep
57    delay(400);
58    if (digitalRead(BUTON_PIN) == LOW) {      // sıfırla / reset
59      alarmVar = false;
60      oturumLitre = 0;
61      sonAkis = 0;
62      digitalWrite(ROLE_PIN, HIGH);
63      Serial.println(F("Alarm sifirlandi / Alarm reset"));
64    }
65  }
66}

Wähle die Schwellen passend zu deiner Nutzung: Eine Dusche läuft 5–10 Minuten mit 8–12 L/min und verbraucht 50–100 Liter, das Gießen eines Gartens kann deutlich länger dauern. Magnetventile arbeiten meist mit 12 V und werden über ein Relaismodul aus einem eigenen Netzteil versorgt; die Verdrahtung zeigt der Artikel Relaismodul. Bedenke auch: Ein tropfender Hahn oder ein undichter Spülkasten verliert ein paar Liter pro Stunde und liegt weit unter der Untergrenze von 1 L/min des YF-S201; solche kleinen Lecks sieht der Sensor nicht. Für sie ergänzt du eine zweite Prüfung, die nachts jeden Impuls protokolliert, oder einen auf den Boden gelegten Wasserstandssensor.

Wasserverbrauch mit dem ESP32 erfassen

ESP32-Entwicklungsboard
Der ESP32 kann die Impulse des Durchflusssensors zählen und gleichzeitig über WLAN eine Webseite bereitstellen.

Jeder GPIO-Pin des ESP32 unterstützt Interrupts, und dank WLAN verfolgst du die Messung auf dem Handy. Der folgende Code liest den Sensor an GPIO 27 (über den Teiler), zeigt aktuellen Durchfluss und Gesamtliter auf einer Webseite, die sich alle zwei Sekunden aktualisiert, und speichert die Summe mit Preferences im Flash, sodass der Zähler auch nach einem Stromausfall weiterzählt. Um den Flash zu schonen, wird nur gespeichert, wenn sich die Summe um mindestens 1 Liter geändert hat, und höchstens einmal pro Minute.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4
5const char* AG_ADI = "AG_ADIN";          // Wi-Fi ağ adı / network name
6const char* SIFRE = "SIFREN";            // Wi-Fi şifresi / password
7const int SENSOR_PIN = 27;               // 10k + 20k bölücü üzerinden / through a 10k + 20k divider
8const float DARBE_LITRE = 450.0;
9
10volatile uint32_t darbe = 0;
11portMUX_TYPE kilit = portMUX_INITIALIZER_UNLOCKED;
12uint32_t toplamDarbe = 0;
13uint32_t kayitliDarbe = 0;
14float debi = 0;
15unsigned long oncekiOlcum = 0, oncekiKayit = 0;
16
17WebServer sunucu(80);
18Preferences ayarlar;
19
20void IRAM_ATTR darbeSay() {              // kesme RAM'de çalışır / ISR runs from IRAM
21  portENTER_CRITICAL_ISR(&kilit);
22  darbe++;
23  portEXIT_CRITICAL_ISR(&kilit);
24}
25
26void anaSayfa() {
27  char sayfa[300];
28  snprintf(sayfa, sizeof(sayfa),
29           "<html><head><meta charset='utf-8'><meta http-equiv='refresh' content='2'></head><body>"
30           "<h2>Su sayaci / Water meter</h2><p>Debi / Flow: %.2f L/dk</p><p>Toplam / Total: %.2f L</p></body></html>",
31           debi, toplamDarbe / DARBE_LITRE);
32  sunucu.send(200, "text/html", sayfa);
33}
34
35void sifirla() {                         // /sifirla adresi toplamı sıfırlar / resets the total
36  toplamDarbe = 0;
37  kayitliDarbe = 0;
38  ayarlar.putUInt("toplam", 0);
39  sunucu.send(200, "text/plain", "Sifirlandi / Reset");
40}
41
42void setup() {
43  Serial.begin(115200);
44  pinMode(SENSOR_PIN, INPUT);
45  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), darbeSay, FALLING);
46  ayarlar.begin("su", false);
47  toplamDarbe = ayarlar.getUInt("toplam", 0);   // kaldığı yerden devam / resume the total
48  kayitliDarbe = toplamDarbe;
49
50  WiFi.begin(AG_ADI, SIFRE);
51  while (WiFi.status() != WL_CONNECTED) {
52    delay(300);
53    Serial.print(".");
54  }
55  Serial.print("\nIP: ");
56  Serial.println(WiFi.localIP());
57  sunucu.on("/", anaSayfa);
58  sunucu.on("/sifirla", sifirla);
59  sunucu.begin();
60}
61
62void loop() {
63  sunucu.handleClient();
64  unsigned long simdi = millis();
65  if (simdi - oncekiOlcum >= 1000) {
66    float sure = (simdi - oncekiOlcum) / 1000.0;
67    oncekiOlcum = simdi;
68    portENTER_CRITICAL(&kilit);
69    uint32_t sayi = darbe;
70    darbe = 0;
71    portEXIT_CRITICAL(&kilit);
72    toplamDarbe += sayi;
73    debi = (sayi / sure) * 60.0 / DARBE_LITRE;
74  }
75  // en az 1 L değiştiyse ve 60 s geçtiyse kaydet / save if >= 1 L changed and 60 s passed
76  if (toplamDarbe - kayitliDarbe >= DARBE_LITRE && simdi - oncekiKayit >= 60000) {
77    ayarlar.putUInt("toplam", toplamDarbe);
78    kayitliDarbe = toplamDarbe;
79    oncekiKayit = simdi;
80  }
81}

Nach dem Hochladen gibst du die im seriellen Monitor angezeigte IP-Adresse einfach im Browser eines Handys im selben Netz ein. Beim ESP32 bekommt die Interrupt-Funktion IRAM_ATTR, weil der Interrupt auch während eines Flash-Zugriffs laufen können muss; den Zähler schützt portENTER_CRITICAL statt noInterrupts(), weil der ESP32 zwei Kerne hat. Möchtest du Tagesdiagramme oder eine Benachrichtigung beim Überschreiten einer Schwelle, schickst du dieselbe Messung an MQTT und Home Assistant oder an einen Telegram-Bot.

MicroPython-Code für den Raspberry Pi Pico

Auch beim Pico unterstützt jeder GPIO Interrupts. Versorge den Sensor mit 5 V aus VBUS und schließe das Signal über einen 10-kΩ-+-20-kΩ-Teiler an GP15 an. In MicroPython wird die Interrupt-Funktion mit Pin.irq zugewiesen; machine.disable_irq() sperrt Interrupts kurz, während der Zähler gelesen wird.

MicroPython
1from machine import Pin
2import machine
3import time
4
5DARBE_LITRE = 450                      # kalibrasyonla değiştir / change after calibration
6sayac = 0
7toplam_darbe = 0
8
9def darbe_say(pin):                    # kesme fonksiyonu / interrupt handler
10    global sayac
11    sayac += 1
12
13sensor = Pin(15, Pin.IN)               # bölücü üzerinden GP15 / GP15 through the divider
14sensor.irq(trigger=Pin.IRQ_FALLING, handler=darbe_say)
15
16onceki = time.ticks_ms()
17while True:
18    time.sleep_ms(1000)
19    simdi = time.ticks_ms()
20    sure = time.ticks_diff(simdi, onceki) / 1000   # gerçek pencere (s) / real window (s)
21    onceki = simdi
22    durum = machine.disable_irq()      # sayacı güvenle al / read the counter safely
23    n = sayac
24    sayac = 0
25    machine.enable_irq(durum)
26    toplam_darbe += n
27    debi = (n / sure) * 60 / DARBE_LITRE
28    print("Debi: {:.2f} L/dk  Toplam: {:.3f} L".format(debi, toplam_darbe / DARBE_LITRE))

Einsatz in Pumpen- und Bewässerungssystemen

6-V-Mini-Tauchpumpe
Mini-Tauchpumpen fördern meist weniger als 1–2 Liter pro Minute; für diesen Bereich brauchst du einen kleineren Durchflusssensor als den YF-S201.

In Bewässerungsprojekten bestätigt ein Durchflusssensor außerdem, dass die Pumpe wirklich Wasser fördert. Kommen wenige Sekunden nach dem Einschalten keine Impulse, ist der Tank leer, der Schlauch verstopft oder die Pumpe defekt; sie dann abzuschalten, verhindert Trockenlauf und Durchbrennen. Die kleinen 3–6-V-Tauchpumpen aus Hobbysets fördern aber oft weniger als 1 L/min und liegen außerhalb des Messbereichs des YF-S201. Nimm in solchen Aufbauten einen kleinen Sensor wie den YF-S401 für 0,3–6 L/min. Die Pumpenverdrahtung zeigt Arduino Wasserpumpe, ein komplettes System das smarte Gewächshausprojekt.

Größe, Druck und Modellwahl

ModellAnschlussMessbereichImpulsbeziehungImpulse pro Liter
YF-S401Dünner Schlauch (etwa 6 mm)0,3–6 L/minF = 98 × QEtwa 5880
YF-S201G1/2 (Halbzoll), Kunststoff1–30 L/minF = 7,5 × QEtwa 450
YF-B1G1/2, Messinggehäuse1–25 L/minF = 11 × QEtwa 660
FS300AG3/4 (Dreiviertelzoll)1–60 L/minF = 5,5 × QEtwa 330
  • Nach Rohrgröße wählen: Hahn- und Duschleitungen im Haus sind meist Halbzoll; der YF-S201 passt ohne Adapter. Ein kleiner Sensor an einer größeren Leitung drosselt den Durchfluss.
  • Druck: Der Leitungsdruck im Haus liegt meist bei 2–5 bar (0,2–0,5 MPa), weit unter der Grenze von 1,75 MPa des YF-S201. Trotzdem setzt die Turbine dem Wasser Widerstand entgegen und erzeugt bei hohem Durchfluss einen kleinen Druckverlust.
  • Flussrichtung und Lage: Halte dich an den Pfeil auf dem Gehäuse, bau den Sensor möglichst waagerecht ein und lass davor einige Dutzend Zentimeter gerades Rohr. Direkt hinter einem Bogen weicht der Sensor wegen Verwirbelungen stärker ab.
  • Luftblasen und Ablagerungen: Luft dreht die Turbine frei und erzeugt falsche Impulse, Sand und Kalk bremsen sie. Setz bei Bedarf einen Filter vor den Sensor.
  • Kunststoffgehäuse: Das Nylongehäuse des YF-S201 ist gegen heißes Wasser und Stöße weniger robust als Messingmodelle. Die meisten günstigen Modelle haben auch keine Trinkwasserzulassung; wähle für eine Trinkwasserleitung ein lebensmittelechtes Modell.
  • Abdichtung: Wickle Teflonband auf die Gewinde, aber achte darauf, dass kein Band in die Turbinenkammer gelangt. Zieh den Sensor von Hand fest; mit einer Zange kann das Kunststoffgewinde reißen.

Projektideen mit einem Durchflusssensor

  • Duschzähler: Zeig auf einem I2C-LCD, wie viele Liter eine Dusche verbraucht hat, und warne mit einem Summer, wenn eine festgelegte Menge überschritten wird.
  • Smarte Bewässerung: Starte die Pumpe bei trockener Erde, miss die abgegebene Wassermenge in Litern und stoppe bei der Zielmenge. Für die Feuchtemessung siehe Bodenfeuchtesensor.
  • Hauswasserzähler: Protokolliere mit einem ESP32 den täglichen, wöchentlichen und monatlichen Verbrauch und sende eine Benachrichtigung, wenn nachts Wasser fließt.
  • Pumpenschutz: Fließt bei laufender Pumpe nichts, schalte sie nach einigen Sekunden ab und zeige den Fehler mit einer LED an.
  • Aquarienfilter überwachen: Beobachte den Durchfluss, der mit verstopfendem Filter sinkt, und melde, wann gereinigt werden muss.
  • Dosierautomat: Bau eine automatische Abfüllstation, die ein Gefäß mit genau 2 Litern füllt und das Ventil schließt.

Häufige Fehler und ihre Lösungen

SymptomMögliche UrsacheLösung
Durchfluss immer 0Signal an einem Pin ohne Interrupt oder Sensor verkehrt eingebautAm Uno D2 oder D3 nutzen; Flussrichtung mit dem Pfeil am Gehäuse vergleichen
Impulse, obwohl kein Wasser fließtStörungen auf langem Kabel oder offener PinINPUT_PULLUP nutzen, 100 nF zwischen Signal und GND, Kabel von Motorleitungen fernhalten
Gemessene Liter 10 % höher oder niedriger als realSensor nicht kalibriertMit Messbecher kalibrieren, DARBE_LITRE anpassen
Wert springt bei geringem DurchflussZu wenige Impulse im 1-Sekunden-FensterFenster auf 2–5 Sekunden verlängern oder mitteln
ESP32 startet zufällig neu oder Pin defekt5-V-Signal direkt an einem 3,3-V-Pin10-kΩ-+-20-kΩ-Spannungsteiler oder Pegelwandler verwenden
Gesamtliter nach Stromausfall wegZähler nur im RAMSumme regelmäßig im EEPROM oder in Preferences speichern
Bei kleiner Pumpe gar keine ImpulseDurchfluss unter 1 L/minSensor für geringen Durchfluss wie den YF-S401 verwenden
Mach bei jedem neuen Aufbau zuerst ein paar Messungen mit dem Kalibrier-Code und notiere die Ergebnisse. Derselbe Sensor kann waagerecht und senkrecht eingebaut oder bei anderem Druck einige Prozent abweichen; am zuverlässigsten ist es, dort zu kalibrieren, wo der Sensor am Ende sitzt.

Der Durchflusssensor YF-S201 ist ein ideales Bauteil, um das Zählen von Impulsen mit Interrupts zu lernen, und liefert mit sauberer Kalibrierung in vielen Projekten verlässliche Werte, vom Hauswasserzähler bis zur automatischen Bewässerung. In der BlueGrays-App findest du die smarte Bewässerungsstation und Messprojekte mit LCD samt Schritt-für-Schritt-Schaltplan und Code, und kannst den Durchflusssensor dort leicht ergänzen.

Häufige Fragen

Wie funktioniert ein Durchflusssensor?

Eine Turbine im Sensor dreht sich mit dem Wasserstrom, und ihr Magnet läuft bei jeder Umdrehung an einem Hall-Sensor vorbei. Der Hall-Sensor erzeugt dabei jedes Mal einen Impuls, und je schneller das Wasser fließt, desto höher ist die Impulsfrequenz. Der Arduino zählt diese Impulse und berechnet daraus Durchfluss und Gesamtliter.

Wie viele Impulse pro Liter liefert der YF-S201?

Die Herstellerformel lautet F = 7,5 × Q, er liefert also bei 1 L/min 7,5 Hz. Das entspricht etwa 450 Impulsen pro Liter. Ein echter Sensor kann 5–10 % abweichen, deshalb solltest du ihn mit einem Messbecher kalibrieren und deinen eigenen Faktor bestimmen.

Kann man einen Durchflusssensor direkt an einen ESP32 anschließen?

Mit 5 V versorgt liefert der YF-S201 ein 5-V-Signal, das für die 3,3-V-Pins des ESP32 zu hoch ist. Füge in die Signalleitung einen Spannungsteiler aus 10 kΩ und 20 kΩ oder einen Pegelwandler ein. Die Versorgung des Sensors kann vom VIN-Pin des ESP32 kommen.

Warum kommt der Durchflusssensor an einen Interrupt-Pin?

Bei hohem Durchfluss liefert der Sensor über 200 Impulse pro Sekunde, und ein Programm, das den Pin in loop() abfragt, verpasst bei Pausen oder Display-Updates Impulse. Ein Interrupt führt bei jedem Impuls sofort eine kleine Funktion aus, sodass keiner verloren geht. Beim Arduino Uno sind die Interrupt-Pins D2 und D3.

Kann ein Durchflusssensor Lecks erkennen?

Große Lecks, etwa ein lange offener Hahn oder Schlauch, erkennt man leicht über die Dauer des ununterbrochenen Durchflusses und die verbrauchten Liter. Sehr kleine Lecks wie ein tropfender Hahn liegen aber unter der Untergrenze von 1 L/min des YF-S201 und bleiben unsichtbar. Dafür braucht man einen Wassermelder am Boden oder einen empfindlicheren Zähler.

Auf welches Rohr passt der YF-S201?

Der YF-S201 hat an beiden Enden ein G1/2-Außengewinde, also Halbzoll, und passt direkt auf die meisten Hahn- und Duschleitungen im Haus. Für dünnere Schläuche gibt es Modelle wie den YF-S401, für Dreiviertelzoll-Leitungen den FS300A. Teflonband auf das Gewinde und handfestes Anziehen genügen.

Alle Projekte ansehen
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

Temperatur und Luftfeuchtigkeit mit DHT11

Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

4.7(47)
83
HC-SR04 Abstandsmessung (serielle Anzeige)
AR-27Anfänger

HC-SR04 Abstandsmessung (serielle Anzeige)

Der Sensor HC-SR04 funktioniert wie eine Fledermaus, die im Dunkeln ihren Weg findet: Er sendet einen Ton, den du nicht hörst, lauscht auf das Echo und misst, wie weit der Gegenstand vor ihm entfernt…

4.6(50)
82
Intelligente Bewässerungsstation
AR-83Fortgeschritten
Premium

Intelligente Bewässerungsstation

Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

5.0(42)
57
Digitales Voltmeter mit LCD-Anzeige
AR-56Mittel
Premium

Digitales Voltmeter mit LCD-Anzeige

Finde mit einem selbstgebauten Messgerät heraus, wie viel Spannung eine Batterie oder ein Netzteil liefert.

4.5(27)
36
ESP32 I2C-LCD-Display (16×2)
ES-17Mittel
Premium

ESP32 I2C-LCD-Display (16×2)

In diesem Projekt schließen wir ein 16x2-Zeichen-LCD über I2C an den ESP32 an und zeigen Text an. Dank I2C reichen 2 Datenpins (SDA und SCL) statt der 6+ Pins einer klassischen Parallelverbindung. Der Code schreibt eine feste Nachricht in die erste Zeile und einen sekündlich steigenden Zähler in die zweite. Beim Start gibt ein I2C-Scanner die Adresse des Displays im Serial Monitor aus (meist 0x27 oder 0x3F).

4.9(23)
40
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

ESP32-WLAN-STA-Verbindung (mit LCD-Display)

In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

4.4(21)
38