Bomba de água com Arduino: como ligar e controlar uma mini bomba submersível

Quase todo projeto de bomba de água com Arduino usa a mesma peça: uma mini bomba submersível do tamanho de um dedo, que funciona com 3–6 V e fica totalmente dentro da água. Ela é o coração de circuitos que regam vasos de plantas, completam a água de um aquário, servem uma quantidade definida de líquido como uma máquina de café ou fazem funcionar uma pequena fonte. É barata e silenciosa e tem só dois fios. Mas como há um motor CC com escovas dentro dela, não dá para ligá-la direto em um pino do Arduino.

Neste guia você vai aprender, passo a passo, o que há dentro da bomba, por que ela não vai direto no pino e como acioná-la com segurança usando um MOSFET, transistor ou relé. Vamos falar da função do diodo de roda livre, de por que a bomba precisa de uma fonte de alimentação própria, de como a vazão depende da altura de elevação e de por que funcionar a seco acaba com a bomba. Depois vamos escrever código para controle de velocidade por PWM, um dosador de líquidos com precisão de mililitro, irrigação automática conforme a umidade do solo, controle pelo celular com ESP32 e irrigação programada com Raspberry Pi Pico.

O que é uma mini bomba submersível e como ela funciona?

Uma mini bomba submersível é uma bomba centrífuga. Dentro do corpo de plástico há um pequeno motor CC com escovas e um rotor com aletas preso ao eixo. Conforme o motor gira, o rotor lança para fora a água que entra pelo furo de entrada na parte de baixo e a empurra pela saída da mangueira, na lateral ou no topo. O compartimento do motor é vedado contra a água, enquanto a câmara do rotor fica cheia de água. Esse projeto tem duas consequências importantes: a bomba não é autoescorvante (não consegue bombear ar, então precisa ficar abaixo da água) e é a própria água bombeada que resfria o rotor e lubrifica o mancal.

Os valores da tabela mudam de modelo para modelo. Confira sempre a etiqueta da sua bomba ou os dados do vendedor. As duas linhas que realmente importam são corrente e corrente de partida. Uma bomba de 200 mA pode puxar 400–600 mA por um instante na partida, porque o motor ainda não ganhou velocidade. Se o seu circuito não for pensado para esse pico, o Arduino vai reiniciar toda vez que a bomba ligar.

Por que a bomba não pode ir direto em um pino do Arduino?

O erro mais comum de quem está começando é ligar o fio vermelho da bomba em um pino digital, o preto no GND, e tentar acioná-la com digitalWrite(HIGH). Isso tem três problemas diferentes. Primeiro, a corrente: um pino do Arduino Uno aguenta no máximo 40 mA e o limite seguro é 20 mA, enquanto a bomba quer dez vezes isso. Segundo, os picos de tensão: o enrolamento do motor é uma bobina e, no instante em que a corrente é cortada, pode gerar um pulso curto de centenas de volts no sentido contrário. Terceiro, o ruído elétrico: as escovas de um motor com escovas soltam faíscas a cada volta e espalham interferência na linha de alimentação. O resultado é uma bomba que nunca gira ou um pino danificado para sempre.

A solução é o pino controlar uma chave, e não a bomba. O pino fornece só um sinal de poucos miliampères; a corrente de verdade da bomba vem de uma fonte de alimentação separada e passa por essa chave. Você tem quatro opções de chave: um MOSFET de nível lógico, um transistor NPN, um módulo MOSFET pronto ou um módulo relé. A tabela abaixo resume quando cada um faz sentido.

Ligação da bomba de água no Arduino: MOSFET, diodo e GND comum

O circuito mais robusto e flexível é um MOSFET de nível lógico de canal N que chaveia a bomba pelo lado baixo (low-side). O fio positivo da bomba vai direto ao positivo da fonte externa; o fio negativo vai ao dreno do MOSFET. A fonte (source) do MOSFET vai ao GND e o gate vai ao pino do Arduino através de um resistor. Quando o pino vai para HIGH, o MOSFET conduz, liga o negativo da bomba ao GND e a bomba gira. No IRLZ44N, com o lado escrito virado para você, os terminais da esquerda para a direita são Gate, Dreno, Fonte.

O resistor de gate limita o pico de corrente puxado do pino enquanto a capacitância do gate do MOSFET carrega; o pull-down de 10 kΩ mantém o gate em GND enquanto o Arduino inicializa ou recebe código e o pino ainda está indefinido. Sem esse resistor, a bomba pode funcionar sozinha por alguns segundos a cada reinicialização; ao lado de um vaso, isso significa um copo de água derramado na sua mesa. O diodo e o GND comum são importantes o bastante para ganhar seções próprias.

Diodo de roda livre: o pico de tensão quando a bomba desliga

O enrolamento do motor se comporta como uma bobina, e uma bobina não deixa a corrente que passa por ela parar de repente. No instante em que o MOSFET desliga, a energia guardada no enrolamento procura uma saída e cria no dreno um pico de tensão curto, bem acima da tensão de alimentação. Com o tempo, esse pulso fura o MOSFET ou o transistor e reinicia qualquer Arduino na mesma linha. A solução é um diodo ligado entre os dois terminais da bomba no sentido inverso: cátodo (lado com a faixa) no positivo, ânodo no negativo. Em funcionamento normal o diodo não conduz corrente nenhuma; quando o MOSFET desliga, a corrente da bobina circula de volta pelo diodo para a bomba e a energia se dissipa sem causar danos.

Se você vai ligar e desligar a bomba rapidamente com PWM, o diodo conduz a cada período, então um diodo Schottky rápido como o 1N5819 é a melhor escolha. Se for só ligar e desligar, aquele 1N4007 que você tem na gaveta resolve. Para reduzir o ruído das escovas, você também pode soldar um capacitor cerâmico de 100 nF entre os terminais da bomba. Explicamos os tipos de diodo e como descobrir o sentido deles em o que é diodo.

Fonte separada e GND comum: por que o Arduino reinicia?

Alimentar a bomba pelo pino 5V do Arduino Uno parece funcionar na primeira tentativa, mas não é confiável. Um Uno alimentado por USB fica inteiro atrás de um fusível de 500 mA (polyfuse), e a porta USB do computador normalmente também fornece 500 mA. Quando a bomba parte, o pico de 400–600 mA derruba a tensão para menos de 4 V por um instante; o microcontrolador reinicia, o Monitor Serial desconecta ou o código se comporta de um jeito estranho. Se em vez disso você ligar um adaptador no conector DC do Uno, o regulador de 5 V da placa esquenta: com 9 V de entrada e uma bomba de 250 mA, o regulador transforma (9 − 5) × 0,25 = 1 W em calor.

• Adaptador de 5 V (1–2 A): A solução mais prática. A bomba e, se necessário, o Arduino são alimentados pelo mesmo adaptador, mas com fios separados.
• 4 pilhas AA (6 V): Ideal para bombas de 6 V; pilhas novas dão 6,4 V, o que é seguro para a bomba.
• Li-ion 18650 (3,7–4,2 V): Boa para bombas de 3–5 V; carregue com um módulo TP4056.
• Módulo de alimentação para protoboard: Módulos como o MB102 fornecem 5 V e 3,3 V à protoboard; bastam para uma bomba pequena, detalhes no guia do módulo de alimentação para protoboard.
• Se você tem um sistema de 12 V: Abaixe para 5 V com um conversor buck LM2596; nunca ligue 12 V direto em uma bomba de 6 V.

Vazão e altura de elevação: até que altura a bomba leva a água?

A vazão de 100–120 L/h que os vendedores informam vale para a bomba sem mangueira e com a saída na superfície da água. No uso real, à medida que a água sobe pela mangueira, a bomba trabalha contra a gravidade e a vazão cai. A altura em que a bomba não consegue mais elevar água nenhuma se chama altura máxima de elevação (altura manométrica); nesse ponto o rotor gira, mas não sai nada pela mangueira. Uma mangueira longa, fina ou dobrada tem o mesmo efeito, porque acrescenta atrito. A tabela abaixo mostra como uma bomba típica, que entrega cerca de 100 L/h em 5 V com a saída livre, se comporta em alturas diferentes.

Por isso, não calcule o tempo de irrigação com o valor do catálogo; meça na sua própria montagem. Segure a mangueira sobre um copo medidor na altura que você vai usar de verdade, ligue a bomba por exatamente 10 segundos e leia a água no copo. Se você mediu 185 ml, por exemplo, sua vazão é 18,5 ml/s; para entregar 250 ml, a bomba precisa funcionar 250 / 18,5 ≈ 13,5 segundos. Repetir a medição três vezes e tirar a média reduz o erro causado pela tensão da bateria e por diferenças na mangueira. Se a tensão da bomba muda (conforme as pilhas se descarregam), a vazão também muda; para dosagem precisa, use uma fonte estável de 5 V.

Funcionar a seco e efeito sifão: os dois inimigos escondidos da bomba

É a água que lubrifica o mancal da bomba e resfria o motor. Quando o reservatório esvazia, a bomba gira no ar, o mancal do rotor esquenta com o atrito, as peças de plástico amolecem e o motor gira mais rápido que o normal. Alguns segundos a seco não matam a maioria das bombas, mas uma bomba que funciona a seco por minutos trava ou começa a fazer um barulho diferente e perde vazão. Em sistemas automáticos há duas formas de evitar isso: colocar um sensor de nível de água ou uma chave boia no reservatório e limitar no código quanto tempo a bomba pode funcionar de uma vez. O código de irrigação automática abaixo faz as duas coisas.

Passo a passo: seu primeiro teste com a bomba

1. Mergulhe a bomba totalmente em um recipiente com água e encaixe 30–50 cm de mangueira de silicone na saída; aponte a ponta da mangueira para um segundo recipiente.
2. Coloque o IRLZ44N na protoboard. Ligue o gate ao D9 por um resistor de 220 Ω e também ao GND por 10 kΩ; ligue a fonte (source) ao GND.
3. Ligue o fio preto da bomba ao dreno e o fio vermelho ao positivo da fonte externa de 5 V. Coloque o diodo 1N5819 entre os terminais da bomba, com o lado da faixa no positivo.
4. Ligue o negativo da fonte externa ao GND do Arduino; confira as ligações mais uma vez e então ligue a fonte.
5. Carregue o código abaixo e abra o Monitor Serial em 9600 baud. A bomba deve funcionar por 3 segundos e parar por 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}

Se a bomba não funcionar, confira primeiro o GND comum e depois a ordem dos terminais do MOSFET; se ela não parar, o dreno e a fonte podem estar trocados. Para medir a vazão, basta trocar delay(3000) por delay(10000) no mesmo código e segurar a mangueira sobre um copo medidor. Como este código usa delay(), o Arduino não consegue fazer mais nada enquanto a bomba funciona; nos próximos exemplos vamos marcar o tempo com millis(). Se estiver curioso sobre a diferença, dê uma olhada em millis ou delay.

Ajustando a velocidade da bomba com PWM

A maior vantagem do MOSFET é poder ajustar a velocidade da bomba com PWM. Um fluxo lento fica mais natural em uma fonte, levanta menos sujeira em um filtro de aquário e permite dosagem mais fina. Há dois problemas práticos. Primeiro, bombas pequenas não conseguem partir com ciclo de trabalho baixo (normalmente abaixo de 30–40%) e só zumbem; por isso o código dá a partida com um pulso curto de potência total e depois baixa para a velocidade pedida. Segundo, o PWM de 490 Hz no pino D9 do Uno faz a bomba chiar de forma audível; o código sobe essa frequência para 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}

Ligue o pino do meio do potenciômetro ao A0 e os pinos das pontas ao 5V e ao GND. A linha TCCR1B afeta só o Timer1, ou seja, os pinos D9 e D10; millis() e delay() usam o Timer0, então continuam funcionando. Porém a biblioteca Servo também usa o Timer1, então remova essa linha se o seu projeto tiver um servo. Encontre o MIN_DUTY com a sua própria bomba: gire o potenciômetro devagar, leia no Monitor Serial o menor valor em que a bomba consegue partir sozinha e acrescente uma pequena margem. Baixar a tensão da bomba também baixa a altura de elevação; na metade da velocidade, a bomba só consegue elevar a água a cerca de um quarto da altura que alcança em velocidade total, porque a pressão de uma bomba centrífuga é proporcional ao quadrado da rotação.

Dosador de líquidos: exatamente 50 ml com um toque no botão

Depois de medir a vazão, transformar a bomba em uma máquina dosadora é fácil: divida a quantidade desejada pela vazão e você tem o tempo que a bomba precisa funcionar. O código abaixo serve 50 ml cada vez que você aperta um botão ligado entre D2 e GND; apertar o botão de novo com a bomba funcionando cancela a dose. Como o tempo é medido com millis(), o loop nunca fica esperando e pode ler o botão o tempo todo. Essa é a base de projetos como dispensers de sabonete, dosadores de adubo para plantas ou máquinas de coquetel.

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}

Se a primeira dose sair menor que as outras, a causa mais provável é a mangueira vazia: a bomba enche a mangueira primeiro e só depois entrega o líquido. Manter a ponta da mangueira um pouco acima da água do reservatório deixa a mangueira cheia, e assim todas as doses saem iguais. Com líquidos grossos como óleo, xarope ou sabonete, a vazão é bem menor que com água, então calibre sempre com o próprio líquido. Em projetos que entram em contato com alimentos, use mangueira de silicone de grau alimentício e enxágue a bomba com água limpa depois de cada uso.

Irrigação automática conforme a umidade do solo

O projeto de bomba de água com Arduino mais popular é o vaso que se rega sozinho quando a terra seca. A armadilha em que os iniciantes caem é deixar a bomba ligada até a umidade do solo chegar ao valor desejado: a água leva minutos para chegar ao sensor e, até lá, o vaso já transbordou. O método certo é regar em pulsos curtos: a bomba funciona por 4 segundos, depois espera 1 minuto para a água se espalhar na terra e mede a umidade de novo. O código também nunca liga a bomba com o reservatório vazio e, se a umidade ainda não tiver subido depois de 6 pulsos (o sensor pode ter saído da terra ou a mangueira pode ter se soltado), trava o sistema e acende o LED. Tratamos da calibração do sensor em detalhes no guia do sensor de umidade do solo.

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 dois limites separados no código é proposital: a irrigação começa quando a umidade cai abaixo de 35%, mas continua até chegar a 55%. Graças a essa histerese, a bomba não fica ligando e desligando por causa de uma leitura que oscila bem em cima do limite. Meça DRY_VALUE e WET_VALUE com o seu próprio sensor; em sensores capacitivos esses valores dependem da tensão de alimentação e do comprimento do cabo. Se o fio da chave boia se romper, o pino lê HIGH e o código trata isso como reservatório vazio; ou seja, se algo falhar, o sistema fica do lado seguro e para a bomba. Se quiser regar só em certos horários do dia, adicione um módulo RTC e inclua uma verificação de horário na condição.

Quando faz sentido usar relé para controlar a bomba?

Se tudo o que você tem é um módulo relé, também dá para acionar a mini bomba com ele: o fio positivo da bomba vai da fonte externa ao terminal COM do relé e do terminal NA (NO) até a bomba; o fio negativo vai ao negativo da fonte. O relé isola totalmente a bomba do circuito da placa, e o mesmo módulo pode chavear bombas grandes de 12 V ou bombas de aquário ligadas na rede elétrica. Por outro lado, o relé não permite controle de velocidade por PWM, faz clique a cada chaveamento, seus contatos se desgastam com o tempo e só a bobina já puxa cerca de 70 mA. Se você liga e desliga a bomba poucas vezes por dia, o relé resolve; se precisa de dosagem ou controle de velocidade, o MOSFET é sempre melhor. Mesmo com relé, um diodo entre os terminais da bomba reduz o arco nos contatos.

Controlando a bomba de água pelo celular com ESP32

Graças ao Wi-Fi do ESP32, você pode acionar a bomba pelo navegador do celular. O código abaixo cria um pequeno servidor web no ESP32; ao abrir, em um celular na mesma rede, o endereço IP mostrado no Monitor Serial, você vê botões para 5 e 15 segundos de irrigação e um botão de parar. Não é preciso biblioteca extra, porque a WebServer já vem com o core do ESP32. Por segurança, a bomba nunca funciona mais de 30 segundos; mesmo que a conexão caia, ela para sozinha quando o tempo acaba. Como o ESP32 trabalha com 3,3 V, escolha um MOSFET que abra totalmente com 3,3 V: o AO3400A é o melhor, e o IRLZ44N ainda dá conta com folga dos 300 mA de uma 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 só abre pela rede Wi-Fi da sua casa. Se também quiser controlar a bomba de fora ou receber um aviso quando o reservatório secar, você pode acrescentar a este código os métodos dos guias bot do Telegram com ESP32 ou Blynk. Para transformar a página em um painel que se atualiza na hora via WebSocket, veja o guia ESP32 Async Web Server. Como os pinos do ESP32 têm saída de 3,3 V, um módulo IRF520 não funciona aqui; se quiser usar um módulo, escolha um com MOSFET de nível lógico.

Irrigação programada com Raspberry Pi Pico (MicroPython)

No Pico, você pode acionar a bomba por um MOSFET no GP15 e dar uma partida suave com PWM. A partida suave espalha a corrente de partida da bomba por algumas centenas de milissegundos e evita uma queda brusca na tensão de alimentação; se o Pico e a bomba dividem a mesma fonte, isso evita reinicializações aleatórias. O código abaixo rega por 8 segundos a cada 12 horas e acrescenta 3 segundos extras quando você aperta o botão no GP14. Como os pinos do Pico fornecem só 3,3 V, prefira também aqui um MOSFET garantido para 3,3 V, como o AO3400A. Se você é novo no MicroPython, dê uma olhada antes em o que é 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)

O código mede o tempo com time.ticks_diff(), que devolve a diferença correta mesmo quando o contador dá a volta. Como o relógio do próprio Pico zera quando ele é desligado e pode atrasar ou adiantar alguns segundos por dia, se você quer uma programação ligada ao horário real, como “regar todo dia às 07:00”, adicione um módulo RTC ou use um Pico W e pegue o horário da internet (NTP). Depois de uma queda de energia, o contador de 12 horas recomeça do zero; isso não é problema para a maioria das plantas, mas leve em conta em projetos que funcionam enquanto você está fora em férias longas.

Ideias de projetos com mini bomba de água

• Sistema de irrigação para as férias: Regue suas plantas por duas semanas com um balde de água, alguns vasos e mangueiras finas que se ramificam até cada vaso; a montagem completa está no projeto de estufa inteligente.
• Bebedouro automático para pets: Quando o nível da água no pote baixa, a bomba completa a partir de um reservatório; um sensor de nível de líquido sem contato funciona bem para o nível.
• Dispenser de sabonete ou álcool em gel sem toque: Quando um HC-SR04 ou um sensor infravermelho detecta a mão, a bomba funciona por meio segundo.
• Máquina de coquetéis e bebidas: 3–4 bombas, cada uma em sua garrafa e cada uma com a vazão medida separadamente, preparam bebidas conforme a receita.
• Cascata de mesa e laguinho decorativo: Uma fonte cujo fluxo diminui à noite com PWM e desliga quando um LDR percebe que o ambiente escureceu.
• Reposição de água do aquário: Um sistema que repõe a água evaporada a partir de um reservatório separado quando uma chave boia indica que o nível baixou.
• Integração com casa inteligente: Conecte a bomba aos seus outros dispositivos via MQTT e Home Assistant com um ESP32.

Erros comuns e como corrigir

Acionada do jeito certo, a mini bomba submersível é uma peça barata e silenciosa que funciona por anos sem problemas: com um MOSFET de nível lógico, um diodo invertido, uma fonte separada de 5 V e GND comum, seu Arduino fica totalmente seguro. O resto fica por conta da sua imaginação; com a vazão que você mediu, dá para dosar com precisão de mililitro, irrigar conforme a umidade do solo ou gerenciar a bomba pelo celular com um ESP32. No app BlueGrays você encontra o projeto Estação de irrigação inteligente, além de projetos de servidor web com ESP32 e de relógio RTC, com esquemas do circuito e código passo a passo.