Arduino Wasserpumpe: Mini-Tauchpumpe anschließen und steuern

Fast jedes Projekt mit einer Arduino Wasserpumpe nutzt dasselbe Bauteil: eine fingergroße Mini-Tauchpumpe, die mit 3–6 V läuft und komplett unter Wasser liegt. Sie ist das Herz von Schaltungen, die Blumentöpfe gießen, ein Aquarium nachfüllen, wie eine Kaffeemaschine eine feste Menge Flüssigkeit abgeben oder einen kleinen Zimmerbrunnen betreiben. Sie ist billig, leise und hat nur zwei Drähte; weil aber ein Bürsten-Gleichstrommotor in ihr steckt, darfst du sie nicht direkt an einen Arduino-Pin hängen.

In dieser Anleitung lernst du Schritt für Schritt, was in der Pumpe steckt, warum sie nicht direkt an einen Pin gehört und wie du sie sicher mit einem MOSFET, Transistor oder Relais ansteuerst. Wir klären die Aufgabe der Freilaufdiode, warum die Pumpe eine eigene Stromversorgung braucht, wie Förderrate und Förderhöhe zusammenhängen und warum Trockenlauf die Pumpe zerstört. Danach schreiben wir Code für die Drehzahlregelung per PWM, einen milliliter-genauen Flüssigkeitsspender, automatisches Gießen nach Bodenfeuchte, Steuerung per Handy mit dem ESP32 und zeitgesteuertes Gießen mit dem Raspberry Pi Pico.

Was ist eine Mini-Tauchpumpe und wie funktioniert sie?

Eine Mini-Tauchpumpe ist eine Kreiselpumpe. Im Kunststoffgehäuse sitzen ein kleiner Bürsten-Gleichstrommotor und ein Laufrad mit Schaufeln auf seiner Welle. Dreht der Motor, schleudert das Laufrad das Wasser, das es unten ansaugt, durch die Fliehkraft nach außen und drückt es aus dem seitlichen oder oberen Schlauchanschluss. Der Motorraum ist wasserdicht verschlossen, die Laufradkammer dagegen voller Wasser. Das hat zwei wichtige Folgen: Die Pumpe ist nicht selbstansaugend (sie kann keine Luft fördern und muss deshalb unter Wasser liegen), und genau das geförderte Wasser kühlt das Laufrad und schmiert seine Lagerung.

Die Werte in der Tabelle unterscheiden sich je nach Modell; schau immer auf das Etikett deiner Pumpe oder in die Angaben des Händlers. Wirklich wichtig sind zwei Zeilen: Strom und Anlaufstrom. Eine 200-mA-Pumpe kann beim Einschalten kurzzeitig 400–600 mA ziehen, weil der Motor noch nicht auf Drehzahl ist. Legst du deine Schaltung nicht für diesen Stromstoß aus, startet dein Arduino bei jedem Einschalten der Pumpe neu.

Warum darf die Pumpe nicht direkt an einen Arduino-Pin?

Der häufigste Anfängerfehler: das rote Kabel der Pumpe an einen Digitalpin, das schwarze an GND stecken und sie mit digitalWrite(HIGH) starten wollen. Das hat drei Probleme. Erstens der Strom: Ein Pin des Arduino Uno verträgt höchstens 40 mA, sicher sind 20 mA, die Pumpe will aber das Zehnfache. Zweitens Spannungsspitzen: Die Motorwicklung ist eine Spule und kann beim Abschalten einen kurzen Gegenimpuls von Hunderten Volt erzeugen. Drittens elektrische Störungen: Die Bürsten eines Bürstenmotors funken bei jeder Umdrehung und streuen Störungen auf die Versorgung. Das Ergebnis ist entweder eine Pumpe, die sich nicht dreht, oder ein dauerhaft beschädigter Pin.

Die Lösung: Der Pin steuert nicht die Pumpe, sondern einen Schalter. Der Pin liefert nur ein Signal von wenigen Milliampere; der eigentliche Pumpenstrom fließt aus einer eigenen Stromquelle über diesen Schalter. Dafür hast du vier Möglichkeiten: einen Logic-Level-MOSFET, einen NPN-Transistor, ein fertiges MOSFET-Modul oder ein Relaismodul. Die Tabelle unten zeigt, wann welche sinnvoll ist.

Arduino Wasserpumpe anschließen: MOSFET, Diode und gemeinsame Masse

Die robusteste und flexibelste Schaltung ist ein N-Kanal-Logic-Level-MOSFET, der die Pumpe auf der Low-Side schaltet. Der Pluspol der Pumpe geht direkt an den Plus der externen Versorgung, ihr Minuskabel an den Drain des MOSFETs. Source kommt an GND, das Gate über einen Widerstand an den Arduino-Pin. Ist der Pin HIGH, leitet der MOSFET, verbindet den Minuspol der Pumpe mit GND und die Pumpe läuft. Beim IRLZ44N lautet die Reihenfolge, mit der beschrifteten Seite zu dir, von links nach rechts Gate, Drain, Source.

Der Gate-Widerstand begrenzt den Stromstoß aus dem Pin, während die Gate-Kapazität geladen wird; der 10-kΩ-Pull-down hält das Gate auf GND, solange der Arduino startet oder Code hochgeladen wird und der Pin noch undefiniert ist. Fehlt dieser Widerstand, läuft die Pumpe bei jedem Reset ein paar Sekunden von selbst; neben einem Blumentopf bedeutet das ein Glas Wasser auf dem Schreibtisch. Diode und gemeinsame Masse sind so wichtig, dass sie eigene Abschnitte bekommen.

Freilaufdiode: die Spannungsspitze beim Abschalten der Pumpe

Eine Motorwicklung verhält sich wie eine Spule, und eine Spule lässt nicht zu, dass ihr Strom plötzlich abreißt. Sobald der MOSFET sperrt, sucht die gespeicherte Energie einen Weg und erzeugt am Drain eine kurze Spannungsspitze weit über der Versorgungsspannung. Mit der Zeit schlägt dieser Impuls den MOSFET oder Transistor durch und setzt jeden Arduino an derselben Leitung zurück. Die Lösung ist eine Diode, die in Sperrrichtung parallel zur Pumpe liegt: Kathode (Ring) an Plus, Anode an Minus. Im normalen Betrieb fließt durch sie gar kein Strom; sperrt der MOSFET, kreist der Spulenstrom über die Diode zurück in die Pumpe und die Energie klingt harmlos ab.

Schaltest du die Pumpe per PWM schnell ein und aus, leitet die Diode in jeder Periode; eine schnelle Schottky-Diode wie die 1N5819 ist dann die beste Wahl. Für reines Ein und Aus genügt auch eine 1N4007 aus der Bastelkiste. Gegen die Störungen der Bürsten kannst du zusätzlich einen 100-nF-Keramikkondensator direkt an die Pumpenanschlüsse löten. Diodentypen und ihre Polung erklären wir in Was ist eine Diode?.

Eigene Stromversorgung und gemeinsame Masse: Warum startet der Arduino neu?

Die Pumpe aus dem 5V-Pin des Arduino Uno zu versorgen, scheint beim ersten Versuch zu klappen, ist aber nicht zuverlässig. Ein per USB versorgter Uno hängt komplett hinter einer 500-mA-Sicherung (Polyfuse), und der USB-Port des Computers liefert meist auch nur 500 mA. Läuft die Pumpe an, zieht ihr Stromstoß von 400–600 mA die Spannung kurz unter 4 V; der Mikrocontroller startet neu, der serielle Monitor bricht ab oder der Code spinnt. Steckst du stattdessen ein Netzteil in die Hohlbuchse, wird der 5-V-Regler auf dem Board heiß: Bei 9 V Eingang und einer 250-mA-Pumpe verheizt er (9 − 5) × 0,25 = 1 W.

• 5-V-Netzteil (1–2 A): Die praktischste Lösung. Pumpe und bei Bedarf der Arduino hängen am selben Netzteil, aber über getrennte Leitungen.
• 4 × AA-Batterien (6 V): Ideal für 6-V-Pumpen; frische Zellen liefern 6,4 V, das ist für die Pumpe unbedenklich.
• 18650-Li-Ion-Akku (3,7–4,2 V): Passt zu 3–5-V-Pumpen; geladen wird er mit einem TP4056-Modul.
• Breadboard-Netzteilmodul: Module wie das MB102 liefern 5 V und 3,3 V aufs Breadboard; für eine kleine Pumpe reicht das, mehr dazu unter Breadboard-Netzteil.
• Bei einem 12-V-System: Mit einem LM2596-Abwärtswandler auf 5 V herunterregeln; 12 V nie direkt an eine 6-V-Pumpe legen.

Förderrate und Förderhöhe: Wie hoch pumpt die Pumpe das Wasser?

Die 100–120 l/h, die Händler angeben, gelten für eine Pumpe ohne Schlauch, deren Auslass auf Höhe der Wasseroberfläche liegt. In der Praxis arbeitet die Pumpe gegen die Schwerkraft, sobald das Wasser im Schlauch steigt, und die Förderrate sinkt. Die Höhe, bei der sie das Wasser gar nicht mehr anheben kann, heißt maximale Förderhöhe; dort dreht sich das Laufrad, aber aus dem Schlauch kommt nichts. Ein langer, dünner oder geknickter Schlauch wirkt durch Reibung genauso. Die Tabelle zeigt, wie sich eine typische Pumpe mit etwa 100 l/h bei 5 V und offenem Auslass in verschiedenen Höhen verhält.

Berechne die Gießzeit deshalb nicht aus dem Katalogwert, sondern miss sie an deinem eigenen Aufbau. Halte den Schlauch in der tatsächlichen Höhe über einen Messbecher, lass die Pumpe genau 10 Sekunden laufen und lies die Wassermenge ab. Hast du zum Beispiel 185 ml gemessen, beträgt deine Förderrate 18,5 ml/s; für 250 ml muss die Pumpe 250 / 18,5 ≈ 13,5 Sekunden laufen. Wiederhole die Messung dreimal und bilde den Mittelwert, das verringert Abweichungen durch Akkuspannung und Schlauch. Ändert sich die Pumpenspannung (wenn Batterien schwächer werden), ändert sich auch die Förderrate; für genaues Dosieren nimm eine stabile 5-V-Quelle.

Trockenlauf und Saugheber-Effekt: die zwei versteckten Feinde der Pumpe

Wasser schmiert die Lagerung der Pumpe und kühlt ihren Motor. Ist der Tank leer, dreht die Pumpe in Luft, das Lager des Laufrads wird durch Reibung heiß, Kunststoffteile werden weich und der Motor dreht höher als normal. Ein paar Sekunden Trockenlauf überleben die meisten Pumpen, aber minutenlanger Trockenlauf lässt sie festgehen oder sie klingt danach anders und fördert weniger. In automatischen Systemen verhinderst du das auf zwei Arten: mit einem Wasserstandssensor oder Schwimmerschalter im Tank und mit einer Höchstlaufzeit pro Durchgang im Code. Der Bewässerungscode weiter unten macht beides.

Schritt für Schritt: der erste Pumpentest

1. Tauche die Pumpe vollständig in ein Gefäß mit Wasser und stecke 30–50 cm Silikonschlauch auf den Auslass; richte das Schlauchende in ein zweites Gefäß.
2. Setze den IRLZ44N aufs Breadboard. Verbinde das Gate über 220 Ω mit D9 und zusätzlich über 10 kΩ mit GND; Source kommt an GND.
3. Schließe das schwarze Pumpenkabel an Drain und das rote an den Plus der externen 5-V-Versorgung an. Setze die 1N5819 an die Pumpenanschlüsse, mit dem Ring auf der Plusseite.
4. Verbinde den Minus der externen Versorgung mit dem GND des Arduino; prüfe die Verdrahtung noch einmal und schalte dann die Versorgung ein.
5. Lade den Code unten hoch und öffne den seriellen Monitor mit 9600 Baud. Die Pumpe sollte 3 Sekunden laufen und 10 Sekunden pausieren.

1const byte PUMP_PIN = 9;            // MOSFET gate (220 Ω üzerinden) / MOSFET gate (through 220 Ω)
2
3void setup() {
4  pinMode(PUMP_PIN, OUTPUT);
5  digitalWrite(PUMP_PIN, LOW);      // açılışta pompa kapalı / pump off at start-up
6  Serial.begin(9600);
7}
8
9void loop() {
10  Serial.println(F("Pompa calisiyor / pump on"));
11  digitalWrite(PUMP_PIN, HIGH);     // MOSFET iletimde, pompa döner / MOSFET on, pump runs
12  delay(3000);                      // 3 saniye su bas / pump for 3 seconds
13  Serial.println(F("Pompa durdu / pump off"));
14  digitalWrite(PUMP_PIN, LOW);
15  delay(10000);                     // 10 saniye bekle / wait 10 seconds
16}

Läuft die Pumpe nicht, prüfe zuerst die gemeinsame Masse, dann die Pinfolge des MOSFETs; hört sie nicht auf, sind Drain und Source vielleicht vertauscht. Für die Messung der Förderrate änderst du im selben Code delay(3000) in delay(10000) und hältst den Schlauch über einen Messbecher. Weil dieser Code delay() nutzt, kann der Arduino währenddessen nichts anderes tun; in den nächsten Beispielen messen wir die Zeit mit millis(). Den Unterschied erklärt der Beitrag millis und delay.

Pumpendrehzahl per PWM einstellen

Der größte Vorteil eines MOSFETs: Du kannst die Pumpendrehzahl per PWM einstellen. Ein langsamer Strahl wirkt in einem Brunnen natürlicher, wirbelt im Aquarienfilter weniger Schmutz auf und erlaubt feineres Dosieren. Es gibt zwei praktische Probleme. Erstens laufen kleine Pumpen bei niedrigem Tastgrad (meist unter 30–40 %) nicht an und brummen nur; deshalb gibt der Code zuerst einen kurzen Impuls mit voller Leistung und geht dann auf die gewünschte Drehzahl. Zweitens lässt die 490-Hz-PWM an Pin D9 des Uno die Pumpe hörbar pfeifen; der Code hebt die Frequenz auf 3,9 kHz an.

1const byte PUMP_PIN = 9;            // MOSFET gate, Timer1 PWM pini / Timer1 PWM pin
2const byte POT_PIN = A0;            // hız potansiyometresi / speed potentiometer
3const byte MIN_DUTY = 90;           // bunun altında pompa dönmez (≈ %35) / pump stalls below this (≈ 35 %)
4
5byte duty = 0;
6
7void setup() {
8  // D9-D10 PWM frekansı 490 Hz yerine 3,9 kHz (daha az vızıltı) / D9-D10 PWM at 3.9 kHz instead of 490 Hz (less whine)
9  TCCR1B = (TCCR1B & 0b11111000) | 0x02;
10  pinMode(PUMP_PIN, OUTPUT);
11  Serial.begin(9600);
12}
13
14void loop() {
15  int raw = analogRead(POT_PIN);                    // 0-1023
16  byte target = map(raw, 0, 1023, 0, 255);
17  if (target < MIN_DUTY) target = 0;                // çok yavaşsa tamamen durdur / stop completely if too slow
18
19  if (duty == 0 && target > 0) {                    // pompa duruyordu, şimdi kalkacak / pump was stopped, now starting
20    analogWrite(PUMP_PIN, 255);                     // kısa tam güç darbesi / short full-power kick
21    delay(150);
22  }
23  duty = target;
24  analogWrite(PUMP_PIN, duty);
25
26  Serial.print(F("PWM: "));
27  Serial.print(duty);
28  Serial.print(F("  (%"));
29  Serial.print(duty * 100 / 255);
30  Serial.println(F(")"));
31  delay(100);
32}

Verbinde den Schleifer des Potentiometers mit A0 und die äußeren Anschlüsse mit 5V und GND. Die Zeile mit TCCR1B betrifft nur Timer1, also die Pins D9 und D10; millis() und delay() nutzen Timer0 und funktionieren weiter. Allerdings verwendet auch die Servo-Bibliothek Timer1, entferne die Zeile also, wenn ein Servo im Projekt steckt. MIN_DUTY ermittelst du mit deiner Pumpe: Dreh das Poti langsam, lies im seriellen Monitor den niedrigsten Wert ab, bei dem sie von selbst anläuft, und gib etwas Reserve dazu. Weniger Spannung bedeutet auch weniger Förderhöhe; bei halber Drehzahl schafft die Pumpe nur etwa ein Viertel der Höhe, weil der Druck einer Kreiselpumpe mit dem Quadrat der Drehzahl wächst.

Flüssigkeitsspender: genau 50 ml auf Knopfdruck

Kennst du die Förderrate, wird aus der Pumpe leicht ein Dosierautomat: Teile die gewünschte Menge durch die Förderrate und du erhältst die Laufzeit. Der Code unten gibt bei jedem Druck auf einen Taster zwischen D2 und GND 50 ml ab; ein erneuter Druck während des Pumpens bricht die Dosis ab. Weil die Zeit mit millis() gemessen wird, wartet die Schleife nie und kann den Taster ständig abfragen. Das ist die Grundlage für Seifenspender, Düngerdosierer oder Cocktailmaschinen.

1const byte PUMP_PIN = 9;                 // MOSFET gate / MOSFET gate
2const byte BUTTON_PIN = 2;               // buton: D2 ile GND arası / button between D2 and GND
3const float ML_PER_SECOND = 18.5;        // kendi ölçtüğün debi / the flow rate you measured
4const float DOSE_ML = 50.0;              // bir basışta verilecek miktar / amount per press
5
6unsigned long doseTime = 0;              // ms cinsinden doz süresi / dose time in ms
7unsigned long startTime = 0;
8unsigned long lastPress = 0;
9bool pumping = false;
10bool lastButton = HIGH;
11
12void setPump(bool on) {
13  pumping = on;
14  digitalWrite(PUMP_PIN, on ? HIGH : LOW);
15  if (on) startTime = millis();
16}
17
18void setup() {
19  pinMode(PUMP_PIN, OUTPUT);
20  digitalWrite(PUMP_PIN, LOW);
21  pinMode(BUTTON_PIN, INPUT_PULLUP);     // basılıyken LOW / LOW while pressed
22  Serial.begin(9600);
23  doseTime = (unsigned long)(DOSE_ML / ML_PER_SECOND * 1000.0);
24  Serial.print(F("Doz suresi / dose time (ms): "));
25  Serial.println(doseTime);              // 50 / 18,5 = 2703 ms
26}
27
28void loop() {
29  bool button = digitalRead(BUTTON_PIN);
30  if (button == LOW && lastButton == HIGH && millis() - lastPress > 200) {   // yeni basış, 200 ms debounce / new press, 200 ms debounce
31    lastPress = millis();
32    setPump(!pumping);                   // ilk basış başlatır, ikincisi iptal eder / first press starts, second cancels
33    Serial.println(pumping ? F("Doz basladi / dose started") : F("Iptal / cancelled"));
34  }
35  lastButton = button;
36
37  if (pumping && millis() - startTime >= doseTime) {   // süre doldu / time is up
38    setPump(false);
39    Serial.println(F("Doz tamam / dose done"));
40  }
41}

Fällt die erste Dosis kleiner aus als die anderen, ist meist ein leerer Schlauch schuld: Die Pumpe füllt erst den Schlauch und gibt dann Flüssigkeit ab. Liegt das Schlauchende etwas über dem Wasserspiegel im Tank, bleibt der Schlauch gefüllt und jede Dosis ist gleich. Bei dicken Flüssigkeiten wie Öl, Sirup oder Seife ist die Förderrate viel geringer als bei Wasser; kalibriere also immer mit genau dieser Flüssigkeit. Bei Projekten mit Lebensmitteln nimmst du lebensmittelechten Silikonschlauch und spülst die Pumpe nach jedem Einsatz mit klarem Wasser.

Automatisch gießen nach Bodenfeuchte

Das beliebteste Projekt mit einer Arduino Wasserpumpe ist ein Blumentopf, der sich selbst gießt, wenn die Erde trocken wird. Die Anfängerfalle: die Pumpe so lange laufen lassen, bis die Bodenfeuchte den Zielwert erreicht. Bis das Wasser beim Sensor ankommt, vergehen Minuten, und bis dahin ist der Topf übergelaufen. Richtig ist Gießen in kurzen Stößen: Die Pumpe läuft 4 Sekunden, dann wartet das Programm 1 Minute, bis sich das Wasser in der Erde verteilt hat, und misst erneut. Außerdem startet der Code die Pumpe nie bei leerem Tank, und steigt die Feuchte nach 6 Stößen immer noch nicht (der Sensor steckt vielleicht nicht mehr in der Erde oder der Schlauch hat sich gelöst), sperrt er das System und schaltet die LED ein. Die Kalibrierung des Sensors erklären wir ausführlich im Beitrag Bodenfeuchtesensor.

1const byte PUMP_PIN = 9;                 // MOSFET gate / MOSFET gate
2const byte SOIL_PIN = A0;                // kapasitif toprak nem sensörü AOUT / capacitive soil sensor AOUT
3const byte FLOAT_PIN = 3;                // şamandıra: D3 ile GND arası / float switch between D3 and GND
4const byte LED_PIN = 13;                 // uyarı LED'i / warning LED
5
6const int DRY_VALUE = 600;               // sensör kuru havadayken / sensor in dry air
7const int WET_VALUE = 280;               // sensör bardak sudayken / sensor in a glass of water
8const int START_PERCENT = 35;            // bunun altında sulamaya başla / start watering below this
9const int STOP_PERCENT = 55;             // buna ulaşınca dur / stop once this is reached
10const unsigned long PULSE_MS = 4000;     // bir darbede pompa süresi / pump time per pulse
11const unsigned long SOAK_MS = 60000;     // suyun toprağa yayılma süresi / time for the water to soak in
12const byte MAX_PULSES = 6;               // bir sulamada en fazla darbe / max pulses per watering
13
14byte pulses = 0;
15bool locked = false;
16unsigned long lastCheck = 0;
17
18bool waterAvailable() {
19  return digitalRead(FLOAT_PIN) == LOW;  // şamandıra yukarıda: kontak kapalı / float up: contact closed
20}
21
22int readMoisture() {
23  long sum = 0;
24  for (byte i = 0; i < 10; i++) {        // 10 ölçümün ortalaması / average of 10 readings
25    sum += analogRead(SOIL_PIN);
26    delay(5);
27  }
28  int percent = map(sum / 10, DRY_VALUE, WET_VALUE, 0, 100);
29  return constrain(percent, 0, 100);
30}
31
32void runPump(unsigned long ms) {
33  unsigned long t0 = millis();
34  digitalWrite(PUMP_PIN, HIGH);
35  while (millis() - t0 < ms) {
36    if (!waterAvailable()) break;        // su biterse hemen dur / stop at once if the water runs out
37  }
38  digitalWrite(PUMP_PIN, LOW);
39}
40
41void setup() {
42  pinMode(PUMP_PIN, OUTPUT);
43  digitalWrite(PUMP_PIN, LOW);
44  pinMode(FLOAT_PIN, INPUT_PULLUP);
45  pinMode(LED_PIN, OUTPUT);
46  Serial.begin(9600);
47  lastCheck = millis() - SOAK_MS;        // ilk ölçüm hemen yapılsın / take the first reading right away
48}
49
50void loop() {
51  if (!waterAvailable()) {               // depo boş: yavaş yanıp sön / tank empty: slow blink
52    digitalWrite(LED_PIN, (millis() / 500) % 2);
53    return;
54  }
55  if (locked) {                          // arıza: LED sürekli yanar / fault: LED stays on
56    digitalWrite(LED_PIN, HIGH);
57    return;
58  }
59  digitalWrite(LED_PIN, LOW);
60  if (millis() - lastCheck < SOAK_MS) return;
61  lastCheck = millis();
62
63  int moisture = readMoisture();
64  Serial.print(F("Nem / moisture: %"));
65  Serial.println(moisture);
66
67  if (pulses == 0 && moisture >= START_PERCENT) return;   // sulama gerekmiyor / no watering needed
68  if (moisture >= STOP_PERCENT) {                        // hedefe ulaşıldı / target reached
69    pulses = 0;
70    return;
71  }
72  if (pulses >= MAX_PULSES) {                            // nem yükselmiyor: sensör ya da hortum sorunu / moisture not rising: sensor or hose problem
73    locked = true;
74    Serial.println(F("Kilitlendi, kontrol et / locked, check the setup"));
75    return;
76  }
77  runPump(PULSE_MS);
78  pulses++;
79}

Die zwei getrennten Schwellen im Code sind Absicht: Gegossen wird, wenn die Feuchte unter 35 % fällt, und zwar so lange, bis sie 55 % erreicht. Dank dieser Hysterese schaltet die Pumpe nicht ständig ein und aus, nur weil ein Messwert genau an der Schwelle schwankt. Miss DRY_VALUE und WET_VALUE mit deinem eigenen Sensor; bei kapazitiven Sensoren hängen sie von Versorgungsspannung und Kabellänge ab. Reißt das Kabel des Schwimmerschalters, liest der Pin HIGH und der Code wertet das als leeren Tank; fällt also etwas aus, bleibt das System auf der sicheren Seite und stoppt die Pumpe. Soll nur zu bestimmten Uhrzeiten gegossen werden, ergänze ein RTC-Uhrmodul und prüfe die Uhrzeit in der Bedingung.

Wann ist ein Relais für die Pumpensteuerung sinnvoll?

Hast du nur ein Relaismodul, kannst du die Minipumpe auch damit betreiben: Das Pluskabel geht von der externen Versorgung an COM des Relais und von NO zur Pumpe, das Minuskabel an den Minus der Versorgung. Das Relais trennt die Pumpe vollständig von der Schaltung des Boards, und mit demselben Modul kannst du auch große 12-V-Pumpen oder netzbetriebene Aquarienpumpen schalten. Dafür kann ein Relais keine Drehzahl per PWM regeln, klickt bei jedem Schalten, seine Kontakte verschleißen und schon die Spule zieht rund 70 mA. Schaltest du die Pumpe ein paar Mal am Tag, genügt ein Relais; für Dosieren oder Drehzahlregelung ist ein MOSFET immer besser. Auch mit Relais verringert eine Diode an der Pumpe den Kontaktabbrand.

Wasserpumpe per ESP32 vom Handy aus steuern

Dank WLAN kannst du die Pumpe über den Browser deines Handys starten. Der Code unten startet auf dem ESP32 einen kleinen Webserver; rufst du auf einem Handy im selben Netz die IP-Adresse aus dem seriellen Monitor auf, siehst du Tasten für 5 und 15 Sekunden Gießen und eine Stopptaste. Eine zusätzliche Bibliothek brauchst du nicht, WebServer gehört zum ESP32-Core. Aus Sicherheitsgründen läuft die Pumpe nie länger als 30 Sekunden; selbst wenn die Verbindung abreißt, stoppt sie nach Ablauf der Zeit von selbst. Weil der ESP32 mit 3,3 V arbeitet, nimm einen MOSFET, der bei 3,3 V voll durchschaltet: Der AO3400A ist ideal, der IRLZ44N reicht für die 300 mA einer Minipumpe aber locker.

1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi";             // Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
5const char* WIFI_PASS = "Sifre123";          // Wi-Fi şifren / your Wi-Fi password
6const int PUMP_PIN = 25;                     // MOSFET gate, 100 Ω üzerinden / through 100 Ω
7const unsigned long MAX_RUN_MS = 30000;      // güvenlik: en uzun çalışma / safety: longest run
8
9WebServer server(80);
10bool pumpOn = false;
11unsigned long pumpStart = 0;
12unsigned long pumpDuration = 0;
13
14void startPump(unsigned long ms) {
15  if (ms > MAX_RUN_MS) ms = MAX_RUN_MS;
16  pumpDuration = ms;
17  pumpStart = millis();
18  pumpOn = true;
19  digitalWrite(PUMP_PIN, HIGH);
20}
21
22void stopPump() {
23  pumpOn = false;
24  digitalWrite(PUMP_PIN, LOW);
25}
26
27void handleRoot() {
28  String html = F("<!DOCTYPE html><html><head><meta charset='utf-8'>"
29                  "<meta name='viewport' content='width=device-width,initial-scale=1'>"
30                  "<title>Pompa</title></head><body style='font-family:sans-serif;text-align:center'>"
31                  "<h2>BlueGrays Pompa</h2><p>");
32  html += pumpOn ? "Pompa çalışıyor / pump is on" : "Pompa kapalı / pump is off";
33  html += F("</p><p><a href='/run?s=5'><button>5 sn</button></a> "
34            "<a href='/run?s=15'><button>15 sn</button></a> "
35            "<a href='/stop'><button>Durdur / Stop</button></a></p></body></html>");
36  server.send(200, "text/html", html);
37}
38
39void goHome() {                              // ana sayfaya geri dön / go back to the main page
40  server.sendHeader("Location", "/");
41  server.send(303);
42}
43
44void handleRun() {
45  long seconds = server.arg("s").toInt();     // /run?s=5 → 5 saniye / 5 seconds
46  if (seconds > 0) startPump(seconds * 1000UL);
47  goHome();
48}
49
50void handleStop() {
51  stopPump();
52  goHome();
53}
54
55void setup() {
56  pinMode(PUMP_PIN, OUTPUT);
57  digitalWrite(PUMP_PIN, LOW);
58  Serial.begin(115200);
59  WiFi.mode(WIFI_STA);
60  WiFi.begin(WIFI_SSID, WIFI_PASS);
61  while (WiFi.status() != WL_CONNECTED) {
62    delay(500);
63    Serial.print(".");
64  }
65  Serial.println();
66  Serial.print(F("Tarayicida ac / open in the browser: http://"));
67  Serial.println(WiFi.localIP());
68
69  server.on("/", handleRoot);
70  server.on("/run", handleRun);
71  server.on("/stop", handleStop);
72  server.begin();
73}
74
75void loop() {
76  server.handleClient();
77  if (pumpOn && millis() - pumpStart >= pumpDuration) {   // süre doldu / time is up
78    stopPump();
79  }
80}

Diese Seite ist nur im heimischen WLAN erreichbar. Willst du die Pumpe auch von unterwegs steuern oder bei leerem Tank benachrichtigt werden, ergänze den Code mit den Methoden aus den Beiträgen ESP32-Telegram-Bot oder Blynk. Für ein Dashboard, das sich per WebSocket sofort aktualisiert, sieh dir ESP32 Async Webserver an. Weil die ESP32-Pins nur 3,3 V ausgeben, funktioniert ein IRF520-Modul hier nicht; nimm ein Modul mit Logic-Level-MOSFET.

Zeitgesteuertes Gießen mit dem Raspberry Pi Pico (MicroPython)

Am Pico steuerst du die Pumpe über einen MOSFET an GP15 und kannst sie per PWM sanft anlaufen lassen. Der Sanftanlauf verteilt den Anlaufstrom über einige hundert Millisekunden und verhindert einen plötzlichen Spannungseinbruch; hängen Pico und Pumpe an derselben Quelle, vermeidet das zufällige Neustarts. Der Code unten gießt alle 12 Stunden 8 Sekunden lang und gibt per Taster an GP14 zusätzlich 3 Sekunden. Weil die Pico-Pins nur 3,3 V liefern, nimm auch hier einen MOSFET, der bei 3,3 V garantiert durchschaltet, etwa den AO3400A. Bist du neu bei MicroPython, lies zuerst Was ist der Raspberry Pi Pico?.

1from machine import Pin, PWM
2import time
3
4pump = PWM(Pin(15))                       # MOSFET gate, 100 Ω üzerinden / through 100 Ω
5pump.freq(1000)                           # 1 kHz PWM
6pump.duty_u16(0)                          # açılışta kapalı / off at start-up
7button = Pin(14, Pin.IN, Pin.PULL_UP)     # buton: GP14 ile GND arası / button between GP14 and GND
8
9INTERVAL_MS = 12 * 60 * 60 * 1000         # 12 saatte bir / every 12 hours
10WATER_MS = 8000                           # her seferde 8 saniye / 8 seconds each time
11SPEED = 0.8                               # %80 hız / 80 % speed
12
13def water(ms):
14    top = int(65535 * SPEED)
15    for d in range(0, top, 2000):         # yumuşak kalkış (≈ 0,3 s) / soft start (≈ 0.3 s)
16        pump.duty_u16(d)
17        time.sleep_ms(10)
18    pump.duty_u16(top)
19    time.sleep_ms(ms)
20    pump.duty_u16(0)                      # pompayı durdur / stop the pump
21    print("Sulandi / watered:", ms, "ms")
22
23last = time.ticks_ms()
24while True:
25    if time.ticks_diff(time.ticks_ms(), last) >= INTERVAL_MS:
26        last = time.ticks_ms()
27        water(WATER_MS)
28    if button.value() == 0:               # elle sulama / manual watering
29        water(3000)
30        while button.value() == 0:        # bırakılmasını bekle / wait for release
31            time.sleep_ms(10)
32    time.sleep_ms(50)

Der Code misst die Zeit mit time.ticks_diff(), das auch beim Überlauf des Zählers die richtige Differenz liefert. Da die eigene Uhr des Pico beim Ausschalten zurückgesetzt wird und pro Tag einige Sekunden abweichen kann, brauchst du für einen Plan nach echter Uhrzeit, etwa „jeden Morgen um 7 Uhr gießen“, ein RTC-Modul oder einen Pico W, der die Zeit aus dem Internet (NTP) holt. Nach einem Stromausfall beginnt der 12-Stunden-Zähler wieder bei null; für die meisten Pflanzen ist das egal, bei Projekten für einen langen Urlaub solltest du es aber bedenken.

Projektideen mit einer Mini-Wasserpumpe

• Urlaubsbewässerung: Mit einem Eimer Wasser, ein paar Töpfen und dünnen Schläuchen zu jedem Topf gießt du zwei Wochen lang; den kompletten Aufbau zeigt das Smart-Gewächshaus-Projekt.
• Automatischer Wassernapf für Haustiere: Sinkt der Wasserstand im Napf, füllt die Pumpe aus einem Tank nach; für den Füllstand eignet sich ein berührungsloser Füllstandssensor.
• Berührungsloser Seifen- oder Desinfektionsspender: Erkennt ein HC-SR04 oder Infrarotsensor eine Hand, läuft die Pumpe eine halbe Sekunde.
• Cocktail- und Getränkemaschine: 3–4 Pumpen in eigenen Flaschen, jede einzeln auf ihre Förderrate kalibriert, mischen nach Rezept.
• Tischbrunnen und Zierteich: Ein Brunnen, dessen Strahl nachts per PWM langsamer wird und der ausgeht, wenn ein LDR Dunkelheit erkennt.
• Aquarium-Nachfüllautomatik: Ein System, das verdunstetes Wasser aus einem separaten Tank ergänzt, sobald ein Schwimmerschalter den gesunkenen Pegel meldet.
• Smart-Home-Anbindung: Verknüpfe die Pumpe per ESP32 über MQTT und Home Assistant mit deinen anderen Geräten.

Häufige Fehler und ihre Lösungen

Richtig angesteuert ist eine Mini-Tauchpumpe ein billiges, leises Bauteil, das jahrelang problemlos läuft: Mit einem Logic-Level-MOSFET, einer Freilaufdiode, einer eigenen 5-V-Versorgung und gemeinsamer Masse bleibt dein Arduino völlig sicher. Der Rest liegt bei deiner Fantasie; mit der gemessenen Förderrate dosierst du milliliter-genau, gießt nach Bodenfeuchte oder steuerst die Pumpe per ESP32 vom Handy aus. In der BlueGrays-App findest du das Projekt Intelligente Bewässerungsstation sowie Projekte zu ESP32-Webserver und RTC-Uhr mit Schritt-für-Schritt-Schaltplänen und Code.