Bomba de agua con Arduino: conectar y controlar una mini bomba

Casi todos los proyectos de bomba de agua con Arduino usan la misma pieza: una mini bomba sumergible del tamaño de un dedo, que funciona con 3–6 V y va completamente bajo el agua. Es el corazón de los circuitos que riegan macetas, rellenan un acuario, dosifican una cantidad fija de líquido como una cafetera o mueven una pequeña fuente. Es barata, silenciosa y solo tiene dos cables; pero como lleva dentro un motor DC con escobillas, no puedes conectarla directamente a un pin del Arduino.

En esta guía aprenderás paso a paso qué hay dentro de la bomba, por qué no se conecta directamente a un pin y cómo manejarla con seguridad mediante un MOSFET, un transistor o un relé. Veremos para qué sirve el diodo de protección, por qué la bomba necesita su propia fuente de alimentación, cómo se relacionan el caudal y la altura de elevación y por qué hacerla funcionar en seco la destruye. Después escribiremos código para regular la velocidad con PWM, un dosificador de líquidos preciso al mililitro, riego automático según la humedad del suelo, control desde el móvil con un ESP32 y riego programado con una Raspberry Pi Pico.

¿Qué es una mini bomba sumergible y cómo funciona?

Una mini bomba sumergible es una bomba centrífuga. Dentro de la carcasa de plástico hay un pequeño motor DC con escobillas y un rodete con álabes montado en su eje. Cuando el motor gira, el rodete lanza hacia fuera, por fuerza centrífuga, el agua que entra por el orificio inferior y la empuja por la salida para manguera del lateral o de arriba. El compartimento del motor está sellado, mientras que la cámara del rodete está llena de agua. Este diseño tiene dos consecuencias importantes: la bomba no es autocebante (no puede impulsar aire, así que debe estar bajo el agua) y es la propia agua bombeada la que refrigera el rodete y lubrica su eje.

Los valores de la tabla cambian según el modelo; consulta siempre la etiqueta de tu bomba o los datos del vendedor. Las dos filas que de verdad importan son la corriente y la corriente de arranque. Una bomba de 200 mA puede consumir brevemente 400–600 mA en el instante en que arranca, porque el motor aún no ha cogido velocidad. Si no diseñas el circuito para este pico, verás que el Arduino se reinicia cada vez que la bomba se enciende.

¿Por qué la bomba no se conecta directamente a un pin del Arduino?

El error más habitual al empezar es conectar el cable rojo de la bomba a un pin digital, el negro a GND e intentar encenderla con digitalWrite(HIGH). Esto tiene tres problemas distintos. Primero, la corriente: un pin del Arduino Uno aguanta como máximo 40 mA y el límite seguro es 20 mA, mientras que la bomba pide diez veces más. Segundo, los picos de tensión: el bobinado del motor es una bobina y, en el instante en que se corta la corriente, puede generar un breve pulso inverso de cientos de voltios. Tercero, el ruido eléctrico: las escobillas de un motor DC chispean en cada vuelta y meten interferencias en la alimentación. El resultado es una bomba que no gira o un pin dañado para siempre.

La solución es que el pin no controle la bomba sino un interruptor. El pin solo da una señal de pocos miliamperios; la corriente real de la bomba sale de una fuente aparte y pasa por ese interruptor. Tienes cuatro opciones: un MOSFET de nivel lógico, un transistor NPN, un módulo MOSFET ya montado o un módulo de relé. La tabla de abajo resume cuándo conviene cada uno.

Conexión de la bomba de agua al Arduino: MOSFET, diodo y GND común

El circuito más robusto y flexible es un MOSFET de canal N de nivel lógico que conmuta la bomba por el lado bajo (low side). El cable positivo de la bomba va directo al positivo de la fuente externa; el negativo se conecta al drenador (drain) del MOSFET. La fuente (source) va a GND y la puerta (gate), a través de una resistencia, al pin del Arduino. Cuando el pin pasa a HIGH, el MOSFET conduce, une el negativo de la bomba con GND y la bomba gira. En el IRLZ44N, con la cara impresa hacia ti, las patas de izquierda a derecha son Gate, Drain, Source.

La resistencia de puerta limita el pico de corriente que sale del pin mientras se carga la capacidad de la puerta del MOSFET; el pull-down de 10 kΩ mantiene la puerta a GND mientras el Arduino arranca o se carga el código y el pin aún no está definido. Sin esa resistencia, la bomba puede funcionar sola unos segundos en cada reinicio; junto a una maceta, eso es un vaso de agua derramado sobre la mesa. El diodo y la masa común son tan importantes que merecen apartados propios.

Diodo flyback: el pico de tensión al apagar la bomba

El bobinado del motor se comporta como una bobina, y una bobina no permite que su corriente se corte de golpe. En el instante en que el MOSFET se apaga, la energía almacenada busca una salida y crea en el drenador un breve pico de tensión muy por encima de la alimentación. Con el tiempo este pulso perfora el MOSFET o el transistor y reinicia cualquier Arduino de la misma línea. La solución es un diodo conectado entre los dos bornes de la bomba en sentido inverso: cátodo (franja) al positivo y ánodo al negativo. En funcionamiento normal el diodo no conduce nada; cuando el MOSFET se apaga, la corriente de la bobina vuelve a la bomba a través del diodo y la energía se disipa sin daño.

Si vas a conmutar la bomba rápidamente con PWM, el diodo conduce en cada periodo, así que un Schottky rápido como el 1N5819 es la mejor opción. Si solo la enciendes y apagas, el 1N4007 que tengas a mano también sirve. Para reducir el ruido de las escobillas, puedes soldar además un condensador cerámico de 100 nF entre los bornes de la bomba. Explicamos los tipos de diodo y cómo saber su sentido en qué es un diodo.

Fuente aparte y GND común: ¿por qué se reinicia el Arduino?

Alimentar la bomba desde el pin 5V del Arduino Uno parece funcionar al primer intento, pero no es fiable. Un Uno alimentado por USB está entero detrás de un fusible de 500 mA (polyfuse), y el puerto USB del ordenador suele dar también 500 mA. Al arrancar la bomba, su pico de 400–600 mA tira la tensión por debajo de 4 V un instante; el microcontrolador se reinicia, el Monitor Serie se desconecta o el código hace cosas raras. Si en cambio enchufas un adaptador al conector de alimentación del Uno, el regulador de 5 V de la placa se calienta: con 9 V de entrada y una bomba de 250 mA, convierte (9 − 5) × 0,25 = 1 W en calor.

• Adaptador de 5 V (1–2 A): La solución más práctica. La bomba y, si hace falta, el Arduino se alimentan del mismo adaptador, pero con cables separados.
• 4 pilas AA (6 V): Ideales para bombas de 6 V; las pilas nuevas dan 6,4 V, un valor seguro para la bomba.
• Batería 18650 de litio (3,7–4,2 V): Adecuada para bombas de 3–5 V; se carga con un módulo TP4056.
• Módulo de alimentación para protoboard: Módulos como el MB102 dan 5 V y 3,3 V a la protoboard; suficiente para una bomba pequeña, más detalles en módulo de alimentación MB102.
• Si tienes un sistema de 12 V: Bájalo a 5 V con un convertidor LM2596; nunca metas 12 V directamente a una bomba de 6 V.

Caudal y altura: ¿hasta dónde sube el agua la bomba?

Los 100–120 L/h que indican los vendedores corresponden a una bomba sin manguera, con la salida a ras del agua. En el uso real, a medida que el agua sube por la manguera, la bomba trabaja contra la gravedad y el caudal baja. La altura a la que la bomba ya no puede subir nada de agua se llama altura máxima de elevación; en ese punto el rodete gira pero por la manguera no sale nada. Una manguera larga, fina o doblada produce el mismo efecto al añadir rozamiento. La tabla muestra cómo se comporta a distintas alturas una bomba típica que da unos 100 L/h a 5 V con la salida libre.

Por eso no calcules el tiempo de riego con el dato del catálogo: mídelo en tu propio montaje. Pon la manguera sobre una jarra medidora a la altura que vas a usar de verdad, haz funcionar la bomba exactamente 10 segundos y lee el agua de la jarra. Si mediste 185 ml, por ejemplo, tu caudal es de 18,5 ml/s; para dar 250 ml la bomba debe funcionar 250 / 18,5 ≈ 13,5 segundos. Repetir la medida tres veces y promediar reduce el error debido a la tensión de las pilas y a la manguera. Si la tensión de la bomba cambia (al gastarse las pilas), también cambia el caudal; para dosificar con precisión usa una fuente estable de 5 V.

Funcionamiento en seco y efecto sifón: los dos enemigos ocultos de la bomba

El agua es lo que lubrica el eje de la bomba y refrigera su motor. Cuando el depósito se vacía, la bomba gira en el aire, el cojinete del rodete se calienta por rozamiento, el plástico se ablanda y el motor se embala. Unos segundos en seco no matan a la mayoría de las bombas, pero una bomba que gira en seco durante minutos se agarrota o empieza a sonar distinto y pierde caudal. En los sistemas automáticos hay dos formas de evitarlo: poner un sensor de nivel de agua o un interruptor de flotador en el depósito y limitar en el código cuánto tiempo puede funcionar la bomba de una vez. El código de riego automático de más abajo hace las dos cosas.

Paso a paso: la primera prueba de la bomba

1. Sumerge por completo la bomba en un recipiente con agua y pon 30–50 cm de manguera de silicona en la salida; dirige el extremo a un segundo recipiente.
2. Coloca el IRLZ44N en la protoboard. Une la puerta a D9 a través de 220 Ω y también a GND a través de 10 kΩ; conecta la fuente (source) a GND.
3. Conecta el cable negro de la bomba al drenador y el rojo al positivo de la fuente externa de 5 V. Pon el diodo 1N5819 entre los bornes de la bomba, con la franja hacia el positivo.
4. Une el negativo de la fuente externa con el GND del Arduino; revisa las conexiones una vez más y después enciende la fuente.
5. Carga el código de abajo y abre el Monitor Serie a 9600 baudios. La bomba debe funcionar 3 segundos y parar 10.

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}

Si la bomba no funciona, revisa primero la masa común y luego el orden de las patas del MOSFET; si no se para, puede que drenador y fuente estén cambiados. Para medir el caudal basta con cambiar delay(3000) por delay(10000) en el mismo código y poner la manguera sobre la jarra medidora. Como este código usa delay(), el Arduino no puede hacer nada más mientras la bomba funciona; en los siguientes ejemplos mediremos el tiempo con millis(). Si te interesa la diferencia, echa un vistazo a millis frente a delay.

Regular la velocidad de la bomba con PWM

La gran ventaja del MOSFET es que puedes regular la velocidad de la bomba con PWM. Un caudal lento queda más natural en una fuente, remueve menos suciedad en un filtro de acuario y permite dosificar con más finura. Hay dos problemas prácticos. Primero, las bombas pequeñas no arrancan con un ciclo de trabajo bajo (normalmente por debajo del 30–40 %) y solo zumban; por eso el código las arranca con un breve pulso a plena potencia y luego baja a la velocidad pedida. Segundo, el PWM de 490 Hz del pin D9 del Uno hace que la bomba pite de forma audible; el código sube esa frecuencia a 3,9 kHz.

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}

Conecta el pin central del potenciómetro a A0 y los extremos a 5V y GND. La línea TCCR1B solo afecta al Timer1, es decir, a los pines D9 y D10; millis() y delay() usan el Timer0, así que siguen funcionando. Pero la librería Servo también usa el Timer1: quita esta línea si tu proyecto lleva un servo. Encuentra MIN_DUTY con tu propia bomba: gira el potenciómetro despacio, lee en el Monitor Serie el valor más bajo con el que la bomba arranca sola y añade un pequeño margen. Bajar la tensión de la bomba también baja la altura de elevación; a media velocidad la bomba solo sube el agua hasta una cuarta parte de la altura a plena velocidad, porque la presión de una bomba centrífuga es proporcional al cuadrado de su velocidad.

Dosificador de líquidos: 50 ml exactos al pulsar un botón

Una vez medido el caudal, convertir la bomba en una dosificadora es fácil: divide la cantidad deseada entre el caudal y sabrás cuánto tiempo debe funcionar la bomba. El código de abajo suelta 50 ml cada vez que pulsas un botón conectado entre D2 y GND; si vuelves a pulsar mientras la bomba funciona, cancela la dosis. Como el tiempo se mide con millis(), el bucle nunca espera y puede leer el botón continuamente. Es la base de proyectos como dispensadores de jabón, dosificadores de abono o máquinas de cócteles.

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}

Si la primera dosis sale más pequeña que las demás, lo más probable es que la manguera estuviera vacía: la bomba primero la llena y solo después suelta el líquido. Si mantienes el extremo de la manguera un poco por encima del agua del depósito, la manguera queda llena y todas las dosis son iguales. Con líquidos espesos como aceite, sirope o jabón el caudal es mucho menor que con agua, así que calibra siempre con ese líquido. En proyectos que tocan alimentos usa manguera de silicona apta para uso alimentario y aclara la bomba con agua limpia después de cada uso.

Riego automático según la humedad del suelo

El proyecto más popular con una bomba de agua y Arduino es la maceta que se riega sola cuando la tierra se seca. La trampa en la que caen los principiantes es hacer funcionar la bomba hasta que la humedad alcanza el objetivo: el agua tarda minutos en llegar al sensor y para entonces la maceta ya se ha desbordado. El método correcto es regar en pulsos cortos: la bomba funciona 4 segundos, luego espera 1 minuto a que el agua se reparta por la tierra y vuelve a medir. Además, el código nunca enciende la bomba si el depósito está vacío y, si tras 6 pulsos la humedad sigue sin subir (puede que el sensor se haya salido de la tierra o que la manguera se haya soltado), bloquea el sistema y enciende el LED. Explicamos la calibración del sensor en detalle en la guía del sensor de humedad del suelo.

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}

Usar dos umbrales distintos en el código es intencionado: el riego empieza cuando la humedad baja del 35 %, pero continúa hasta llegar al 55 %. Gracias a esta histéresis, la bomba no se enciende y apaga sin parar por una lectura que oscila justo en el umbral. Mide DRY_VALUE y WET_VALUE con tu propio sensor; en los sensores capacitivos estos valores dependen de la tensión de alimentación y de la longitud del cable. Si se rompe el cable del flotador, el pin lee HIGH y el código lo toma como depósito vacío; es decir, si algo falla, el sistema se queda del lado seguro y para la bomba. Si quieres regar solo a ciertas horas, añade un módulo de reloj RTC y mete una comprobación de la hora en la condición.

¿Cuándo tiene sentido controlar la bomba con un relé?

Si solo tienes un módulo de relé, también puedes mover la mini bomba con él: el cable positivo de la bomba va de la fuente externa al borne COM del relé y del borne NO a la bomba; el negativo va al negativo de la fuente. El relé aísla por completo la bomba del circuito de la placa y con el mismo módulo puedes conmutar bombas grandes de 12 V o bombas de acuario conectadas a la red. A cambio, un relé no puede regular la velocidad con PWM, hace clic en cada conmutación, sus contactos se gastan con el tiempo y su bobina por sí sola consume unos 70 mA. Si enciendes la bomba unas pocas veces al día, el relé sirve; si necesitas dosificar o regular la velocidad, el MOSFET siempre es mejor. Incluso con relé, un diodo en la bomba reduce el arco en los contactos.

Controlar la bomba de agua desde el móvil con un ESP32

Gracias al Wi-Fi del ESP32 puedes encender la bomba desde el navegador del móvil. El código de abajo abre un pequeño servidor web en el ESP32; si en un móvil conectado a la misma red entras en la dirección IP que aparece en el Monitor Serie, verás botones para regar 5 y 15 segundos y un botón de parada. No hace falta ninguna librería extra: WebServer viene con el núcleo del ESP32. Por seguridad, la bomba nunca funciona más de 30 segundos; aunque se corte la conexión, se para sola al acabar el tiempo. Como el ESP32 trabaja a 3,3 V, elige un MOSFET que conduzca del todo con 3,3 V: el AO3400A es el mejor, y el IRLZ44N basta de sobra para los 300 mA de una mini bomba.

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}

Esta página solo se abre desde la red Wi-Fi de casa. Si también quieres controlar la bomba desde fuera o recibir un aviso cuando el depósito se vacíe, añade a este código los métodos de las guías bot de Telegram con ESP32 o Blynk. Para convertir la página en un panel que se actualiza al instante con WebSocket, mira la guía servidor web asíncrono con ESP32. Como los pines del ESP32 dan 3,3 V, un módulo IRF520 no funciona aquí; si quieres un módulo, elige uno con MOSFET de nivel lógico.

Riego programado con Raspberry Pi Pico (MicroPython)

En la Pico puedes mover la bomba con un MOSFET en GP15 y hacer un arranque suave con PWM. El arranque suave reparte la corriente de arranque de la bomba en unos cientos de milisegundos y evita una caída brusca de la tensión; si la Pico y la bomba comparten fuente, así se evitan reinicios aleatorios. El código de abajo riega 8 segundos cada 12 horas y añade 3 segundos más al pulsar el botón de GP14. Como los pines de la Pico solo dan 3,3 V, aquí también conviene un MOSFET garantizado a 3,3 V como el AO3400A. Si eres nuevo en MicroPython, echa antes un vistazo a qué es la 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)

El código mide el tiempo con time.ticks_diff(), que da la diferencia correcta incluso cuando el contador se desborda. Como el reloj propio de la Pico se reinicia al apagarla y puede desviarse unos segundos al día, si quieres un horario ligado a la hora real, como «regar cada mañana a las 7:00», añade un módulo RTC o usa una Pico W y toma la hora de internet (NTP). Tras un corte de luz, el contador de 12 horas vuelve a empezar desde cero; para la mayoría de las plantas no importa, pero tenlo en cuenta en proyectos para unas vacaciones largas.

Ideas de proyectos con una mini bomba de agua

• Sistema de riego para vacaciones: Riega tus plantas durante dos semanas con un cubo de agua, unas macetas y mangueras finas que llegan a cada una; el montaje completo está en el proyecto de invernadero inteligente.
• Bebedero automático para mascotas: Cuando baja el nivel del cuenco, la bomba lo rellena desde un depósito; para el nivel sirve un sensor de nivel sin contacto.
• Dispensador de jabón o gel sin contacto: Cuando un HC-SR04 o un sensor infrarrojo detecta la mano, la bomba funciona medio segundo.
• Máquina de cócteles y bebidas: 3–4 bombas, cada una en su botella y con su caudal medido por separado, mezclan según la receta.
• Cascada de escritorio y estanque decorativo: Una fuente cuyo caudal baja de noche con PWM y que se apaga cuando un LDR detecta que la habitación está a oscuras.
• Rellenado automático de acuario: Un sistema que repone el agua evaporada desde otro depósito cuando un interruptor de flotador indica que el nivel ha bajado.
• Integración en la casa inteligente: Conecta la bomba con tus otros dispositivos mediante MQTT y Home Assistant usando un ESP32.

Errores frecuentes y cómo solucionarlos

Bien controlada, una mini bomba sumergible es una pieza barata y silenciosa que funciona años sin problemas: con un MOSFET de nivel lógico, un diodo en inverso, una fuente aparte de 5 V y masa común, tu Arduino queda totalmente a salvo. El resto depende de tu imaginación; con el caudal que has medido puedes dosificar al mililitro, regar según la humedad del suelo o manejar la bomba desde el móvil con un ESP32. En la app BlueGrays encontrarás el proyecto Estación de riego inteligente, junto con proyectos de servidor web con ESP32 y reloj RTC, con esquemas y código paso a paso.