Pompa acqua Arduino: collegare e controllare una mini pompa

Quasi tutti i progetti con una pompa acqua Arduino usano lo stesso componente: una mini pompa sommersa grande come un dito, alimentata a 3–6 V e immersa completamente nell'acqua. È il cuore dei circuiti che innaffiano i vasi, rabboccano un acquario, erogano una dose precisa di liquido come una macchina del caffè o fanno funzionare una piccola fontana. Costa poco, è silenziosa e ha solo due fili; ma poiché al suo interno c'è un motore DC a spazzole, non puoi collegarla direttamente a un pin di Arduino.

In questa guida imparerai passo dopo passo cosa c'è dentro la pompa, perché non va collegata direttamente a un pin e come pilotarla in sicurezza con un MOSFET, un transistor o un relè. Vedremo a cosa serve il diodo di ricircolo, perché la pompa ha bisogno di un'alimentazione separata, come sono legate portata e prevalenza e perché farla girare a secco la distrugge. Poi scriveremo il codice per regolare la velocità in PWM, un dosatore di liquidi preciso al millilitro, l'irrigazione automatica in base all'umidità del terreno, il controllo dal telefono con un ESP32 e l'irrigazione a tempo con un Raspberry Pi Pico.

Che cos'è una mini pompa sommersa e come funziona?

Una mini pompa sommersa è una pompa centrifuga. Dentro il corpo in plastica ci sono un piccolo motore DC a spazzole e una girante a palette montata sul suo albero. Quando il motore gira, la girante spinge verso l'esterno, per forza centrifuga, l'acqua aspirata dal foro inferiore e la manda fuori dall'uscita per il tubo, laterale o superiore. Il vano motore è sigillato, mentre la camera della girante è piena d'acqua. Questo progetto ha due conseguenze importanti: la pompa non è autoadescante (non può spingere aria, quindi deve stare sott'acqua) ed è proprio l'acqua pompata a raffreddare la girante e a lubrificarne l'albero.

I valori della tabella cambiano da modello a modello; controlla sempre l'etichetta della tua pompa o i dati del venditore. Le due righe che contano davvero sono la corrente e la corrente di spunto. Una pompa da 200 mA può assorbire per un attimo 400–600 mA nel momento in cui parte, perché il motore non ha ancora preso velocità. Se non progetti il circuito per questo picco, vedrai Arduino riavviarsi ogni volta che la pompa si accende.

Perché la pompa non si collega direttamente a un pin di Arduino?

L'errore più comune all'inizio è collegare il filo rosso della pompa a un pin digitale, il nero a GND e provare ad accenderla con digitalWrite(HIGH). Ci sono tre problemi distinti. Primo, la corrente: un pin di Arduino Uno regge al massimo 40 mA e il limite sicuro è 20 mA, mentre la pompa ne vuole dieci volte tanto. Secondo, i picchi di tensione: l'avvolgimento del motore è una bobina e, nell'istante in cui la corrente viene interrotta, può generare un breve impulso inverso di centinaia di volt. Terzo, il rumore elettrico: le spazzole del motore fanno scintille a ogni giro e disturbano l'alimentazione. Il risultato è una pompa che non gira o un pin danneggiato per sempre.

La soluzione è che il pin non comandi la pompa ma un interruttore. Il pin fornisce solo un segnale di pochi milliampere; la corrente vera della pompa arriva da un'alimentazione separata e passa attraverso quell'interruttore. Hai quattro possibilità: un MOSFET a livello logico, un transistor NPN, un modulo MOSFET già pronto o un modulo relè. La tabella qui sotto riassume quando conviene ciascuno.

Collegamento della pompa acqua ad Arduino: MOSFET, diodo e GND comune

Il circuito più robusto e flessibile usa un MOSFET a canale N a livello logico che commuta la pompa sul lato basso (low side). Il filo positivo della pompa va direttamente al positivo dell'alimentazione esterna; il negativo si collega al drain del MOSFET. Il source va a GND e il gate, tramite una resistenza, al pin di Arduino. Quando il pin va HIGH, il MOSFET conduce, collega il negativo della pompa a GND e la pompa gira. Sull'IRLZ44N, con il lato stampato verso di te, i piedini da sinistra a destra sono Gate, Drain, Source.

La resistenza di gate limita il picco di corrente prelevato dal pin mentre si carica la capacità di gate del MOSFET; il pull-down da 10 kΩ tiene il gate a GND mentre Arduino si avvia o riceve uno sketch e il pin non è ancora definito. Senza questa resistenza la pompa può girare da sola per qualche secondo a ogni reset; accanto a un vaso significa un bicchiere d'acqua rovesciato sulla scrivania. Il diodo e la massa comune sono così importanti da meritare sezioni a parte.

Diodo di ricircolo: il picco di tensione allo spegnimento della pompa

L'avvolgimento del motore si comporta come una bobina, e una bobina non permette che la sua corrente si interrompa di colpo. Nell'istante in cui il MOSFET si spegne, l'energia accumulata cerca una via d'uscita e crea sul drain un breve picco di tensione ben oltre l'alimentazione. Col tempo questo impulso perfora il MOSFET o il transistor e resetta qualsiasi Arduino sulla stessa linea. La soluzione è un diodo collegato in senso inverso ai capi della pompa: catodo (fascetta) al positivo, anodo al negativo. Nel funzionamento normale il diodo non conduce; quando il MOSFET si spegne, la corrente della bobina ricircola nella pompa attraverso il diodo e l'energia si esaurisce senza danni.

Se commuti la pompa velocemente in PWM, il diodo conduce a ogni periodo, quindi uno Schottky veloce come l'1N5819 è la scelta migliore. Se la accendi e spegni soltanto, va bene anche l'1N4007 che hai nel cassetto. Per ridurre i disturbi delle spazzole puoi saldare anche un condensatore ceramico da 100 nF direttamente ai capi della pompa. Spieghiamo i tipi di diodo e come riconoscerne il verso in cos'è un diodo.

Alimentazione separata e GND comune: perché Arduino si riavvia?

Alimentare la pompa dal pin 5V di Arduino Uno sembra funzionare al primo tentativo, ma non è affidabile. Un Uno alimentato via USB sta tutto dietro un fusibile ripristinabile (polyfuse) da 500 mA, e anche la porta USB del computer di solito fornisce 500 mA. All'avvio della pompa, il picco di 400–600 mA fa scendere la tensione sotto i 4 V per un istante: il microcontrollore si resetta, il monitor seriale si disconnette o il codice si comporta in modo strano. Se invece colleghi un alimentatore al jack dell'Uno, si scalda il regolatore 5 V della scheda: con 9 V in ingresso e una pompa da 250 mA dissipa (9 − 5) × 0,25 = 1 W in calore.

• Alimentatore da 5 V (1–2 A): La soluzione più pratica. La pompa e, se serve, Arduino si alimentano dallo stesso alimentatore, ma con fili separati.
• 4 pile AA (6 V): Ideali per le pompe da 6 V; le pile nuove danno 6,4 V, un valore sicuro per la pompa.
• Batteria Li-ion 18650 (3,7–4,2 V): Adatta alle pompe da 3–5 V; si ricarica con un modulo TP4056.
• Modulo di alimentazione per breadboard: Moduli come l'MB102 portano 5 V e 3,3 V sulla breadboard; bastano per una piccola pompa, dettagli nella guida al modulo di alimentazione MB102.
• Se hai un impianto a 12 V: Abbassalo a 5 V con un convertitore LM2596; non dare mai 12 V direttamente a una pompa da 6 V.

Portata e prevalenza: quanto in alto spinge l'acqua la pompa?

I 100–120 L/h dichiarati dai venditori valgono per una pompa senza tubo, con l'uscita a pelo d'acqua. Nell'uso reale, man mano che l'acqua sale nel tubo la pompa lavora contro la gravità e la portata cala. L'altezza a cui la pompa non riesce più a sollevare acqua si chiama prevalenza massima; a quel punto la girante gira ma dal tubo non esce nulla. Un tubo lungo, sottile o piegato fa lo stesso effetto aggiungendo attrito. La tabella mostra come si comporta a diverse altezze una pompa tipica che dà circa 100 L/h a 5 V con l'uscita libera.

Quindi non calcolare il tempo di irrigazione dal dato di catalogo: misuralo sul tuo montaggio. Tieni il tubo sopra un misurino all'altezza che userai davvero, fai girare la pompa esattamente 10 secondi e leggi l'acqua nel misurino. Se hai misurato 185 ml, per esempio, la tua portata è di 18,5 ml/s; per erogare 250 ml la pompa deve girare 250 / 18,5 ≈ 13,5 secondi. Ripetere la misura tre volte e fare la media riduce l'errore dovuto alla tensione delle pile e al tubo. Se la tensione della pompa cambia (quando le pile si scaricano), cambia anche la portata; per dosare con precisione usa una fonte stabile a 5 V.

Funzionamento a secco ed effetto sifone: i due nemici nascosti della pompa

È l'acqua a lubrificare l'albero della pompa e a raffreddarne il motore. Quando il serbatoio si svuota, la pompa gira in aria, il supporto della girante si scalda per attrito, la plastica si ammorbidisce e il motore va su di giri. Pochi secondi a secco non uccidono la maggior parte delle pompe, ma una pompa che gira a secco per minuti si blocca oppure cambia rumore e perde portata. Nei sistemi automatici ci sono due modi per evitarlo: mettere nel serbatoio un sensore di livello dell'acqua o un interruttore a galleggiante e limitare nel codice quanto può girare la pompa in una volta sola. Il codice di irrigazione automatica più sotto fa entrambe le cose.

Passo dopo passo: il primo test della pompa

1. Immergi completamente la pompa in un contenitore pieno d'acqua e infila 30–50 cm di tubo in silicone sull'uscita; dirigi l'estremità del tubo in un secondo contenitore.
2. Inserisci l'IRLZ44N nella breadboard. Collega il gate a D9 tramite 220 Ω e anche a GND tramite 10 kΩ; collega il source a GND.
3. Collega il filo nero della pompa al drain e il rosso al positivo dell'alimentazione esterna da 5 V. Monta il diodo 1N5819 ai capi della pompa, con la fascetta verso il positivo.
4. Collega il negativo dell'alimentazione esterna al GND di Arduino; ricontrolla i collegamenti e poi accendi l'alimentazione.
5. Carica il codice qui sotto e apri il monitor seriale a 9600 baud. La pompa deve girare 3 secondi e fermarsi per 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 la pompa non gira, controlla prima la massa comune e poi l'ordine dei piedini del MOSFET; se non si ferma, forse drain e source sono invertiti. Per misurare la portata basta cambiare delay(3000) in delay(10000) nello stesso codice e tenere il tubo sopra un misurino. Poiché questo codice usa delay(), Arduino non può fare altro mentre la pompa gira; negli esempi successivi misureremo il tempo con millis(). Se ti interessa la differenza, dai un'occhiata a millis o delay.

Regolare la velocità della pompa con il PWM

Il grande vantaggio del MOSFET è che puoi regolare la velocità della pompa con il PWM. Un flusso lento sembra più naturale in una fontana, smuove meno sporco in un filtro d'acquario e permette un dosaggio più fine. Ci sono due problemi pratici. Primo, le piccole pompe non partono con un duty cycle basso (di solito sotto il 30–40 %) e ronzano soltanto; per questo il codice le avvia con un breve impulso a piena potenza e poi scende alla velocità richiesta. Secondo, il PWM a 490 Hz del pin D9 dell'Uno fa fischiare la pompa in modo udibile; il codice alza la frequenza 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}

Collega il piedino centrale del potenziometro ad A0 e quelli esterni a 5V e GND. La riga TCCR1B riguarda solo il Timer1, cioè i pin D9 e D10; millis() e delay() usano il Timer0 e continuano a funzionare. La libreria Servo però usa anch'essa il Timer1: togli questa riga se nel progetto c'è un servo. Trova MIN_DUTY con la tua pompa: gira lentamente il potenziometro, leggi nel monitor seriale il valore più basso a cui la pompa parte da sola e aggiungi un piccolo margine. Abbassare la tensione della pompa riduce anche la prevalenza; a metà velocità la pompa solleva l'acqua solo fino a circa un quarto dell'altezza a piena velocità, perché la pressione di una pompa centrifuga è proporzionale al quadrato della velocità.

Dosatore di liquidi: 50 ml esatti premendo un pulsante

Una volta misurata la portata, trasformare la pompa in un dosatore è facile: dividi la quantità voluta per la portata e ottieni per quanto tempo deve girare la pompa. Il codice qui sotto eroga 50 ml ogni volta che premi un pulsante collegato tra D2 e GND; se lo premi di nuovo mentre la pompa gira, la dose viene annullata. Poiché il tempo è misurato con millis(), il loop non aspetta mai e può leggere il pulsante di continuo. È la base di progetti come dispenser di sapone, dosatori di concime o macchine per cocktail.

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 la prima dose esce più scarsa delle altre, la causa è quasi sicuramente il tubo vuoto: la pompa prima riempie il tubo e solo dopo eroga il liquido. Tenendo l'estremità del tubo un po' sopra l'acqua del serbatoio, il tubo resta pieno e ogni dose è uguale. Con liquidi densi come olio, sciroppo o sapone la portata è molto più bassa che con l'acqua, quindi calibra sempre con quel liquido. Nei progetti a contatto con alimenti usa un tubo in silicone per uso alimentare e risciacqua la pompa con acqua pulita dopo ogni utilizzo.

Irrigazione automatica in base all'umidità del terreno

Il progetto più popolare con una pompa acqua e Arduino è il vaso che si innaffia da solo quando la terra si asciuga. La trappola in cui cadono i principianti è far girare la pompa finché l'umidità non raggiunge l'obiettivo: l'acqua impiega minuti ad arrivare al sensore e nel frattempo il vaso è già traboccato. Il metodo giusto è irrigare a brevi impulsi: la pompa gira 4 secondi, poi il programma aspetta 1 minuto che l'acqua si distribuisca nella terra e misura di nuovo. Inoltre il codice non avvia mai la pompa se il serbatoio è vuoto e, se dopo 6 impulsi l'umidità non sale ancora (forse il sensore è uscito dalla terra o il tubo si è staccato), blocca il sistema e accende il LED. Spieghiamo la calibrazione del sensore nella guida al sensore di umidità del terreno.

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}

Usare due soglie distinte nel codice è voluto: l'irrigazione parte quando l'umidità scende sotto il 35 %, ma continua finché non arriva al 55 %. Grazie a questa isteresi, la pompa non si accende e spegne di continuo per una lettura che oscilla proprio sulla soglia. Misura DRY_VALUE e WET_VALUE con il tuo sensore; nei sensori capacitivi questi valori dipendono dalla tensione di alimentazione e dalla lunghezza del cavo. Se il filo del galleggiante si rompe, il pin legge HIGH e il codice lo considera serbatoio vuoto; quindi, in caso di guasto, il sistema resta dal lato sicuro e ferma la pompa. Se vuoi irrigare solo in certi orari, aggiungi un modulo orologio RTC e inserisci un controllo dell'ora nella condizione.

Quando conviene comandare la pompa con un relè?

Se hai soltanto un modulo relè, puoi far funzionare la mini pompa anche con quello: il filo positivo va dall'alimentazione esterna al morsetto COM del relè e dal morsetto NO alla pompa; il negativo va al negativo dell'alimentazione. Il relè isola completamente la pompa dal circuito della scheda e con lo stesso modulo puoi commutare grosse pompe a 12 V o pompe per acquario collegate alla rete. In compenso il relè non regola la velocità in PWM, fa clic a ogni commutazione, i contatti si consumano col tempo e la sola bobina assorbe circa 70 mA. Se accendi la pompa poche volte al giorno, il relè va bene; per dosare o regolare la velocità il MOSFET è sempre migliore. Anche con il relè, un diodo ai capi della pompa riduce l'arco sui contatti.

Controllare la pompa acqua dal telefono con un ESP32

Grazie al Wi-Fi dell'ESP32 puoi avviare la pompa dal browser del telefono. Il codice qui sotto avvia un piccolo server web sull'ESP32; aprendo da un telefono sulla stessa rete l'indirizzo IP mostrato nel monitor seriale, vedrai i pulsanti per irrigare 5 e 15 secondi e un pulsante di stop. Non serve nessuna libreria aggiuntiva: WebServer è incluso nel core ESP32. Per sicurezza la pompa non gira mai più di 30 secondi; anche se la connessione cade, si ferma da sola allo scadere del tempo. Poiché l'ESP32 lavora a 3,3 V, scegli un MOSFET che conduca pienamente a 3,3 V: l'AO3400A è il migliore e l'IRLZ44N basta comunque per i 300 mA di una mini pompa.

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}

Questa pagina si apre solo dalla rete Wi-Fi di casa. Se vuoi controllare la pompa anche da fuori o ricevere un avviso quando il serbatoio è vuoto, aggiungi a questo codice i metodi delle guide bot Telegram con ESP32 o Blynk. Per trasformare la pagina in una dashboard che si aggiorna all'istante via WebSocket, guarda la guida web server asincrono con ESP32. Poiché i pin dell'ESP32 danno 3,3 V, un modulo IRF520 qui non funziona; se vuoi un modulo, scegline uno con MOSFET a livello logico.

Irrigazione a tempo con Raspberry Pi Pico (MicroPython)

Sul Pico puoi pilotare la pompa con un MOSFET su GP15 e darle un avvio graduale in PWM. L'avvio graduale distribuisce la corrente di spunto su qualche centinaio di millisecondi ed evita un calo improvviso della tensione; se Pico e pompa condividono l'alimentazione, così si evitano reset casuali. Il codice qui sotto irriga per 8 secondi ogni 12 ore e aggiunge 3 secondi quando premi il pulsante su GP14. Poiché i pin del Pico danno solo 3,3 V, anche qui scegli un MOSFET garantito a 3,3 V come l'AO3400A. Se sei alle prime armi con MicroPython, dai prima un'occhiata a cos'è il 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)

Il codice misura il tempo con time.ticks_diff(), che restituisce la differenza giusta anche quando il contatore si azzera. Poiché l'orologio interno del Pico riparte da zero allo spegnimento e può sgarrare di qualche secondo al giorno, se vuoi un programma legato all'ora reale, come «irrigare ogni mattina alle 7:00», aggiungi un modulo RTC oppure usa un Pico W e prendi l'ora da internet (NTP). Dopo un'interruzione di corrente il contatore di 12 ore riparte da zero; per la maggior parte delle piante non importa, ma tienilo presente nei progetti che devono funzionare durante una lunga vacanza.

Idee di progetti con una mini pompa acqua

• Irrigazione per le vacanze: Innaffia le piante per due settimane con un secchio d'acqua, qualche vaso e tubi sottili che arrivano a ciascun vaso; il montaggio completo è nel progetto della serra intelligente.
• Ciotola d'acqua automatica per animali: Quando il livello nella ciotola scende, la pompa la rabbocca da un serbatoio; per il livello va bene un sensore di livello senza contatto.
• Dispenser di sapone o gel senza contatto: Quando un HC-SR04 o un sensore a infrarossi vede la mano, la pompa gira per mezzo secondo.
• Macchina per cocktail e bevande: 3–4 pompe, ognuna nella sua bottiglia e con la portata misurata a parte, preparano i mix secondo la ricetta.
• Cascata da scrivania e laghetto decorativo: Una fontana il cui flusso rallenta di notte con il PWM e che si spegne quando un LDR vede la stanza al buio.
• Rabbocco automatico dell'acquario: Un sistema che reintegra l'acqua evaporata da un serbatoio separato quando un interruttore a galleggiante segnala che il livello è sceso.
• Integrazione domotica: Collega la pompa agli altri dispositivi tramite MQTT e Home Assistant con un ESP32.

Errori comuni e come risolverli

Pilotata nel modo giusto, una mini pompa sommersa è un componente economico e silenzioso che funziona per anni senza problemi: con un MOSFET a livello logico, un diodo in inverso, un'alimentazione separata a 5 V e la massa comune, il tuo Arduino resta completamente al sicuro. Il resto dipende dalla tua fantasia; con la portata che hai misurato puoi dosare al millilitro, irrigare in base all'umidità del terreno o gestire la pompa dal telefono con un ESP32. Nell'app BlueGrays trovi il progetto Stazione di irrigazione intelligente, insieme a progetti di web server ESP32 e orologio RTC, con schemi e codice passo dopo passo.