Bauteile · 10 Min. Lesezeit

Schwimmerschalter Arduino: Pumpe mit Float Switch steuern

Schwimmerschalter am Arduino anschließen: Reed-Kontakt, NO/NC, Pull-up-Auslesen und Pumpe stoppen, wenn der Tank voll ist. Code für Uno, ESP32, Pico.

Ein Schwimmerschalter (Float Switch) ist mit dem Arduino der einfachste und zuverlässigste Weg, um zu erkennen, ob ein Wassertank, ein Aquarium oder ein Bewässerungsbehälter voll oder leer ist. Im Inneren stecken ein Schwimmer mit Magnet und ein Reed-Kontakt in einem Glasröhrchen: Steigt der Wasserstand, hebt er den Schwimmer an und der Kontakt schließt; sinkt das Wasser, öffnet er wieder. Elektronisch ist der Sensor also ein Taster, der vom Wasser gedrückt wird: Du legst ein Kabel an GND, das andere an einen Digitalpin und liest den Pin mit INPUT_PULLUP aus.

In diesem Beitrag lernst du den inneren Aufbau des Schwimmers kennen, den Unterschied zwischen NO- und NC-Montage, wie du das Flattern durch bewegtes Wasser per Software herausfilterst, und du baust Schritt für Schritt eine Schaltung mit zwei Schwimmern, die die Pumpe stoppt, sobald der Tank voll ist. Neben funktionierendem Code für Arduino Uno, ESP32 und Raspberry Pi Pico siehst du auch, wann der Schwimmerschalter besser ist als Sensoren mit leitenden Sonden, berührungslose oder Ultraschall-Füllstandssensoren.

Wasserstandssensor mit Schwimmer (Float Switch)
Vertikaler Schwimmerschalter: Schwimmer mit Magnet, Gehäuse mit Reed-Kontakt, Gewinde zur Montage und zwei Kabel.

Was ist ein Schwimmerschalter und wie funktioniert er?

Im hohlen Kunststoffgehäuse in der Mitte des Sensors sitzt ein kleines, mit Schutzgas gefülltes Glasröhrchen. Darin liegen zwei ferromagnetische Metallzungen dicht beieinander; das nennt man Reed-Kontakt. Im frei gleitenden Schwimmer auf dem Gehäuse steckt ein ringförmiger Magnet. Steigt das Wasser, schwimmt der Schwimmer auf und gleitet am Gehäuse entlang; kommt der Magnet auf Höhe des Reed-Kontakts, magnetisiert das Feld beide Zungen, sie ziehen sich an und der Stromkreis schließt. Entfernt sich der Magnet, trennt die Federwirkung die Zungen wieder und der Kreis öffnet.

Dieser Aufbau hat zwei große Vorteile. Erstens liegt der elektrische Kontakt komplett im geschlossenen Glasröhrchen; kein Metall berührt das Wasser, daher gibt es keine Korrosion durch Elektrolyse oder Verschmutzung wie bei Sensoren mit leitenden Sonden. Zweitens ist der Ausgang rein digital: offen oder geschlossen. Du brauchst weder Analogmessung noch Kalibrierung noch eine Bibliothek. Dafür kennt der Schwimmer nur einen einzigen Punkt; er kann nicht sagen, ob das Wasser 12 cm oder 18 cm hoch steht, sondern nur, ob der Pegel über oder unter dieser Linie liegt. Dasselbe Prinzip steckt in Tür- und Fenstersensoren; Details findest du im Beitrag Reed-Relais.

EigenschaftTypischer Wert (kleines vertikales Modell)
SensorelementReed-Kontakt + Ringmagnet im Schwimmer
AusgangTrockenkontakt (offen / geschlossen), 2 Kabel, ohne Polarität
KontakttypNO oder NC (durch Umdrehen des Schwimmers änderbar)
Max. Schaltleistung10 W
Max. Schaltspannung100 V DC
Max. Schaltstrom0,5 A
Kontaktwiderstand100 mΩ oder weniger
Material von Gehäuse und SchwimmerPP (Polypropylen)
Betriebstemperatur−10 … +85 °C
MontageGewindegehäuse, mit Mutter und Dichtung am Tankboden oder Deckel

NO- und NC-Montage: den Schwimmer umdrehen

Die meisten Sensoren arbeiten ab Werk als NO (Schließer, normalerweise offen): Ohne Wasser liegt der Schwimmer unten auf dem Haltering und der Kontakt ist offen; hebt das Wasser den Schwimmer an, schließt er. Der Magnet sitzt im Schwimmer nicht in der Mitte, sondern nahe an einem Ende. Wenn du den Sicherungsring am Gehäuseende entfernst und den Schwimmer umgedreht wieder aufsetzt, ändert sich die Position des Magneten relativ zum Reed-Kontakt und der Sensor wird zum NC (Öffner, normalerweise geschlossen): ohne Wasser geschlossen, mit Wasser offen. Beachte noch etwas: Auch wenn du den Sensor vom Tankboden nach oben oder vom Deckel nach unten hängend montierst, ändert sich die Ruhelage des Schwimmers. Stelle daher bei jedem Modell vor dem Einbau das Multimeter auf Durchgangsprüfung (Piepton), hebe und senke den Schwimmer von Hand und sieh dir das tatsächliche Verhalten an.

MontageOhne Wasser (Schwimmer unten)Mit Wasser (Schwimmer oben)Pin mit INPUT_PULLUP
NO (normalerweise offen)Kontakt offenKontakt geschlossenTrocken HIGH, nass LOW
NC (normalerweise geschlossen)Kontakt geschlossenKontakt offenTrocken LOW, nass HIGH
Bei Sicherheitsaufgaben wie einem Überlaufalarm solltest du die NC-Montage bevorzugen. Bei NC ist der Kontakt im Normalzustand geschlossen und der Pin liest LOW; steigt das Wasser, reißt ein Kabel oder wird ein Stecker gezogen, wird der Pin HIGH. So wird auch ein Defekt als Alarm erkannt, und die Pumpe läuft nicht weiter, als wäre nichts passiert, wenn der Sensor stillschweigend ausfällt.

Anschluss: Pins für Arduino Uno, ESP32 und Pico

Zwischen den beiden Kabeln des Schwimmers gibt es keine Polarität. Es reicht, ein Kabel an GND und das andere an einen Digitalpin zu legen und den internen Pull-up-Widerstand des Pins zu aktivieren; ein externer Widerstand ist nicht nötig. Bei offenem Kontakt zieht der Pull-up den Pin auf 5 V (beim ESP32 und Pico auf 3,3 V) und er liest HIGH; schließt der Kontakt, liegt der Pin direkt an GND und liest LOW. Der interne Pull-up des Uno liegt bei 20–50 kΩ; der Strom bei geschlossenem Kontakt beträgt nur 5 V / 30 kΩ ≈ 0,17 mA und belastet den Reed-Kontakt überhaupt nicht. Die Details zur Pull-up-Logik findest du im Beitrag Pull-up- und Pull-down-Widerstand. Die folgende Tabelle zeigt die Pins, die in allen weiteren Codebeispielen verwendet werden:

AnschlussArduino UnoESP32Raspberry Pi Pico
Oberer Schwimmer (Tank voll)D2GPIO 27GP2
Unterer Schwimmer (Tank leer)D3GPIO 26GP3
Andere Kabel der SchwimmerGNDGNDGND
Relaismodul IND7GPIO 23GP15
Aktiver Buzzer (+)D8GPIO 25GP16
Relaismodul VCC5VVIN (5 V)VBUS (5 V)
Schließe eine Pumpe oder ein Magnetventil nie direkt an die Kabel des Schwimmers an. Der Reed-Kontakt kleiner Modelle kann höchstens etwa 10 W und 0,5 A schalten (die Werte variieren je nach Produkt, prüfe das Etikett); der Anlaufstrom des Motors und der Lichtbogen beim Öffnen verschweißen die Zungen im Glasröhrchen in kurzer Zeit, und der Sensor meldet dauerhaft „voll“ oder „leer“. Der Schwimmer soll nur dem Mikrocontroller ein Signal geben, die Last schaltet ein Relais oder MOSFET. Führe auch niemals 230 V Netzspannung über den Schwimmer.

Schritt für Schritt: den Schwimmer zum ersten Mal auslesen

  1. Stelle das Multimeter auf Durchgangsprüfung, halte die Spitzen an die beiden Kabel des Schwimmers und verschiebe den Schwimmer von Hand auf und ab, um herauszufinden, ob er als NO oder NC arbeitet.
  2. Schließe eines der Kabel an den GND-Pin des Arduino und das andere an D2 an. Bei dünnen Kabeln löte die Enden an Jumperkabel oder nutze eine Klemme.
  3. Lade den folgenden Code hoch; er setzt den Pin auf INPUT_PULLUP, deshalb ist kein zusätzlicher Widerstand nötig.
  4. Öffne den Serial Monitor mit 9600 Baud.
  5. Drücke den Schwimmer mit dem Finger nach oben: Bei NO-Montage sollte die interne LED an D13 leuchten und im Fenster die Meldung „YUKSEK“ erscheinen. Lässt du los, sollte die LED ausgehen und „DUSUK“ erscheinen.
C++ (Arduino IDE)
1const int FLOAT_PIN = 2;                 // şamandıra kablosu / float switch wire
2const int LED_PIN = 13;                  // dahili LED / built-in LED
3const unsigned long DEBOUNCE_MS = 300;   // dalga filtresi / ripple filter
4
5int stableState;
6int lastReading;
7unsigned long lastChange = 0;
8
9void setup() {
10  Serial.begin(9600);
11  pinMode(FLOAT_PIN, INPUT_PULLUP);      // dahili pull-up / internal pull-up
12  pinMode(LED_PIN, OUTPUT);
13  delay(10);
14  stableState = digitalRead(FLOAT_PIN);
15  lastReading = stableState;
16  digitalWrite(LED_PIN, stableState == LOW ? HIGH : LOW);
17}
18
19void loop() {
20  int reading = digitalRead(FLOAT_PIN);
21  if (reading != lastReading) {          // değişim var, sayacı sıfırla / change, reset timer
22    lastReading = reading;
23    lastChange = millis();
24  }
25  if (millis() - lastChange >= DEBOUNCE_MS && reading != stableState) {
26    stableState = reading;               // 300 ms sabit kaldı / stable for 300 ms
27    if (stableState == LOW) {            // NO: kontak kapalı = su var / NO: closed = water
28      Serial.println(F("Seviye YUKSEK: su var / Level HIGH: water present"));
29      digitalWrite(LED_PIN, HIGH);
30    } else {
31      Serial.println(F("Seviye DUSUK: su yok / Level LOW: no water"));
32      digitalWrite(LED_PIN, LOW);
33    }
34  }
35}

Der wichtigste Teil des Codes ist das Debouncing (Entprellen). In einem Tank ist das Wasser nie ganz ruhig: Läuft die Pumpe, wird ein Hahn geöffnet oder Wasser nachgefüllt, wellt sich die Oberfläche, und der Schwimmer kann am Schwellenpunkt mehrmals pro Sekunde auf- und zuschalten. Der Code setzt den Timer bei jeder Änderung des Pinwerts zurück und übernimmt den neuen Wert erst, wenn er 300 ms lang unverändert bleibt. Das ist dieselbe Idee wie beim Tasterprellen, nur mit längerer Zeit. Bei sehr unruhigem Wasser kannst du die Zeit auf 1–2 Sekunden erhöhen. Da die Zeitmessung mit millis() erfolgt, wartet loop nie; warum, kannst du im Beitrag Unterschied zwischen millis und delay nachlesen.

Schaltung, die die Pumpe bei vollem Tank stoppt

Auch mit einem einzigen Schwimmer lässt sich eine Pumpe steuern, aber es gibt ein Problem: Liegt der Wasserstand genau am Schwellenwert, schaltet die Pumpe alle paar Sekunden ein und aus. Das belastet Pumpe und Relais. Die Lösung ist Hysterese, also zwei getrennte Schwellen. Du montierst einen Schwimmer im unteren und einen im oberen Teil des Tanks. Fällt das Wasser unter den unteren Schwimmer, läuft die Pumpe an, erreicht es den oberen, stoppt sie; im Bereich dazwischen behält die Pumpe ihren Zustand. Beträgt der Abstand zwischen den Schwimmern 15 cm und die Pumpe fördert 3 Liter pro Minute, sind das bei einem Tank mit 30×40 cm Grundfläche (1200 cm²) 18 Liter, und die Pumpe läuft jedes Mal etwa 6 Minuten am Stück. Der Code führt außerdem zwei Sicherheitsprüfungen durch: Wenn der obere Schwimmer nass, der untere aber trocken meldet, ist das physikalisch unmöglich, also liegt ein Kabel- oder Sensorfehler vor; läuft die Pumpe länger als erwartet, ist vielleicht die Quelle leer oder ein Schlauch abgegangen. In beiden Fällen stoppt die Pumpe und der Buzzer piept.

  • 2 Schwimmerschalter: für die untere und obere Schwelle; bei NO-Montage liefern beide im Wasser LOW.
  • 1-Kanal-Relaismodul: schaltet die Versorgung der Pumpe. Die meisten Module ziehen an, wenn IN auf LOW geht (Active Low); im Code stellst du das mit der Konstante RELAY_ACTIVE_LOW ein. Details im Beitrag Relaismodul.
  • Pumpe und eigene Stromversorgung: Für eine kleine Pumpe wie eine 6-V-Mini-Tauchpumpe nimmst du 4 AA-Batterien oder ein 6-V-Netzteil; ziehe den Pumpenstrom nicht aus dem 5V-Pin des Arduino. Zur Pumpenauswahl schau in den Beitrag Mini-Wasserpumpe.
  • Gemeinsame Masse: Bei einem Relaismodul werden die GNDs von Arduino und Modul verbunden, der Pumpenstromkreis bleibt über den Relaiskontakt getrennt. Verwendest du einen MOSFET, muss auch der Minuspol der Pumpenversorgung an Arduino-GND, und parallel zur Pumpe kommt eine 1N4007-Diode in Sperrrichtung.
  • Aktiver Buzzer: warnt dich im Fehlerfall mit unterbrochenen Tönen.
C++ (Arduino IDE)
1// İki şamandıra ile otomatik depo doldurma / Automatic tank filling with two floats
2const int FLOAT_PINS[2] = {2, 3};      // 0: üst şamandıra / upper float, 1: alt şamandıra / lower float
3const int RELAY_PIN  = 7;              // röle modülü IN / relay module IN
4const int BUZZER_PIN = 8;              // aktif buzzer / active buzzer
5const bool RELAY_ACTIVE_LOW = true;    // çoğu modül LOW ile çeker / most modules trigger on LOW
6const unsigned long STABLE_MS  = 500;                   // filtre süresi / filter time
7const unsigned long MAX_RUN_MS = 10UL * 60UL * 1000UL;  // en uzun çalışma: 10 dk / max run: 10 min
8
9bool wet[2];                 // true = şamandıra suda / true = float in water
10int lastRaw[2];
11unsigned long lastChange[2];
12bool pumpOn = false;
13bool fault = false;
14unsigned long pumpStart = 0;
15
16void updateSensor(int i) {
17  int raw = digitalRead(FLOAT_PINS[i]);
18  if (raw != lastRaw[i]) {             // değer değişti, sayacı sıfırla / value changed, reset timer
19    lastRaw[i] = raw;
20    lastChange[i] = millis();
21  }
22  if (millis() - lastChange[i] >= STABLE_MS) {
23    wet[i] = (raw == LOW);             // NO montaj: suda LOW / NO mount: LOW when wet
24  }
25}
26
27void setPump(bool on) {
28  pumpOn = on;
29  if (on) pumpStart = millis();
30  digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
31}
32
33void stopWithFault(const __FlashStringHelper *msg) {
34  setPump(false);
35  fault = true;                        // reset atılana kadar kilitli / latched until reset
36  Serial.println(msg);
37}
38
39void setup() {
40  Serial.begin(9600);
41  digitalWrite(RELAY_PIN, RELAY_ACTIVE_LOW ? HIGH : LOW);  // önce kapalı seviye / off level first
42  pinMode(RELAY_PIN, OUTPUT);
43  pinMode(BUZZER_PIN, OUTPUT);
44  for (int i = 0; i < 2; i++) {
45    pinMode(FLOAT_PINS[i], INPUT_PULLUP);
46  }
47  delay(10);                           // pull-up otursun / let pull-ups settle
48  for (int i = 0; i < 2; i++) {
49    lastRaw[i] = digitalRead(FLOAT_PINS[i]);
50    wet[i] = (lastRaw[i] == LOW);
51    lastChange[i] = millis();
52  }
53  Serial.println(F("Depo kontrolu basladi / Tank control started"));
54}
55
56void loop() {
57  updateSensor(0);
58  updateSensor(1);
59
60  if (!fault && wet[0] && !wet[1]) {   // üst suda, alt kuru: imkansız / upper wet, lower dry: impossible
61    stopWithFault(F("HATA: sensor tutarsiz / ERROR: sensors inconsistent"));
62  }
63  if (!fault && pumpOn && millis() - pumpStart > MAX_RUN_MS) {
64    stopWithFault(F("HATA: pompa cok uzun calisti / ERROR: pump ran too long"));
65  }
66
67  if (!fault) {
68    if (!pumpOn && !wet[1]) {          // su alt eşiğin altında / water below lower level
69      setPump(true);
70      Serial.println(F("Pompa ACIK / Pump ON"));
71    } else if (pumpOn && wet[0]) {     // depo dolu / tank full
72      setPump(false);
73      Serial.println(F("Depo dolu, pompa KAPALI / Tank full, pump OFF"));
74    }
75  }
76
77  // Arızada yarım saniyede bir bip / beep every half second on fault
78  digitalWrite(BUZZER_PIN, (fault && (millis() / 500) % 2) ? HIGH : LOW);
79}
CodeabschnittAufgabe
updateSensor(i)Liest jeden Schwimmer einzeln; aktualisiert wet[i], wenn der Wert 500 ms lang stabil bleibt.
wet[0] / wet[1]Ob der obere und der untere Schwimmer im Wasser sind (true = nass).
!pumpOn && !wet[1]Wasser ist unter die untere Schwelle gefallen: Pumpe starten.
pumpOn && wet[0]Wasser hat die obere Schwelle erreicht: Pumpe stoppen.
wet[0] && !wet[1]Oben nass, unten trocken: widersprüchliche Messung, also Kabel- oder Sensorfehler.
MAX_RUN_MSLäuft die Pumpe länger als 10 Minuten, greift der Trockenlaufschutz.
stopWithFault()Stoppt die Pumpe und verriegelt den Fehler; zum Löschen Problem beheben und Board zurücksetzen.
RELAY_ACTIVE_LOWStellt den Ausgangspegel passend dazu ein, ob das Relaismodul mit LOW oder HIGH anzieht.

Schwimmer auslesen und Pumpe steuern mit dem ESP32

Beim ESP32 ist der Code fast identisch; nur Pins und Baudrate ändern sich. In dieser Version gibt es für jeden Schwimmer eine Konstante WET_LEVEL: Montierst du einen Sensor als NC, setzt du den entsprechenden Wert einfach auf HIGH, der Rest der Logik bleibt gleich. Der Code schreibt außerdem alle 5 Sekunden den Füllstand auf die serielle Schnittstelle; diese Zeile kannst du später in Code umbauen, der per WLAN eine Benachrichtigung aufs Handy schickt. Achte bei der Pinwahl: Die GPIO 34, 35, 36 und 39 des ESP32 sind reine Eingänge und haben keine internen Pull-up-Widerstände; schließt du den Schwimmer dort an, brauchst du einen externen 10-kΩ-Pull-up. Auch Strapping-Pins wie GPIO 0, 2, 12 und 15 solltest du meiden; ist der Schwimmer beim Start geschlossen, kann das Board in den Programmiermodus gehen oder gar nicht starten. Der Code lässt sich mit dem ESP32-Arduino-Core 2.x und 3.x kompilieren. Wenn du neu beim ESP32 bist, lies zuerst Was ist der ESP32?.

C++ (Arduino IDE)
1// ESP32: iki şamandıra + röle + buzzer / two floats + relay + buzzer
2const int FLOAT_PINS[2] = {27, 26};    // 0: üst / upper, 1: alt / lower
3const int WET_LEVEL[2]  = {LOW, LOW};  // NO: suda LOW, NC ise HIGH yap / NO: LOW when wet, set HIGH for NC
4const int RELAY_PIN  = 23;             // röle modülü IN / relay module IN
5const int BUZZER_PIN = 25;             // aktif buzzer / active buzzer
6const bool RELAY_ACTIVE_LOW = true;
7const unsigned long STABLE_MS  = 500;
8const unsigned long MAX_RUN_MS = 10UL * 60UL * 1000UL;
9
10bool wet[2];
11int lastRaw[2];
12unsigned long lastChange[2];
13bool pumpOn = false;
14bool fault = false;
15unsigned long pumpStart = 0;
16unsigned long lastReport = 0;
17
18void updateSensor(int i) {
19  int raw = digitalRead(FLOAT_PINS[i]);
20  if (raw != lastRaw[i]) {
21    lastRaw[i] = raw;
22    lastChange[i] = millis();
23  }
24  if (millis() - lastChange[i] >= STABLE_MS) {
25    wet[i] = (raw == WET_LEVEL[i]);
26  }
27}
28
29void setPump(bool on) {
30  pumpOn = on;
31  if (on) pumpStart = millis();
32  digitalWrite(RELAY_PIN, (on != RELAY_ACTIVE_LOW) ? HIGH : LOW);
33}
34
35void stopWithFault(const char *msg) {
36  setPump(false);
37  fault = true;
38  Serial.println(msg);
39}
40
41void setup() {
42  Serial.begin(115200);
43  pinMode(RELAY_PIN, OUTPUT);
44  setPump(false);                      // röleyi hemen kapat / switch relay off immediately
45  pinMode(BUZZER_PIN, OUTPUT);
46  digitalWrite(BUZZER_PIN, LOW);
47  for (int i = 0; i < 2; i++) {
48    pinMode(FLOAT_PINS[i], INPUT_PULLUP);
49  }
50  delay(10);
51  for (int i = 0; i < 2; i++) {
52    lastRaw[i] = digitalRead(FLOAT_PINS[i]);
53    wet[i] = (lastRaw[i] == WET_LEVEL[i]);
54    lastChange[i] = millis();
55  }
56  Serial.println("Depo kontrolu basladi / Tank control started");
57}
58
59void loop() {
60  updateSensor(0);
61  updateSensor(1);
62
63  if (!fault && wet[0] && !wet[1]) {   // üst suda, alt kuru / upper wet, lower dry
64    stopWithFault("HATA: sensor tutarsiz / ERROR: sensors inconsistent");
65  }
66  if (!fault && pumpOn && millis() - pumpStart > MAX_RUN_MS) {
67    stopWithFault("HATA: pompa cok uzun calisti / ERROR: pump ran too long");
68  }
69
70  if (!fault) {
71    if (!pumpOn && !wet[1]) {
72      setPump(true);
73      Serial.println("Pompa ACIK / Pump ON");
74    } else if (pumpOn && wet[0]) {
75      setPump(false);
76      Serial.println("Depo dolu, pompa KAPALI / Tank full, pump OFF");
77    }
78  }
79
80  digitalWrite(BUZZER_PIN, (fault && (millis() / 500) % 2) ? HIGH : LOW);
81
82  if (millis() - lastReport >= 5000) {   // 5 sn'de bir durum raporu / status report every 5 s
83    lastReport = millis();
84    Serial.printf("Ust/Upper: %d  Alt/Lower: %d  Pompa/Pump: %d  Ariza/Fault: %d\n",
85                  (int)wet[0], (int)wet[1], (int)pumpOn, (int)fault);
86  }
87}

MicroPython-Code mit dem Raspberry Pi Pico

Auf dem Pico setzen wir dieselbe Logik in MicroPython um. Der Parameter Pin.PULL_UP aktiviert den internen Pull-up-Widerstand und ist an allen GP-Pins des Pico nutzbar. Für die Zeitmessung dienen time.ticks_ms() und time.ticks_diff(); ticks_diff berechnet die Differenz auch dann richtig, wenn der Zähler überläuft. Da die Ausgänge des Pico 3,3 V liefern, achte auf die Relaiswahl: Manche mit 5 V versorgten Module mit Optokoppler lassen beim 3,3-V-HIGH-Pegel nicht sicher los. Ein Relaismodul mit 3,3-V-Ansteuerung oder ein Logic-Level-MOSFET ist sicherer. Speicherst du den Code als main.py, führt der Pico ihn bei jedem Start automatisch aus. Wenn du neu bei MicroPython bist, erklärt Was ist der Raspberry Pi Pico? die Einrichtung.

MicroPython
1from machine import Pin
2import time
3
4FLOAT_PINS = (2, 3)          # 0: üst şamandıra / upper float, 1: alt / lower
5WET_LEVEL = (0, 0)           # NO: suda 0, NC ise 1 / NO: 0 when wet, 1 for NC
6STABLE_MS = 500              # filtre süresi / filter time
7MAX_RUN_MS = 10 * 60 * 1000  # en uzun çalışma: 10 dk / max run: 10 min
8RELAY_ACTIVE_LOW = True      # röle LOW ile çekiyorsa / relay triggers on LOW
9
10relay = Pin(15, Pin.OUT, value=1 if RELAY_ACTIVE_LOW else 0)   # başlangıçta kapalı / off at start
11buzzer = Pin(16, Pin.OUT, value=0)
12sensors = [Pin(p, Pin.IN, Pin.PULL_UP) for p in FLOAT_PINS]
13time.sleep_ms(10)
14
15last_raw = [s.value() for s in sensors]
16wet = [last_raw[i] == WET_LEVEL[i] for i in range(2)]
17last_change = [time.ticks_ms(), time.ticks_ms()]
18pump_on = False
19fault = False
20pump_start = 0
21
22
23def set_pump(on):
24    global pump_on, pump_start
25    pump_on = on
26    if on:
27        pump_start = time.ticks_ms()
28    relay.value(0 if on == RELAY_ACTIVE_LOW else 1)
29
30
31def update(i):
32    raw = sensors[i].value()
33    now = time.ticks_ms()
34    if raw != last_raw[i]:                       # değer değişti / value changed
35        last_raw[i] = raw
36        last_change[i] = now
37    if time.ticks_diff(now, last_change[i]) >= STABLE_MS:
38        wet[i] = raw == WET_LEVEL[i]
39
40
41def stop_with_fault(msg):
42    global fault
43    set_pump(False)
44    fault = True
45    print(msg)
46
47
48print("Depo kontrolu basladi / Tank control started")
49while True:
50    update(0)
51    update(1)
52    if not fault and wet[0] and not wet[1]:      # üst suda, alt kuru / upper wet, lower dry
53        stop_with_fault("HATA: sensor tutarsiz / ERROR: sensors inconsistent")
54    if not fault and pump_on and time.ticks_diff(time.ticks_ms(), pump_start) > MAX_RUN_MS:
55        stop_with_fault("HATA: pompa cok uzun calisti / ERROR: pump ran too long")
56    if not fault:
57        if not pump_on and not wet[1]:           # su alt eşiğin altında / water below lower level
58            set_pump(True)
59            print("Pompa ACIK / Pump ON")
60        elif pump_on and wet[0]:                 # depo dolu / tank full
61            set_pump(False)
62            print("Depo dolu, pompa KAPALI / Tank full, pump OFF")
63    buzzer.value(1 if fault and (time.ticks_ms() // 500) % 2 else 0)
64    time.sleep_ms(10)

Schwimmerschalter im Vergleich zu anderen Füllstandssensoren

SensorAusgangVorteilNachteil
Schwimmerschalter (Float Switch)Digital, ein PunktGünstig, keine Bibliothek nötig, kein Metall im Wasser, langlebigLiefert nur eine Schwelleninformation; Schmutz und Algen können den Schwimmer blockieren
Wasserstandssensor mit leitenden SondenAnalogSehr günstig, liefert abgestufte Werte je nach benetzter FlächeKorrodiert durch Elektrolyse schnell, nicht für Dauerbetrieb im Wasser geeignet
Berührungsloser Sensor XKC-Y25Digital, ein PunktWird außen an den Tank geklebt, kein Loch nötigFunktioniert nicht bei dicken oder metallischen Wänden, teurer
Ultraschall (HC-SR04, JSN-SR04T)Kontinuierliche DistanzMisst den Füllstand in Zentimetern, berührt die Flüssigkeit nichtVon Schaum und Dampf beeinflusst, hat einen toten Bereich; der HC-SR04 ist nicht wasserdicht

Die Auswahlregel ist einfach: Wenn du eine verlässliche Antwort auf die Frage „Ist der Tank voll oder leer?“ willst, ist der Schwimmerschalter die beste Wahl. Willst du den Füllstand in Prozent anzeigen, nimm einen Ultraschallsensor; Details dazu im Beitrag Vergleich von Abstandssensoren. Kannst du kein Loch in den Tank bohren, erledigt der berührungslose Sensor XKC-Y25 die Aufgabe. Sondenmodule solltest du nur für Tests oder kurze Messungen in Betracht ziehen; wie du die Lebensdauer dieses Moduls verlängerst, steht im Beitrag Wasserstandssensor. In ernsthaften Systemen nutzt man oft beides: Der Ultraschallsensor zeigt den Füllstand an, der Schwimmer wartet als zusätzlicher Überlaufschutz.

Projektideen mit dem Schwimmerschalter

  • Automatische Tankbefüllung: Fülle den Wassertank auf dem Dach oder im Garten mit zwei Schwimmern und einer Pumpe von selbst.
  • Intelligenter Blumentopf und Bewässerungsstation: Ein Bodenfeuchtesensor entscheidet über das Gießen, der Schwimmer schützt die Pumpe vor Trockenlauf, wenn der Wasserbehälter leer ist.
  • Nachfüllautomat fürs Aquarium: Füge verdunstetes Wasser aus einem separaten Behälter in kleinen Mengen nach; ein zweiter, als NC montierter Schwimmer oben dient als Überlaufsicherung.
  • Luftentfeuchter- und Klimaanlagen-Ablaufalarm: Der Buzzer piept oder das Gerät wird per Relais abgeschaltet, wenn der Wasserbehälter voll ist.
  • Wassertank im Gewächshaus überwachen: Lass dir in deinem intelligenten Gewächshaus den Tankstand per ESP32 aufs Handy melden.
  • Warnung bei Wasser im Keller: Ein bodennah montierter Schwimmer schickt eine Nachricht über einen Telegram-Bot, sobald sich Wasser sammelt.

Häufige Fehler und ihre Lösungen

SymptomMögliche UrsacheLösung
Pin wechselt ständig zufälligINPUT_PULLUP vergessen, Pin schwebt (floating)pinMode auf INPUT_PULLUP setzen oder externen 10-kΩ-Pull-up ergänzen
Zustand ist immer vertauschtSensor arbeitet als NC oder wurde umgekehrt montiertSchwimmer umdrehen oder WET_LEVEL im Code ändern
Pumpe schaltet am Schwellenwert ständig ein und ausNur ein Schwimmer und zu kurze FilterzeitHysterese mit zwei Schwimmern einrichten, Filterzeit auf 1–2 Sekunden erhöhen
Schwimmer reagiert gar nichtReed-Kontakt durch Überlast verschweißt oder Glasröhrchen gebrochenDurchgangsprüfung mit dem Multimeter machen, Last immer über ein Relais schalten
Schwimmer bleibt oben hängenSchmutz, Kalk oder Algen haben sich angesammeltGehäuse und Schwimmer regelmäßig reinigen, am Wassereinlauf ein Sieb einsetzen
Arduino startet neu, wenn die Pumpe läuftPumpe hängt an derselben Quelle, die Spannung bricht einEigene Versorgung für die Pumpe nutzen, GND-Verbindung korrekt herstellen
ESP32 startet nicht oder hängt beim StartSchwimmer hängt an einem Strapping-PinSichere Pins wie GPIO 26 und 27 verwenden
Sind die Kabel des Schwimmers länger als ein paar Meter, setze direkt am Pin einen externen 10-kΩ-Pull-up und zwischen Pin und GND einen 100-nF-Kondensator ein. Die Zeitkonstante dieses RC-Filters beträgt 10 kΩ × 100 nF = 1 ms; er filtert elektrische Störungen, bremst die Reaktion des Schwimmers aber nicht spürbar. Andere Werte kannst du mit dem RC-Zeitkonstanten-Rechner ausprobieren. Isoliere die Kabelverbindungen außerdem mit Schrumpfschlauch und schütze sie vor Feuchtigkeit.

Trotz seines günstigen und schlichten Aufbaus bildet der Schwimmerschalter in Kombination mit korrekter Montage, Pull-up-Auslesung, Software-Filter und Hysterese das Fundament einer Automatisierung, die jahrelang problemlos läuft. Dasselbe Reed-Kontakt-Prinzip begegnet dir in Türsensoren, dieselbe Pumpensteuerung in Bewässerungssystemen. In der BlueGrays-App findest du Projekte zum Auslesen von Reed-Relais, Türsensoren und intelligenten Bewässerungsstationen mit Schaltplänen und fertigem Code und kannst die Schaltung aus diesem Beitrag an dein eigenes Projekt anpassen.

Häufige Fragen

Wie funktioniert ein Schwimmerschalter?

Im Schwimmer steckt ein ringförmiger Magnet, im Gehäuse ein Reed-Kontakt mit Glasröhrchen. Steigt der Wasserstand, gleitet der Schwimmer am Gehäuse entlang, und sobald der Magnet auf Höhe des Reed-Kontakts ist, schließt oder öffnet der Kontakt. So verhält sich der Sensor wie ein wassergesteuerter Schalter und liefert über seine zwei Kabel ein digitales Signal.

Ist ein Schwimmerschalter NO oder NC?

Derselbe Sensor lässt sich auf beide Arten nutzen. Entfernst du den Sicherungsring am Gehäuseende und setzt den Schwimmer umgedreht auf, wird aus einem NO-Sensor (Schließer) ein NC-Sensor (Öffner). Da auch die Einbaulage das Verhalten beeinflusst, ist eine Durchgangsprüfung mit dem Multimeter vor dem Einbau am sichersten.

Brauche ich für den Schwimmerschalter einen Widerstand?

Beim Arduino, ESP32 und Pico brauchst du keinen zusätzlichen Widerstand, wenn du den internen Pull-up des Pins aktivierst (INPUT_PULLUP bzw. Pin.PULL_UP). Bei Kabeln über ein paar Metern oder in störbehafteter Umgebung machen ein externer 10-kΩ-Pull-up und ein 100-nF-Kondensator die Messung stabiler. An den Pins 34–39 des ESP32 gibt es keinen internen Pull-up, dort ist ein externer Widerstand Pflicht.

Kann ein Schwimmerschalter eine Pumpe direkt schalten?

Der Reed-Kontakt kleiner Hobby-Schwimmer kann meist höchstens 10 W und 0,5 A schalten; der Anlaufstrom einer Pumpe überschreitet diese Grenze leicht und verschweißt die Kontakte. Richtig ist, den Schwimmer an den Mikrocontroller anzuschließen und die Pumpe über ein Relaismodul oder einen MOSFET anzusteuern. So kannst du per Software auch Trockenlauf- und Zeitschutz ergänzen.

Funktioniert der Schwimmerschalter mit ESP32 und Raspberry Pi Pico?

Ja, da der Sensor nur ein Schalter ist, spielt die Versorgungsspannung keine Rolle, und er funktioniert problemlos mit 3,3-V-Boards. Es reicht, ein Kabel an GND und das andere an einen GPIO mit aktiviertem Pull-up zu legen. Meide beim ESP32 die Strapping-Pins und die Pins 34–39 ohne internen Pull-up.

Kann ich den Wasserstand mit einem Schwimmer in Prozent messen?

Ein einzelner Schwimmer erkennt nur einen Schwellenpunkt. Mit drei oder vier Schwimmern in verschiedenen Höhen des Tanks kannst du eine grobe Prozentanzeige bauen, für eine kontinuierliche und zentimetergenaue Messung ist aber ein Ultraschall-Abstandssensor besser geeignet. Eine gute Lösung ist, den Ultraschallsensor als Füllstandsanzeige und den Schwimmer zusätzlich als Überlaufsicherung zu nutzen.

Alle Projekte ansehen