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.

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.
| Eigenschaft | Typischer Wert (kleines vertikales Modell) |
|---|---|
| Sensorelement | Reed-Kontakt + Ringmagnet im Schwimmer |
| Ausgang | Trockenkontakt (offen / geschlossen), 2 Kabel, ohne Polarität |
| Kontakttyp | NO oder NC (durch Umdrehen des Schwimmers änderbar) |
| Max. Schaltleistung | 10 W |
| Max. Schaltspannung | 100 V DC |
| Max. Schaltstrom | 0,5 A |
| Kontaktwiderstand | 100 mΩ oder weniger |
| Material von Gehäuse und Schwimmer | PP (Polypropylen) |
| Betriebstemperatur | −10 … +85 °C |
| Montage | Gewindegehä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.
| Montage | Ohne Wasser (Schwimmer unten) | Mit Wasser (Schwimmer oben) | Pin mit INPUT_PULLUP |
|---|---|---|---|
| NO (normalerweise offen) | Kontakt offen | Kontakt geschlossen | Trocken HIGH, nass LOW |
| NC (normalerweise geschlossen) | Kontakt geschlossen | Kontakt offen | Trocken LOW, nass HIGH |
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:
| Anschluss | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Oberer Schwimmer (Tank voll) | D2 | GPIO 27 | GP2 |
| Unterer Schwimmer (Tank leer) | D3 | GPIO 26 | GP3 |
| Andere Kabel der Schwimmer | GND | GND | GND |
| Relaismodul IN | D7 | GPIO 23 | GP15 |
| Aktiver Buzzer (+) | D8 | GPIO 25 | GP16 |
| Relaismodul VCC | 5V | VIN (5 V) | VBUS (5 V) |
Schritt für Schritt: den Schwimmer zum ersten Mal auslesen
- 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.
- 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.
- Lade den folgenden Code hoch; er setzt den Pin auf INPUT_PULLUP, deshalb ist kein zusätzlicher Widerstand nötig.
- Öffne den Serial Monitor mit 9600 Baud.
- 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.
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.
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}| Codeabschnitt | Aufgabe |
|---|---|
| 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_MS | Lä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_LOW | Stellt 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?.
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.
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
| Sensor | Ausgang | Vorteil | Nachteil |
|---|---|---|---|
| Schwimmerschalter (Float Switch) | Digital, ein Punkt | Günstig, keine Bibliothek nötig, kein Metall im Wasser, langlebig | Liefert nur eine Schwelleninformation; Schmutz und Algen können den Schwimmer blockieren |
| Wasserstandssensor mit leitenden Sonden | Analog | Sehr günstig, liefert abgestufte Werte je nach benetzter Fläche | Korrodiert durch Elektrolyse schnell, nicht für Dauerbetrieb im Wasser geeignet |
| Berührungsloser Sensor XKC-Y25 | Digital, ein Punkt | Wird außen an den Tank geklebt, kein Loch nötig | Funktioniert nicht bei dicken oder metallischen Wänden, teurer |
| Ultraschall (HC-SR04, JSN-SR04T) | Kontinuierliche Distanz | Misst den Füllstand in Zentimetern, berührt die Flüssigkeit nicht | Von 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
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Pin wechselt ständig zufällig | INPUT_PULLUP vergessen, Pin schwebt (floating) | pinMode auf INPUT_PULLUP setzen oder externen 10-kΩ-Pull-up ergänzen |
| Zustand ist immer vertauscht | Sensor arbeitet als NC oder wurde umgekehrt montiert | Schwimmer umdrehen oder WET_LEVEL im Code ändern |
| Pumpe schaltet am Schwellenwert ständig ein und aus | Nur ein Schwimmer und zu kurze Filterzeit | Hysterese mit zwei Schwimmern einrichten, Filterzeit auf 1–2 Sekunden erhöhen |
| Schwimmer reagiert gar nicht | Reed-Kontakt durch Überlast verschweißt oder Glasröhrchen gebrochen | Durchgangsprüfung mit dem Multimeter machen, Last immer über ein Relais schalten |
| Schwimmer bleibt oben hängen | Schmutz, Kalk oder Algen haben sich angesammelt | Gehäuse und Schwimmer regelmäßig reinigen, am Wassereinlauf ein Sieb einsetzen |
| Arduino startet neu, wenn die Pumpe läuft | Pumpe hängt an derselben Quelle, die Spannung bricht ein | Eigene Versorgung für die Pumpe nutzen, GND-Verbindung korrekt herstellen |
| ESP32 startet nicht oder hängt beim Start | Schwimmer hängt an einem Strapping-Pin | Sichere Pins wie GPIO 26 und 27 verwenden |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED mit Taster schalten (Push)
Wie bei einer Türklingel: Das Licht leuchtet, solange du drückst, und geht aus, wenn du loslässt.

ESP32 LED-Steuerung mit Drucktaste (Push)
Die LED leuchtet auf, wenn die Taste gedrückt wird und geht aus, wenn sie losgelassen wird. Zeigt, wie der digitale Eingangspin des ESP32 und der interne Pull-up-Widerstand verwendet werden. Dank des INPUT_PULLUP-Modus ist kein externer Widerstand erforderlich.

Verwendung des Summers
Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

Reedschalter auslesen
Hast du dich schon mal gefragt, wie der Magnetschalter in Tür- und Fensteralarmen funktioniert?

Türsensor mit Reedschalter
Erkenne an einem Licht, ob deine Tür offen oder zu ist. An der Tür befestigst du einen kleinen Magneten, am Rahmen einen Schalter, der Magnete spürt; ist die Tür zu, liegen beide nebeneinander und…

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

220V Glühbirne mit Druckknopf (Push)
Solange du den Knopf gedrückt hältst, leuchtet eine echte 220-Volt-Glühbirne, und sobald du loslässt, geht sie aus.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

