Pompe à eau Arduino : brancher et piloter une mini pompe immergée

Presque tous les projets de pompe à eau Arduino utilisent la même pièce : une mini pompe immergée grande comme un doigt, alimentée en 3–6 V et plongée entièrement dans l'eau. C'est le cœur des montages qui arrosent des pots de fleurs, complètent un aquarium, distribuent une dose précise de liquide comme une machine à café ou animent une petite fontaine. Elle est bon marché, silencieuse et n'a que deux fils ; mais comme elle contient un moteur à courant continu à balais, tu ne peux pas la brancher directement sur une broche de l'Arduino.

Dans ce guide, tu vas apprendre pas à pas ce qu'il y a dans la pompe, pourquoi elle ne se branche pas directement sur une broche et comment la piloter en toute sécurité avec un MOSFET, un transistor ou un relais. Nous verrons le rôle de la diode de roue libre, pourquoi la pompe a besoin de sa propre alimentation, le lien entre débit et hauteur de refoulement, et pourquoi la faire tourner à sec la tue. Ensuite, nous écrirons le code pour régler la vitesse en PWM, un distributeur de liquide précis au millilitre, un arrosage automatique selon l'humidité du sol, le pilotage depuis le téléphone avec un ESP32 et un arrosage programmé avec un Raspberry Pi Pico.

Qu'est-ce qu'une mini pompe immergée et comment fonctionne-t-elle ?

Une mini pompe immergée est une pompe centrifuge. Dans le boîtier en plastique se trouvent un petit moteur à courant continu à balais et une turbine à ailettes fixée sur son axe. Quand le moteur tourne, la turbine projette vers l'extérieur, par force centrifuge, l'eau aspirée par l'orifice du bas et la refoule par la sortie pour tuyau sur le côté ou en haut. Le compartiment moteur est étanche, tandis que la chambre de la turbine est pleine d'eau. Cette conception a deux conséquences importantes : la pompe n'est pas auto-amorçante (elle ne peut pas pousser de l'air, elle doit donc être sous l'eau) et c'est l'eau pompée elle-même qui refroidit la turbine et lubrifie son axe.

Les valeurs du tableau varient d'un modèle à l'autre ; vérifie toujours l'étiquette de ta pompe ou les données du vendeur. Les deux lignes qui comptent vraiment sont le courant et le courant de démarrage. Une pompe de 200 mA peut appeler brièvement 400 à 600 mA au moment où elle démarre, car le moteur n'a pas encore pris sa vitesse. Si ton montage n'est pas prévu pour ce pic, tu verras l'Arduino redémarrer à chaque mise en marche de la pompe.

Pourquoi ne pas brancher la pompe directement sur une broche de l'Arduino ?

L'erreur de débutant la plus fréquente consiste à brancher le fil rouge de la pompe sur une broche numérique, le noir sur GND, et à essayer de la lancer avec digitalWrite(HIGH). Cela pose trois problèmes distincts. D'abord le courant : une broche d'Arduino Uno supporte au maximum 40 mA et la limite sûre est de 20 mA, alors que la pompe en demande dix fois plus. Ensuite les surtensions : le bobinage du moteur est une bobine et, au moment où le courant est coupé, il peut produire une brève impulsion inverse de plusieurs centaines de volts. Enfin le bruit électrique : les balais du moteur produisent des étincelles à chaque tour et polluent l'alimentation. Résultat : une pompe qui ne tourne pas ou une broche abîmée pour de bon.

La solution : la broche ne commande pas la pompe mais un interrupteur. Elle ne fournit qu'un signal de quelques milliampères ; le vrai courant de la pompe vient d'une alimentation séparée et passe par cet interrupteur. Tu as quatre possibilités : un MOSFET à niveau logique, un transistor NPN, un module MOSFET tout fait ou un module relais. Le tableau ci-dessous résume quand chacun convient.

Branchement de la pompe à eau sur l'Arduino : MOSFET, diode et masse commune

Le montage le plus solide et le plus souple utilise un MOSFET canal N à niveau logique qui commute la pompe côté bas (low side). Le fil positif de la pompe va directement au plus de l'alimentation externe ; le fil négatif se branche sur le drain du MOSFET. La source va au GND et la grille, à travers une résistance, à la broche de l'Arduino. Quand la broche passe à HIGH, le MOSFET conduit, relie le négatif de la pompe au GND et la pompe tourne. Sur l'IRLZ44N, face imprimée vers toi, les pattes de gauche à droite sont Gate, Drain, Source.

La résistance de grille limite le courant d'appel tiré sur la broche pendant que la capacité de grille du MOSFET se charge ; le pull-down de 10 kΩ maintient la grille au GND pendant que l'Arduino démarre ou reçoit un programme et que la broche n'est pas encore définie. Sans cette résistance, la pompe peut tourner seule quelques secondes à chaque reset ; à côté d'un pot de fleurs, c'est un verre d'eau renversé sur ton bureau. La diode et la masse commune sont assez importantes pour avoir chacune leur partie.

Diode de roue libre : la surtension à l'arrêt de la pompe

Le bobinage du moteur se comporte comme une bobine, et une bobine refuse que son courant s'arrête brutalement. Au moment où le MOSFET se bloque, l'énergie stockée cherche une issue et crée sur le drain une brève surtension bien supérieure à la tension d'alimentation. À la longue, cette impulsion claque le MOSFET ou le transistor et fait redémarrer tout Arduino sur la même ligne. La solution est une diode montée en inverse aux bornes de la pompe : cathode (bague) au plus, anode au moins. En fonctionnement normal elle ne conduit rien ; quand le MOSFET se bloque, le courant de la bobine reboucle dans la pompe à travers la diode et l'énergie s'éteint sans dégâts.

Si tu commutes la pompe rapidement en PWM, la diode conduit à chaque période : une Schottky rapide comme la 1N5819 est alors le meilleur choix. Pour un simple marche/arrêt, la 1N4007 de ton tiroir suffit. Pour réduire les parasites des balais, tu peux aussi souder un condensateur céramique de 100 nF directement aux bornes de la pompe. Nous expliquons les types de diodes et comment repérer leur sens dans qu'est-ce qu'une diode.

Alimentation séparée et masse commune : pourquoi l'Arduino redémarre-t-il ?

Alimenter la pompe par la broche 5V de l'Arduino Uno semble marcher au premier essai, mais ce n'est pas fiable. Un Uno alimenté par USB se trouve entièrement derrière un fusible réarmable (polyfuse) de 500 mA, et le port USB de l'ordinateur fournit en général 500 mA lui aussi. Au démarrage de la pompe, l'appel de 400 à 600 mA fait chuter la tension sous 4 V pendant un instant : le microcontrôleur redémarre, le moniteur série se déconnecte ou le code se comporte bizarrement. Si tu branches plutôt un adaptateur sur le jack de l'Uno, c'est le régulateur 5 V de la carte qui chauffe : avec 9 V en entrée et une pompe de 250 mA, il transforme (9 − 5) × 0,25 = 1 W en chaleur.

• Adaptateur 5 V (1–2 A) : La solution la plus pratique. La pompe et, si besoin, l'Arduino sont alimentés par le même adaptateur, mais par des fils séparés.
• 4 piles AA (6 V) : Idéal pour les pompes 6 V ; des piles neuves donnent 6,4 V, ce qui reste sans danger pour la pompe.
• Accu Li-ion 18650 (3,7–4,2 V) : Convient aux pompes 3–5 V ; on le recharge avec un module TP4056.
• Module d'alimentation pour breadboard : Les modules comme le MB102 fournissent 5 V et 3,3 V à la breadboard ; assez pour une petite pompe, détails dans le guide module d'alimentation MB102.
• Si tu as un système 12 V : Abaisse-le à 5 V avec un convertisseur LM2596 ; ne mets jamais 12 V directement sur une pompe 6 V.

Débit et hauteur de refoulement : jusqu'où la pompe monte-t-elle l'eau ?

Les 100 à 120 L/h annoncés par les vendeurs valent pour une pompe sans tuyau, sortie au ras de l'eau. En pratique, plus l'eau monte dans le tuyau, plus la pompe lutte contre la gravité et plus le débit baisse. La hauteur à laquelle la pompe ne peut plus du tout monter l'eau s'appelle la hauteur de refoulement maximale ; à ce point, la turbine tourne mais rien ne sort du tuyau. Un tuyau long, fin ou plié fait le même effet en ajoutant du frottement. Le tableau montre le comportement, selon la hauteur, d'une pompe typique qui donne environ 100 L/h en 5 V sortie libre.

Ne calcule donc pas la durée d'arrosage à partir du chiffre du catalogue : mesure-la sur ton propre montage. Tiens le tuyau au-dessus d'un verre doseur à la hauteur réelle d'utilisation, fais tourner la pompe exactement 10 secondes et lis la quantité d'eau. Si tu as mesuré 185 ml, par exemple, ton débit est de 18,5 ml/s ; pour verser 250 ml, la pompe doit tourner 250 / 18,5 ≈ 13,5 secondes. Répéter la mesure trois fois et faire la moyenne réduit l'erreur due à la tension des piles et au tuyau. Si la tension de la pompe change (quand les piles faiblissent), le débit change aussi ; pour un dosage précis, utilise une source 5 V stable.

Marche à sec et effet siphon : les deux ennemis cachés de la pompe

C'est l'eau qui lubrifie l'axe de la pompe et refroidit son moteur. Quand le réservoir est vide, la pompe tourne dans l'air, le palier de la turbine chauffe par frottement, le plastique ramollit et le moteur s'emballe. Quelques secondes à sec ne tuent pas la plupart des pompes, mais une pompe qui tourne à sec pendant des minutes se grippe ou change de bruit et perd du débit. Dans un système automatique, deux moyens l'évitent : placer un capteur de niveau d'eau ou un interrupteur à flotteur dans le réservoir, et limiter dans le code la durée de fonctionnement d'un seul cycle. Le code d'arrosage automatique plus bas fait les deux.

Pas à pas : le premier test de la pompe

1. Plonge entièrement la pompe dans un récipient rempli d'eau et fixe 30 à 50 cm de tuyau silicone sur la sortie ; dirige le bout du tuyau vers un second récipient.
2. Place l'IRLZ44N sur la breadboard. Relie la grille à D9 par 220 Ω et aussi au GND par 10 kΩ ; relie la source au GND.
3. Branche le fil noir de la pompe sur le drain et le fil rouge sur le plus de l'alimentation externe 5 V. Mets la diode 1N5819 aux bornes de la pompe, bague côté plus.
4. Relie le moins de l'alimentation externe au GND de l'Arduino ; vérifie encore une fois le câblage, puis mets l'alimentation sous tension.
5. Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds. La pompe doit tourner 3 secondes puis s'arrêter 10 secondes.

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 pompe ne tourne pas, vérifie d'abord la masse commune, puis l'ordre des pattes du MOSFET ; si elle ne s'arrête pas, drain et source sont peut-être inversés. Pour mesurer le débit, remplace simplement delay(3000) par delay(10000) dans le même code et tiens le tuyau au-dessus d'un verre doseur. Comme ce code utilise delay(), l'Arduino ne peut rien faire d'autre pendant que la pompe tourne ; dans les exemples suivants, nous compterons le temps avec millis(). Pour comprendre la différence, jette un œil à millis ou delay.

Régler la vitesse de la pompe en PWM

Le grand avantage du MOSFET est de pouvoir régler la vitesse de la pompe en PWM. Un débit lent paraît plus naturel dans une fontaine, remue moins la saleté dans un filtre d'aquarium et permet un dosage plus fin. Il y a deux problèmes pratiques. D'abord, les petites pompes ne démarrent pas avec un rapport cyclique faible (en général sous 30–40 %) et se contentent de bourdonner ; le code les lance donc par une courte impulsion à pleine puissance avant de descendre à la vitesse voulue. Ensuite, le PWM à 490 Hz de la broche D9 de l'Uno fait siffler la pompe de façon audible ; le code monte cette fréquence à 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}

Relie le curseur du potentiomètre à A0 et ses bornes extrêmes à 5V et GND. La ligne TCCR1B ne touche que le Timer1, c'est-à-dire les broches D9 et D10 ; millis() et delay() utilisent le Timer0 et continuent de fonctionner. En revanche, la bibliothèque Servo utilise aussi le Timer1 : supprime cette ligne si ton projet comporte un servo. Trouve MIN_DUTY avec ta propre pompe : tourne lentement le potentiomètre, lis dans le moniteur série la valeur la plus basse à laquelle la pompe démarre seule et ajoute une petite marge. Baisser la tension de la pompe réduit aussi la hauteur de refoulement ; à mi-vitesse, la pompe ne monte l'eau qu'à environ un quart de la hauteur à pleine vitesse, car la pression d'une pompe centrifuge est proportionnelle au carré de sa vitesse.

Distributeur de liquide : 50 ml précis d'une pression sur le bouton

Une fois le débit mesuré, transformer la pompe en doseur est facile : divise la quantité voulue par le débit et tu obtiens la durée de fonctionnement. Le code ci-dessous verse 50 ml à chaque appui sur un bouton câblé entre D2 et GND ; un nouvel appui pendant que la pompe tourne annule la dose. Comme le temps est mesuré avec millis(), la boucle n'attend jamais et peut lire le bouton en permanence. C'est la base de projets comme un distributeur de savon, un doseur d'engrais ou une machine à cocktails.

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 première dose est plus petite que les autres, la cause est sans doute un tuyau vide : la pompe remplit d'abord le tuyau avant de verser le liquide. En gardant le bout du tuyau légèrement au-dessus de l'eau du réservoir, le tuyau reste plein et chaque dose est identique. Avec des liquides épais comme l'huile, le sirop ou le savon, le débit est bien plus faible qu'avec l'eau : calibre toujours avec le liquide réel. Pour les projets en contact avec des aliments, utilise un tuyau silicone de qualité alimentaire et rince la pompe à l'eau claire après chaque utilisation.

Arrosage automatique selon l'humidité du sol

Le projet de pompe à eau Arduino le plus populaire est le pot de fleurs qui s'arrose tout seul quand la terre sèche. Le piège des débutants consiste à faire tourner la pompe jusqu'à ce que l'humidité atteigne la cible : l'eau met plusieurs minutes à atteindre le capteur et, entre-temps, le pot a débordé. La bonne méthode est d'arroser par courtes impulsions : la pompe tourne 4 secondes, puis le programme attend 1 minute que l'eau se répartisse dans la terre et mesure de nouveau. En plus, le code ne lance jamais la pompe si le réservoir est vide et, si l'humidité ne monte toujours pas après 6 impulsions (le capteur est peut-être sorti de la terre ou le tuyau s'est détaché), il verrouille le système et allume la LED. Nous détaillons l'étalonnage du capteur dans le guide du capteur d'humidité du sol.

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}

Utiliser deux seuils distincts dans le code est voulu : l'arrosage démarre quand l'humidité passe sous 35 %, mais continue jusqu'à 55 %. Grâce à cette hystérésis, la pompe ne s'allume et ne s'éteint pas sans arrêt à cause d'une mesure qui oscille pile sur le seuil. Mesure DRY_VALUE et WET_VALUE avec ton propre capteur ; sur les capteurs capacitifs, ces valeurs dépendent de la tension d'alimentation et de la longueur du câble. Si le fil du flotteur casse, la broche lit HIGH et le code considère le réservoir comme vide : en cas de panne, le système reste du côté sûr et arrête la pompe. Pour n'arroser qu'à certaines heures, ajoute un module horloge RTC et teste l'heure dans la condition.

Quand un relais est-il pertinent pour piloter la pompe ?

Si tu n'as qu'un module relais, tu peux aussi faire tourner la mini pompe avec : le fil positif va de l'alimentation externe à la borne COM du relais, puis de la borne NO à la pompe ; le fil négatif va au moins de l'alimentation. Le relais isole complètement la pompe du circuit de la carte, et le même module peut commuter de grosses pompes 12 V ou des pompes d'aquarium sur secteur. En revanche, un relais ne fait pas de PWM, claque à chaque commutation, ses contacts s'usent avec le temps et sa bobine consomme à elle seule environ 70 mA. Pour quelques mises en marche par jour, un relais suffit ; pour doser ou régler la vitesse, le MOSFET est toujours meilleur. Même avec un relais, une diode aux bornes de la pompe réduit les arcs sur les contacts.

Piloter la pompe à eau depuis ton téléphone avec un ESP32

Grâce au Wi-Fi de l'ESP32, tu peux lancer la pompe depuis le navigateur de ton téléphone. Le code ci-dessous démarre un petit serveur web sur l'ESP32 ; en ouvrant sur un téléphone du même réseau l'adresse IP affichée dans le moniteur série, tu verras des boutons d'arrosage de 5 et 15 secondes et un bouton d'arrêt. Aucune bibliothèque supplémentaire n'est nécessaire : WebServer est fourni avec le cœur ESP32. Par sécurité, la pompe ne tourne jamais plus de 30 secondes ; même si la connexion tombe, elle s'arrête d'elle-même à la fin du temps. Comme l'ESP32 fonctionne en 3,3 V, choisis un MOSFET qui conduit pleinement à 3,3 V : l'AO3400A est le meilleur, et l'IRLZ44N suffit largement pour les 300 mA d'une mini pompe.

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}

Cette page ne s'ouvre que depuis le Wi-Fi de la maison. Pour piloter la pompe à distance ou recevoir une alerte quand le réservoir est vide, ajoute à ce code les méthodes des guides bot Telegram avec ESP32 ou Blynk. Pour transformer la page en tableau de bord mis à jour instantanément par WebSocket, consulte le guide serveur web asynchrone ESP32. Comme les broches de l'ESP32 sortent 3,3 V, un module IRF520 ne fonctionne pas ici ; si tu veux un module, choisis-en un avec un MOSFET à niveau logique.

Arrosage programmé avec un Raspberry Pi Pico (MicroPython)

Sur la Pico, tu peux piloter la pompe par un MOSFET sur GP15 et lui offrir un démarrage progressif en PWM. Le démarrage progressif étale le courant de démarrage sur quelques centaines de millisecondes et évite une chute brutale de la tension ; si la Pico et la pompe partagent la même alimentation, cela évite des redémarrages aléatoires. Le code ci-dessous arrose 8 secondes toutes les 12 heures et ajoute 3 secondes à chaque appui sur le bouton de GP14. Comme les broches de la Pico ne donnent que 3,3 V, choisis ici aussi un MOSFET garanti à 3,3 V comme l'AO3400A. Si tu débutes en MicroPython, jette d'abord un œil à qu'est-ce que le 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)

Le code mesure le temps avec time.ticks_diff(), qui renvoie la bonne différence même quand le compteur déborde. Comme l'horloge interne de la Pico repart de zéro à chaque coupure et peut dériver de quelques secondes par jour, si tu veux un programme lié à l'heure réelle, du type « arroser chaque matin à 7 h », ajoute un module RTC ou utilise une Pico W qui récupère l'heure sur internet (NTP). Après une coupure de courant, le compteur de 12 heures repart de zéro ; c'est sans importance pour la plupart des plantes, mais pense-y pour un projet qui doit tenir pendant de longues vacances.

Idées de projets avec une mini pompe à eau

• Arrosage pour les vacances : Arrose tes plantes pendant deux semaines avec un seau d'eau, quelques pots et de fins tuyaux qui vont vers chaque pot ; le montage complet est dans le projet de serre connectée.
• Gamelle d'eau automatique pour animal : Quand le niveau baisse dans la gamelle, la pompe la complète depuis un réservoir ; pour le niveau, un capteur de niveau sans contact convient bien.
• Distributeur de savon ou de gel sans contact : Quand un HC-SR04 ou un capteur infrarouge voit une main, la pompe tourne une demi-seconde.
• Machine à cocktails et à boissons : 3 ou 4 pompes, chacune dans sa bouteille et étalonnée séparément, préparent les mélanges selon la recette.
• Cascade de bureau et bassin décoratif : Une fontaine dont le débit ralentit la nuit en PWM et qui s'éteint quand une LDR voit la pièce s'assombrir.
• Remise à niveau d'aquarium : Un système qui compense l'eau évaporée depuis un réservoir séparé quand un interrupteur à flotteur signale la baisse du niveau.
• Intégration domotique : Relie la pompe à tes autres appareils via MQTT et Home Assistant avec un ESP32.

Erreurs fréquentes et solutions

Bien pilotée, une mini pompe immergée est une pièce bon marché et silencieuse qui fonctionne des années sans souci : avec un MOSFET à niveau logique, une diode en inverse, une alimentation 5 V séparée et une masse commune, ton Arduino reste parfaitement en sécurité. Le reste dépend de ton imagination ; avec le débit que tu as mesuré, tu peux doser au millilitre, arroser selon l'humidité du sol ou gérer la pompe depuis ton téléphone avec un ESP32. Dans l'application BlueGrays, tu trouveras le projet Station d'irrigation intelligente, ainsi que des projets de serveur web ESP32 et d'horloge RTC, avec schémas et code pas à pas.