Componenten · 19 min leestijd

Arduino-waterpomp: een mini-dompelpomp aansluiten en aansturen

Arduino-waterpomp: stuur een mini-dompelpomp van 3–6 V aan met een MOSFET of relais, flybackdiode, aparte voeding, debiet, automatisch water geven en ESP32-code.

Bijna elk Arduino-waterpomp-project gebruikt hetzelfde onderdeel: een mini-dompelpomp ter grootte van een vinger die op 3–6 V werkt en helemaal onder water zit. Hij is het hart van schakelingen die plantenpotten water geven, een aquarium bijvullen, een vaste hoeveelheid vloeistof doseren zoals een koffiemachine of een kleine fontein laten werken. Hij is goedkoop, stil en heeft maar twee draden; maar omdat er een DC-motor met borstels in zit, kun je hem niet rechtstreeks op een Arduino-pin aansluiten.

In deze gids leer je stap voor stap wat er in de pomp zit, waarom hij niet direct op een pin kan en hoe je hem veilig aanstuurt met een MOSFET, transistor of relais. We bespreken de taak van de flybackdiode, waarom de pomp een eigen voeding nodig heeft, hoe het debiet samenhangt met de opvoerhoogte en waarom droogdraaien de pomp om zeep helpt. Daarna schrijven we code voor snelheidsregeling met PWM, een vloeistofdoseerder die op de milliliter nauwkeurig is, automatisch water geven op basis van bodemvocht, bediening vanaf je telefoon met een ESP32 en water geven op tijd met een Raspberry Pi Pico.

6V mini-dompelpomp
Mini-dompelpomp: 3–6 V DC, twee draden, slanguitgang van ongeveer 7,5 mm. Hij moet tijdens het draaien helemaal onder water zitten.

Wat is een mini-dompelpomp en hoe werkt hij?

Een mini-dompelpomp is een centrifugaalpomp. In de kunststof behuizing zit een kleine DC-motor met borstels en een waaier met schoepen op de as. Als de motor draait, slingert de waaier het water dat via de inlaat onderaan binnenkomt naar buiten en perst het door de slanguitgang aan de zijkant of bovenkant. Het motorcompartiment is waterdicht afgesloten, terwijl de waaierkamer vol water zit. Dit ontwerp heeft twee belangrijke gevolgen: de pomp zuigt zichzelf niet aan (hij kan geen lucht verplaatsen, dus hij moet onder water liggen) en juist het water dat hij verpompt koelt de waaier en smeert het lager.

EigenschapTypische waarde (mini-dompelpomp 3–6 V)
Werkspanning2,5–6 V DC (meest efficiënt bij 3–5 V)
Werkstroom130–220 mA (tot 300 mA bij 6 V)
Aanloopstroom2 tot 3 keer de werkstroom, een paar milliseconden lang
Vermogen0,4–1,5 W
Debiet (open uitgang)80–120 L/u, ongeveer 1,3–2 L/min
Maximale opvoerhoogte40–110 cm (op deze hoogte zakt het debiet naar nul)
SlangSiliconenslang, 5 mm binnen- en 7–8 mm buitendiameter
Continue levensduurOngeveer 500 uur (motor met borstels)

De waarden in de tabel verschillen per model; controleer altijd het label van je eigen pomp of de gegevens van de verkoper. De twee rijen die er echt toe doen zijn stroom en aanloopstroom. Een pomp van 200 mA kan op het moment van starten kortstondig 400–600 mA trekken, omdat de motor nog niet op toeren is. Als je je schakeling niet voor deze piek ontwerpt, zie je je Arduino elke keer resetten als de pomp aangaat.

Waarom kan de pomp niet rechtstreeks op een Arduino-pin?

De meest gemaakte beginnersfout is de rode draad van de pomp in een digitale pin steken, de zwarte in GND, en proberen hem te laten draaien met digitalWrite(HIGH). Daar zijn drie afzonderlijke problemen mee. Ten eerste de stroom: een pin van een Arduino Uno overleeft maximaal 40 mA en de veilige grens is 20 mA, terwijl de pomp er tien keer zoveel wil. Ten tweede spanningspieken: de motorwikkeling is een spoel en op het moment dat de stroom wordt onderbroken kan die een korte puls van honderden volts in tegengestelde richting opwekken. Ten derde elektrische ruis: de borstels van een borstelmotor vonken bij elke omwenteling en verspreiden storing over de voedingslijn. Het resultaat is een pomp die nooit draait of een blijvend beschadigde pin.

BoardVeilige stroom per pinAbsolute pinlimietVergeleken met de pomp
Arduino Uno / Nano (5 V)20 mA40 mADe pomp wil 5–10 keer meer
ESP32 (3,3 V)≈ 20 mA40 mATe weinig stroom, en de spanning is ook te laag
Raspberry Pi Pico (3,3 V)4 mA (standaard)12 mA (hoogste instelling)De pomp wil meer dan 20 keer zoveel

De oplossing is dat de pin een schakelaar bedient in plaats van de pomp. De pin levert alleen een signaal van enkele milliampères; de echte stroom van de pomp loopt vanuit een aparte voeding door die schakelaar. Je hebt vier opties voor de schakelaar: een logic-level MOSFET, een NPN-transistor, een kant-en-klare MOSFET-module of een relaismodule. De tabel hieronder laat zien wanneer welke zinvol is.

AanstuurmethodeSnelheidsregeling met PWMMet 3,3V-boardsOpmerking
Logic-level MOSFET (IRLZ44N, AO3400A)JaAO3400A uitstekend, IRLZ44N voldoendeBeste keuze; wordt nauwelijks warm
NPN-transistor (2N2222A, BC337)JaJa, gebruik een kleinere basisweerstandTot 300 mA; spanningsval ≈ 0,2–0,3 V
IRF520-MOSFET-moduleJaNee, slechts half openWerkt tot ongeveer 1 A bij 5 V
RelaismoduleNee, alleen aan/uitHeeft een module met 3,3V-trigger nodigKlikt, contacten slijten; voor pompen op 12 V of netspanning
L298N / L9110S-motordriverJaJaOmkeren is niet nodig; de L298N slokt tot 2 V op
Wil je de details over het kiezen van een MOSFET, gateweerstanden en wat logic level betekent, lees dan de Arduino MOSFET-gids; voor BJT's en de berekening van de basisweerstand zie wat is een transistor. De pinout en de versterking van je transistor vind je in de transistorcatalogus.

Arduino-waterpomp aansluiten: MOSFET, diode en gemeenschappelijke massa

De stevigste en meest flexibele schakeling is een N-kanaals logic-level MOSFET die de pomp aan de lage kant schakelt. De positieve draad van de pomp gaat rechtstreeks naar de plus van de externe voeding; de negatieve draad komt op de drain van de MOSFET. De source van de MOSFET gaat naar GND en de gate gaat via een weerstand naar de Arduino-pin. Als de pin HIGH wordt, geleidt de MOSFET, verbindt hij de min van de pomp met GND en draait de pomp. Bij de IRLZ44N zijn de pinnen van links naar rechts, met de bedrukte kant naar je toe, Gate, Drain, Source.

VerbindingArduino UnoESP32Raspberry Pi Pico
Stuurpin → gateweerstand → gateD9 (PWM), 220 ΩGPIO 25, 100 ΩGP15, 100 Ω
Pull-down tussen gate en GND10 kΩ10 kΩ10 kΩ
MOSFET sourceGNDGNDGND
MOSFET drainNegatieve (zwarte) draad van de pompNegatieve (zwarte) draad van de pompNegatieve (zwarte) draad van de pomp
Positieve (rode) draad van de pompPlus van de externe 5V-voedingPlus van de externe 5V-voedingPlus van de externe 5V-voeding
Min van de externe voedingGND van de Arduino (gemeenschappelijke massa)GND van de ESP32 (gemeenschappelijke massa)GND van de Pico (gemeenschappelijke massa)
1N5819-diode, in sperrichting parallel aan de pompKathode (kant met streep) naar plus van de pompKathode naar plus van de pompKathode naar plus van de pomp

De gateweerstand beperkt de stootstroom uit de pin terwijl de gatecapaciteit van de MOSFET oplaadt; de pull-down van 10 kΩ houdt de gate op GND terwijl de Arduino opstart of code uploadt en de pin nog niet gedefinieerd is. Zonder die weerstand kan de pomp bij elke reset een paar seconden vanzelf draaien; naast een plantenpot betekent dat een glas water over je bureau. De diode en de gemeenschappelijke massa zijn belangrijk genoeg voor een eigen paragraaf.

Flybackdiode: de spanningspiek als de pomp uitschakelt

Een motorwikkeling gedraagt zich als een spoel, en een spoel laat de stroom er doorheen niet abrupt stoppen. Op het moment dat de MOSFET uitschakelt, zoekt de in de wikkeling opgeslagen energie een uitweg en veroorzaakt een korte spanningspiek op de drain, ver boven de voedingsspanning. Na verloop van tijd slaat die puls door de MOSFET of transistor heen en reset hij elke Arduino aan dezelfde lijn. De oplossing is een diode over de twee aansluitingen van de pomp, in sperrichting: kathode (kant met streep) naar plus, anode naar min. Tijdens normaal bedrijf voert de diode helemaal geen stroom; als de MOSFET uitschakelt, circuleert de spoelstroom via de diode terug de pomp in en sterft de energie onschadelijk weg.

Als je de pomp snel met PWM gaat schakelen, geleidt de diode in elke periode, dus een snelle schottkydiode zoals de 1N5819 is de beste keuze. Als je hem alleen aan- en uitzet, volstaat de 1N4007 die je toch al hebt liggen. Om de ruis van de borstels te verminderen, kun je ook een keramische condensator van 100 nF over de pompaansluitingen solderen. Soorten diodes en hoe je hun richting vindt leggen we uit in wat is een diode.

Aparte voeding en gemeenschappelijke massa: waarom reset de Arduino?

De pomp voeden vanaf de 5V-pin van de Arduino Uno lijkt de eerste keer te werken, maar is niet betrouwbaar. Een Uno die via USB wordt gevoed zit helemaal achter een zekering van 500 mA (polyfuse), en de USB-poort van een computer levert meestal ook 500 mA. Als de pomp start, trekt de piek van 400–600 mA de spanning heel even onder 4 V; de microcontroller reset, de Serial Monitor verbreekt de verbinding of de code gedraagt zich vreemd. Als je in plaats daarvan een adapter op de voedingsjack van de Uno aansluit, wordt de 5V-regelaar van het board heet: met 9 V ingang en een pomp van 250 mA zet de regelaar (9 − 5) × 0,25 = 1 W om in warmte.

  • 5V-adapter (1–2 A): De meest praktische oplossing. De pomp en, indien nodig, de Arduino draaien op dezelfde adapter, maar via aparte draden.
  • 4 × AA-batterijen (6 V): Ideaal voor pompen van 6 V; verse cellen geven 6,4 V, wat veilig is voor de pomp.
  • 18650 li-ion (3,7–4,2 V): Goed voor pompen van 3–5 V; laad hem op met een TP4056-module.
  • Breadboard-voedingsmodule: Modules zoals de MB102 leveren 5 V en 3,3 V aan het breadboard; genoeg voor een kleine pomp, details in de gids over de breadboard-voedingsmodule.
  • Als je een systeem van 12 V hebt: Verlaag het naar 5 V met een LM2596-stepdownconverter; voer nooit 12 V rechtstreeks aan een pomp van 6 V.
Vergeet niet de min van de externe voeding met de GND van de Arduino te verbinden. Zonder gemeenschappelijke massa is er geen referentie voor het gatesignaal, gaat de MOSFET niet open en draait de pomp helemaal niet; erger nog, hij kan willekeurig half openen en heet worden. Waarom, leggen we uit in GND en gemeenschappelijke massa. En als je de batterijduur inschat, denk dan aan de Arduino, niet aan de pomp: een pomp van 200 mA die 30 seconden per dag draait verbruikt ongeveer 1,7 mAh per dag, terwijl een Uno die altijd aan staat ongeveer 1200 mAh verbruikt; de batterijduurcalculator toont dit meteen.

Debiet en opvoerhoogte: hoe hoog kan de pomp water optillen?

Het debiet van 100–120 L/u dat verkopers opgeven geldt voor een pomp zonder slang en met de uitgang op het wateroppervlak. In de praktijk werkt de pomp, naarmate het water in de slang stijgt, tegen de zwaartekracht in en daalt het debiet. De hoogte waarop de pomp helemaal geen water meer kan optillen heet de maximale opvoerhoogte; op dat punt draait de waaier maar komt er niets uit de slang. Een lange, dunne of geknikte slang heeft hetzelfde effect doordat hij extra wrijving geeft. De tabel hieronder laat zien hoe een typische pomp die bij 5 V met open uitgang ongeveer 100 L/u levert zich op verschillende hoogtes gedraagt.

Hoogte van wateroppervlak tot slanguiteindeOngeveer debietPer seconde
0 cm100 L/u≈ 28 ml
25 cm75 L/u≈ 21 ml
50 cm50 L/u≈ 14 ml
75 cm25 L/u≈ 7 ml
100 cmBijna nulDruppel voor druppel

Bereken de gietduur dus niet met het cijfer uit de catalogus; meet het aan je eigen opstelling. Houd de slang boven een maatbeker op de hoogte die je echt gaat gebruiken, laat de pomp precies 10 seconden draaien en lees het water in de beker af. Als je bijvoorbeeld 185 ml hebt gemeten, is je debiet 18,5 ml/s; om 250 ml te leveren moet de pomp 250 / 18,5 ≈ 13,5 seconden draaien. Drie keer meten en het gemiddelde nemen verkleint de fout door verschillen in batterijspanning en slang. Als de pompspanning verandert (doordat batterijen leeg raken), verandert ook het debiet; gebruik voor nauwkeurig doseren een stabiele 5V-voeding.

Droogdraaien en het hevelingseffect: de twee verborgen vijanden van de pomp

Water smeert het lager van de pomp en koelt de motor. Als het reservoir leeg raakt, draait de pomp in lucht, wordt het waaierlager heet door wrijving, worden kunststof onderdelen zacht en draait de motor sneller dan normaal. Een paar seconden droogdraaien doodt de meeste pompen niet, maar een pomp die minutenlang droogdraait loopt vast of gaat anders klinken en verliest debiet. In automatische systemen zijn er twee manieren om dit te voorkomen: plaats een waterniveausensor of vlotterschakelaar in het reservoir en beperk in code hoe lang de pomp achter elkaar mag draaien. De code voor automatisch water geven hieronder doet beide.

Pas op voor het hevelingseffect: Als het uiteinde van de slang lager ligt dan het waterniveau in het reservoir, blijft het water door de zwaartekracht stromen, ook nadat de pomp is gestopt, en loopt het reservoir leeg in de plantenpot. Houd het hoogste punt van de slang altijd boven het water in het reservoir, of prik met een naald een klein luchtgaatje bovenaan de slang; als de pomp stopt, komt er lucht in en valt de stroming weg.

Stap voor stap: je eerste pomptest

  1. Dompel de pomp helemaal onder in een bak water en zet 30–50 cm siliconenslang op de uitgang; richt het uiteinde van de slang op een tweede bak.
  2. Plaats de IRLZ44N op het breadboard. Verbind de gate via 220 Ω met D9 en ook via 10 kΩ met GND; verbind de source met GND.
  3. Verbind de zwarte draad van de pomp met de drain en de rode draad met de plus van de externe 5V-voeding. Plaats de 1N5819-diode over de pompaansluitingen met de kant met streep aan de plus.
  4. Verbind de min van de externe voeding met de GND van de Arduino; controleer de bedrading nog een keer en zet dan de voeding aan.
  5. Upload de onderstaande code en open de Serial Monitor op 9600 baud. De pomp moet 3 seconden draaien en 10 seconden stoppen.
C++ (Arduino IDE)
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}

Als de pomp niet draait, controleer dan eerst de gemeenschappelijke massa en daarna de pinvolgorde van de MOSFET; als hij niet wil stoppen, zijn drain en source misschien verwisseld. Om het debiet te meten verander je in dezelfde code gewoon delay(3000) in delay(10000) en houd je de slang boven een maatbeker. Omdat deze code delay() gebruikt, kan de Arduino niets anders doen terwijl de pomp draait; in de volgende voorbeelden houden we de tijd bij met millis(). Ben je benieuwd naar het verschil, kijk dan naar millis versus delay.

De pompsnelheid instellen met PWM

Het grootste voordeel van een MOSFET is dat je de pompsnelheid kunt instellen met PWM. Een langzame stroom ziet er natuurlijker uit in een fontein, roert minder vuil op in een aquariumfilter en maakt fijner doseren mogelijk. Er zijn twee praktische problemen. Ten eerste kunnen kleine pompen niet starten bij een lage duty cycle (meestal onder 30–40%) en gaan ze alleen zoemen; daarom geeft de code de pomp een korte puls op vol vermogen om te starten en zakt daarna naar de gevraagde snelheid. Ten tweede laat de PWM van 490 Hz op pin D9 van de Uno de pomp hoorbaar janken; de code verhoogt die frequentie naar 3,9 kHz.

C++ (Arduino IDE)
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}

Verbind de middelste pin van de potentiometer met A0 en de buitenste pinnen met 5V en GND. De regel met TCCR1B beïnvloedt alleen Timer1, dus de pinnen D9 en D10; millis() en delay() gebruiken Timer0 en blijven dus werken. De Servo-bibliotheek gebruikt echter ook Timer1, dus haal deze regel weg als je project een servo heeft. Zoek MIN_DUTY met je eigen pomp: draai de potentiometer langzaam, lees in de Serial Monitor de laagste waarde af waarbij de pomp zelf kan starten en voeg een kleine marge toe. Een lagere pompspanning verlaagt ook de opvoerhoogte; op halve snelheid kan de pomp water maar tot ongeveer een kwart van de hoogte op volle snelheid optillen, omdat de druk van een centrifugaalpomp evenredig is met het kwadraat van zijn snelheid.

Vloeistofdoseerder: precies 50 ml met één druk op de knop

Als je het debiet eenmaal hebt gemeten, is het eenvoudig om van de pomp een doseermachine te maken: deel de benodigde hoeveelheid door het debiet en je weet hoe lang de pomp moet draaien. De onderstaande code doseert 50 ml telkens als je op een knop drukt die tussen D2 en GND zit; nogmaals indrukken terwijl de pomp draait annuleert de dosis. Omdat de tijd met millis() wordt gemeten, wacht de lus nooit en kan hij de knop continu lezen. Dit is de basis van projecten zoals zeepdispensers, plantenvoedingdosers of cocktailmachines.

C++ (Arduino IDE)
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}

Als de eerste dosis kleiner uitvalt dan de rest, is de oorzaak hoogstwaarschijnlijk een lege slang: de pomp vult eerst de slang en levert pas daarna vloeistof. Als je het slanguiteinde iets boven het water in het reservoir houdt, blijft de slang gevuld en is elke dosis gelijk. Bij dikke vloeistoffen zoals olie, siroop of zeep is het debiet veel lager dan bij water, dus kalibreer altijd met die vloeistof. Gebruik voor projecten die met voedsel in aanraking komen siliconenslang voor voedingsmiddelen en spoel de pomp na elk gebruik met schoon water.

Automatisch water geven op basis van bodemvocht

Het populairste Arduino-waterpompproject is een plantenpot die zichzelf water geeft als de grond uitdroogt. De valkuil voor beginners is de pomp laten draaien tot het bodemvocht de doelwaarde bereikt: het duurt minuten voordat water de sensor bereikt en dan is de pot allang overgelopen. De juiste methode is water geven in korte pulsen: de pomp draait 4 seconden, wacht dan 1 minuut zodat het water zich door de grond kan verspreiden en meet het vocht opnieuw. De code laat de pomp ook nooit draaien als het reservoir leeg is, en als het vocht na 6 pulsen nog steeds niet is gestegen (de sensor kan uit de grond zijn gekomen of de slang kan eraf zijn), vergrendelt hij het systeem en laat hij de led branden. Het kalibreren van de sensor behandelen we uitgebreid in de gids over de bodemvochtsensor.

C++ (Arduino IDE)
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}

Twee aparte drempels in de code gebruiken is bewust: het water geven begint als het vocht onder 35% zakt, maar gaat door tot 55%. Dankzij deze hysterese blijft de pomp niet aan- en uitschakelen door een meting die precies rond de drempel schommelt. Meet DRY_VALUE en WET_VALUE met je eigen sensor; bij capacitieve sensoren hangen deze waarden af van de voedingsspanning en de kabellengte. Als de draad van de vlotterschakelaar breekt, leest de pin HIGH en behandelt de code dat als een leeg reservoir; met andere woorden, als er iets uitvalt, blijft het systeem aan de veilige kant en stopt de pomp. Wil je alleen op bepaalde tijden van de dag water geven, voeg dan een RTC-klokmodule toe en neem een tijdcontrole op in de voorwaarde.

Wanneer is een relais zinvol voor het aansturen van de pomp?

Als je alleen een relaismodule hebt, kun je de minipomp daar ook mee laten draaien: de positieve draad van de pomp gaat van de externe voeding naar de COM-aansluiting van het relais en van de NO-aansluiting naar de pomp; de negatieve draad gaat naar de min van de voeding. Het relais scheidt de pomp volledig van de schakeling van het board, en dezelfde module kan grote pompen van 12 V of aquariumpompen op netspanning schakelen. Aan de andere kant kan een relais geen PWM-snelheidsregeling, klikt het bij elke schakeling, slijten de contacten na verloop van tijd en trekt alleen al de spoel ongeveer 70 mA. Als je de pomp een paar keer per dag schakelt, volstaat een relais; als je moet doseren of de snelheid moet regelen, is een MOSFET altijd beter. Ook bij een relais verkleint een diode over de pomp de vonkvorming op de contacten.

De waterpomp met een ESP32 vanaf je telefoon bedienen

Dankzij de Wi-Fi van de ESP32 kun je de pomp vanuit de browser van je telefoon laten draaien. De onderstaande code start een kleine webserver op de ESP32; als je op een telefoon in hetzelfde netwerk het IP-adres opent dat in de Serial Monitor staat, zie je knoppen voor 5 en 15 seconden water geven en een stopknop. Er is geen extra bibliotheek nodig, want WebServer zit in de ESP32-core. Voor de veiligheid draait de pomp nooit langer dan 30 seconden; zelfs als de verbinding wegvalt, stopt hij vanzelf als de tijd om is. Omdat de ESP32 op 3,3 V draait, kies je een MOSFET die bij 3,3 V volledig opengaat: de AO3400A is het best, en de IRLZ44N is nog ruim voldoende voor de 300 mA van een minipomp.

C++ (Arduino IDE)
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}

Deze pagina opent alleen vanuit je eigen wifinetwerk thuis. Wil je de pomp ook van buitenaf bedienen of een melding krijgen als het reservoir leeg raakt, dan kun je de methoden uit de gidsen ESP32 Telegram-bot of Blynk aan deze code toevoegen. Om de pagina om te bouwen tot een dashboard dat direct via WebSocket wordt bijgewerkt, zie de gids ESP32 Async Web Server. Omdat de pinnen van de ESP32 3,3 V uitgeven, werkt een IRF520-module hier niet; als je een module wilt, kies er dan een met een logic-level MOSFET.

Water geven op tijd met een Raspberry Pi Pico (MicroPython)

Op de Pico kun je de pomp via een MOSFET op GP15 aansturen en met PWM een zachte start geven. Een zachte start verspreidt de aanloopstroom van de pomp over een paar honderd milliseconden en voorkomt een plotselinge daling van de voedingsspanning; als de Pico en de pomp dezelfde voeding delen, voorkomt dit willekeurige resets. De onderstaande code geeft elke 12 uur 8 seconden water en voegt 3 extra seconden toe als je op de knop op GP14 drukt. Omdat de pinnen van de Pico maar 3,3 V geven, kies ook hier liever een MOSFET die bij 3,3 V gegarandeerd werkt, zoals de AO3400A. Als je nieuw bent met MicroPython, bekijk dan eerst wat is een Raspberry Pi Pico.

MicroPython
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)

De code meet de tijd met time.ticks_diff(), dat het juiste verschil geeft, ook als de teller omslaat. Omdat de eigen klok van de Pico bij uitschakelen reset en een paar seconden per dag kan afwijken, voeg je een RTC-module toe of gebruik je een Pico W en haal je de tijd van internet (NTP) als je een schema wilt dat aan de echte tijd gekoppeld is, zoals "elke ochtend om 07:00 water geven". Na een stroomstoring begint de teller van 12 uur weer bij nul; dat is voor de meeste planten prima, maar houd er rekening mee bij projecten die draaien terwijl je lang op vakantie bent.

Projectideeën met een mini-waterpomp

  • Vakantiewatersysteem: Geef je planten twee weken water met een emmer water, een paar potten en dunne slangen die naar elke pot vertakken; de complete opstelling staat in het slimme-kasproject.
  • Automatische drinkbak voor huisdieren: Als het waterniveau in de bak daalt, vult de pomp hem bij vanuit een reservoir; een contactloze vloeistofniveausensor werkt goed voor het niveau.
  • Contactloze zeep- of ontsmettingsmiddeldispenser: Als een HC-SR04 of infraroodsensor een hand ziet, draait de pomp een halve seconde.
  • Cocktail- en drankmachine: 3–4 pompen, elk in een eigen fles en elk met een apart gemeten debiet, mengen drankjes volgens recept.
  • Waterval voor op het bureau en decoratieve vijver: Een fontein waarvan de stroming 's nachts met PWM langzamer wordt en die uitschakelt als een LDR ziet dat de kamer donker wordt.
  • Aquarium bijvullen: Een systeem dat verdampt water uit een apart reservoir aanvult als een vlotterschakelaar laat zien dat het niveau is gedaald.
  • Integratie in het slimme huis: Koppel de pomp met een ESP32 via MQTT en Home Assistant aan je andere apparaten.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
De pomp zoemt maar perst geen waterLucht in de pomp, of de pomp zit boven het wateroppervlakDompel de pomp helemaal onder en schud hem zachtjes om de lucht te laten ontsnappen; leg de slang zonder knikken
De Arduino reset als de pomp startDe pomp draait op de 5V-pin van de Arduino, of er is geen diodeVoed de pomp met een aparte 5V-voeding, voeg een 1N5819 in sperrichting en 100 nF toe
De pomp draait helemaal nietGeen gemeenschappelijke massa, of de MOSFET-pinnen zitten in de verkeerde volgordeVerbind de min van de externe voeding met de GND van de Arduino en controleer de G-D-S-volgorde
De pomp draait kort terwijl de Arduino opstartZwevende gate, geen pull-downweerstandPlaats 10 kΩ tussen gate en GND
Het water blijft stromen nadat de pomp is gestoptHevelingseffect: het slanguiteinde ligt onder het niveau van het reservoirTil de slang op of maak een klein luchtgaatje bovenaan de slang
Het debiet neemt na verloop van tijd afVerstopt inlaatrooster, zwakke batterijen of slijtage door droogdraaienReinig de inlaat, meet de voeding, voeg een waterniveausensor toe
De pomp draait niet bij lage PWMDuty cycle onder de startdrempel van de motorGeef bij de start een korte puls op vol vermogen en verhoog MIN_DUTY
Voordat je de schakeling naast de plant installeert, probeer je elk scenario op je bureau uit met een testbak: wat gebeurt er als het reservoir leeg is, wat als de sensordraad losraakt, en start de pomp vanzelf als de stroom uitvalt en terugkomt? Houd de elektronica altijd naast of boven de waterbak, nooit er direct boven, en geef de kabels een lus die naar beneden hangt voordat ze het board bereiken (een druplus), zodat water dat langs een kabel loopt nooit het board bereikt.

Goed aangestuurd is een mini-dompelpomp een goedkoop, stil onderdeel dat jarenlang zonder problemen werkt: met een logic-level MOSFET, een diode in sperrichting, een aparte 5V-voeding en een gemeenschappelijke massa blijft je Arduino volledig veilig. De rest is aan je verbeelding; met het debiet dat je hebt gemeten kun je op de milliliter doseren, water geven op basis van bodemvocht of de pomp met een ESP32 vanaf je telefoon beheren. In de BlueGrays-app vind je het project Slim irrigatiestation, samen met projecten voor een ESP32-webserver en een RTC-klok, met stapsgewijze schakelschema's en code.

Veelgestelde vragen

Hoe sluit je een waterpomp aan op een Arduino?

Een mini-waterpomp sluit je niet rechtstreeks aan op een Arduino-pin, omdat een pin 20–40 mA levert terwijl de pomp 150–300 mA nodig heeft. Verbind de plus van de pomp met een externe 5V-voeding en de min met de drain van een logic-level MOSFET zoals de IRLZ44N; sluit de gate via 220 Ω aan op een pin en de source op GND. Plaats een 1N5819-diode in sperrichting parallel over de pomp en verbind de massa's van beide voedingen met elkaar.

Hoeveel stroom trekt een mini-waterpomp?

Mini-dompelpompen van 3–6 V trekken tijdens het draaien meestal 130–220 mA, en bij 6 V tot 300 mA. Bij het starten kunnen ze een paar milliseconden lang kortstondig 2 tot 3 keer die waarde halen. Daarom moet je voeding minimaal 1 A aankunnen en mag de pomp niet op de 5V-pin van de Arduino draaien.

Moet ik een waterpomp met een relais of een MOSFET aansturen?

Voor mini-pompen van 3–6 V is een logic-level MOSFET beter: hij is geluidloos, slijt niet en maakt snelheidsregeling met PWM mogelijk. Een relais kan alleen aan- en uitschakelen, klikt en de spoel trekt er ongeveer 70 mA bovenop. Een relais is zinvol voor grote pompen van 12 V of pompen op netspanning, en als de pomp maar een paar keer per dag draait.

Wat gebeurt er als een mini-waterpomp droogdraait?

Deze pompen worden door water gekoeld en hun lager wordt erdoor gesmeerd. Een paar seconden droogdraaien doet meestal geen kwaad, maar een pomp die minutenlang droogdraait oververhit zijn lager, slijt zijn kunststof onderdelen en kan vastlopen. Plaats in automatische systemen een waterniveausensor of vlotterschakelaar in het reservoir en beperk in code de langste looptijd.

Hoe hoog kan een mini-waterpomp water optillen?

De maximale opvoerhoogte van mini-dompelpompen van 3–6 V ligt meestal tussen 40 en 110 cm. Naarmate je die hoogte nadert, daalt het debiet snel, en op de grens komt er bijna geen water meer uit de slang. Als je water hoger moet sturen, gebruik dan een sterkere pomp van 12 V of een membraanpomp.

Kun je de snelheid van een waterpomp met een Arduino regelen?

Ja. Als je de pomp via een logic-level MOSFET aanstuurt, kun je de snelheid instellen met analogWrite() op een PWM-pin. Kleine pompen kunnen onder een duty cycle van ongeveer 30–40% niet starten, dus geef eerst een korte puls op vol vermogen en verlaag dan de snelheid. Met een relais kun je de snelheid niet regelen.

Alle projecten bekijken
Slim bewateringsstation
AR-83Gevorderd
Premium

Slim bewateringsstation

Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.

5.0(42)
57
ESP32 asynchrone webserver (met IP-weergave op lcd)
ES-27Gevorderd

ESP32 asynchrone webserver (met IP-weergave op lcd)

In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

4.8(16)
26
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
ES-25Gevorderd

ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)

In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

4.4(21)
38
Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)
ES-18Gemiddeld
Premium

Digitale klok met ESP32 en DS1307-RTC (I2C + LCD)

In dit project tonen we de tijd en de datum op een 16x2 I2C-LCD met de DS1307 realtimeklok-module (RTC). De DS1307 is een RTC met batterijback-up die de tijd bijhoudt, ook als de ESP32 uit staat. Beide modules delen dezelfde I2C-bus (SDA/SCL), zodat je leert hoe je met slechts twee signaaldraden meerdere apparaten bestuurt. Met dit project krijg je praktische kennis van het I2C-communicatieprotocol, de werking van RTC-modules en het dynamisch tonen van gegevens op een LCD.

4.6(26)
40
DS1302 RTC-klokmodule instellen
AR-45Beginner

DS1302 RTC-klokmodule instellen

Je krijgt een kleine klokmodule aan de praat die de tijd nooit vergeet, ook niet als de Arduino uit staat.

4.5(23)
31
LED bedienen met je telefoon via Bluetooth
AR-34Beginner
Premium

LED bedienen met je telefoon via Bluetooth

Een kleine oefening voor het aan- en uitzetten van de lampen in je kamer met je telefoon.

4.8(69)
91
ESP32 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

ESP32 slimme verlichting (PIR + LDR + relais + OLED)

Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

4.3(6)
11