Composants · 12 min de lecture

Capteur de débit d'eau Arduino : YF-S201, débit et litres

Brancher le capteur de débit d'eau YF-S201 sur Arduino : comptage d'impulsions, formule 7,5 Hz = 1 L/min, étalonnage, compteur, alarme de fuite, ESP32 et Pico.

Un capteur de débit d'eau mesure à quelle vitesse l'eau traverse un tuyau (le débit) et quelle quantité est passée au total ; c'est l'un des composants de mesure les plus simples à lire avec un Arduino. Le modèle le plus courant dans les projets amateurs, le YF-S201, se monte sur un tuyau d'un demi-pouce et produit des impulsions d'autant plus souvent que l'eau circule. En comptant ces impulsions, tu peux savoir combien de litres par minute s'écoulent, combien de litres une douche ou un cycle d'arrosage a consommés, et s'il y a une fuite quelque part sur le tuyau.

Dans ce guide, tu apprendras comment fonctionnent la turbine et le capteur Hall intégrés, d'où vient la formule 7,5 Hz = 1 L/min, comment brancher le capteur en toute sécurité sur un Arduino Uno, un ESP32 et une Raspberry Pi Pico, comment compter les impulsions par interruption et calculer le débit et le total en litres. Ensuite, tu étalonneras le capteur avec un verre doseur, tu monteras une alarme de fuite, tu suivras la consommation en Wi-Fi avec un ESP32 et tu liras des conseils pratiques sur la taille, la pression et l'installation.

Qu'est-ce qu'un capteur de débit d'eau et comment fonctionne-t-il ?

Dans le corps en plastique du YF-S201 se trouve une petite turbine (hélice) qui tourne avec le courant d'eau. La turbine porte un aimant, et un capteur à effet Hall est logé dans un compartiment étanche, hors du passage de l'eau. À chaque tour, l'aimant passe devant le capteur Hall et une impulsion carrée apparaît en sortie. Plus l'eau s'écoule vite, plus la turbine tourne vite et plus la fréquence des impulsions augmente. L'eau est ainsi mesurée sans jamais toucher l'électronique. Tu trouveras le fonctionnement des capteurs Hall en détail dans l'article capteur Hall.

CaractéristiqueYF-S201 (valeurs typiques)
Plage de mesure1–30 L/min
Relation des impulsionsF (Hz) = 7,5 × Q (L/min)
Impulsions par litreEnviron 450 impulsions/L (une impulsion vaut environ 2,2 mL)
Tension d'alimentation5–18 V CC (5 V dans les projets amateurs)
CourantJusqu'à environ 15 mA (sous 5 V)
SortieImpulsions carrées, rapport cyclique d'environ 50 %, au niveau de l'alimentation
PrécisionEnviron ±10 % sans étalonnage
RaccordFiletage mâle G1/2 (demi-pouce)
Pression maximale1,75 MPa (certains vendeurs indiquent 2,0 MPa)
FilsRouge : VCC, noir : GND, jaune : signal

Que signifie la formule 7,5 Hz = 1 L/min ?

La relation du fabricant F = 7,5 × Q indique qu'avec un débit de 1 litre par minute, le capteur produit 7,5 impulsions par seconde. On en tire deux formules pratiques : pour le débit, Q (L/min) = F / 7,5, et pour le volume total, Litres = impulsions totales / 450. Le nombre 450 est le produit de 7,5 impulsions par seconde par les 60 secondes d'une minute. Par exemple, si tu comptes 60 impulsions en une seconde, le débit vaut 60 / 7,5 = 8 L/min ; si tu comptes 22 500 impulsions pendant une douche, 22 500 / 450 = 50 litres d'eau ont été utilisés.

Débit (L/min)Fréquence (Hz)Impulsions en 1 secondeTemps pour 1 L
1 (limite basse)7,57–860 secondes
5 (robinet peu ouvert)37,537–3812 secondes
10 (robinet grand ouvert)75756 secondes
201501503 secondes
30 (limite haute)2252252 secondes

La première ligne montre une limite importante : quand on ne compte que 7–8 impulsions dans une fenêtre d'une seconde, une impulsion d'erreur fait varier la mesure d'environ 13 %. Pour un résultat plus stable à faible débit, tu peux allonger la fenêtre à 2–5 secondes ou faire la moyenne des dernières mesures. Le calcul du total en litres n'a pas ce problème, car les impulsions s'additionnent sans se perdre.

Branchement du capteur de débit d'eau

Fil du capteurArduino UnoESP32Raspberry Pi Pico
Rouge (VCC)5VVIN (5 V de l'USB)VBUS (5 V de l'USB)
Noir (GND)GNDGNDGND
Jaune (signal)D2 (direct)GPIO 27, via un pont diviseurGP15, via un pont diviseur
Résistances du diviseurInutiles10 kΩ (signal–broche) + 20 kΩ (broche–GND)10 kΩ (signal–broche) + 20 kΩ (broche–GND)
Niveau haut vu par la broche5 VEnviron 3,3 VEnviron 3,3 V
Quand le YF-S201 est alimenté en 5 V, sa sortie signal est elle aussi à 5 V. Les broches de l'ESP32 et de la Pico acceptent au maximum 3,3 V ; brancher le fil jaune directement peut abîmer la broche avec le temps. Un pont diviseur de 10 kΩ et 20 kΩ ramène 5 V à 5 × 20 / 30 ≈ 3,3 V. Tu peux vérifier les valeurs avec tes propres résistances grâce au calculateur de pont diviseur et lire son principe dans l'article pont diviseur de tension.

Sur l'Uno, branche toujours le signal sur une broche d'interruption : sur l'Uno et le Nano, seules D2 et D3 gèrent les interruptions externes. Certaines cartes de capteur ont une sortie à collecteur ouvert sans résistance de pull-up ; ouvrir la broche en INPUT_PULLUP dans le code de l'Uno est donc sûr avec les deux types de capteur. Si le câble est long (quelques mètres), éloigne le fil de signal des câbles de moteurs et de pompes et, si besoin, ajoute un condensateur de 100 nF entre signal et GND pour réduire les impulsions parasites.

Pourquoi compter les impulsions par interruption ?

À 30 L/min, le capteur produit 225 impulsions par seconde, soit une toutes les 4,4 millisecondes. Un programme qui lit la broche avec digitalRead dans loop() en rate une partie dès qu'un delay(), une mise à jour de l'écran LCD ou une opération Wi-Fi s'intercale, et la mesure sort trop basse sans prévenir. Une interruption fait abandonner au processeur ce qu'il fait pour exécuter une petite fonction à l'instant où le niveau de la broche change ; quoi que fasse le programme, aucune impulsion n'est perdue. La fonction d'interruption doit être la plus courte possible : elle incrémente seulement le compteur, et les calculs comme l'affichage se font dans loop(). Pour les détails, vois l'article les interruptions Arduino.

Code Arduino : débit et total en litres

  1. Monte le capteur de façon que l'eau s'écoule dans le sens de la flèche sur le corps.
  2. Relie le fil rouge au 5V, le noir au GND et le jaune à D2.
  3. Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds.
  4. Ouvre doucement le robinet ; le débit monte et le total en litres s'accumule.
  5. Quand tu fermes le robinet, le débit retombe à zéro et le total reste à sa dernière valeur.
C++ (Arduino IDE)
1// YF-S201 su akış sensörü: debi ve toplam litre / flow rate and total litres
2const byte SENSOR_PIN = 2;          // sarı kablo, kesme pini / yellow wire, interrupt pin
3const float DARBE_LITRE = 450.0;    // 1 L = 450 darbe, kalibrasyonla değiştir / pulses per litre, calibrate
4
5volatile unsigned long darbe = 0;   // kesmede artan sayaç / counter incremented in the ISR
6unsigned long toplamDarbe = 0;      // açılıştan beri toplam / total since power-up
7unsigned long oncekiZaman = 0;
8
9void darbeSay() {                   // kesme fonksiyonu: kısa tut / ISR: keep it short
10  darbe++;
11}
12
13void setup() {
14  Serial.begin(9600);
15  pinMode(SENSOR_PIN, INPUT_PULLUP);
16  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), darbeSay, FALLING);
17}
18
19void loop() {
20  unsigned long simdi = millis();
21  if (simdi - oncekiZaman >= 1000) {          // saniyede bir hesapla / compute once a second
22    noInterrupts();                           // sayacı güvenle kopyala / copy the counter safely
23    unsigned long sayi = darbe;
24    darbe = 0;
25    interrupts();
26
27    float sure = (simdi - oncekiZaman) / 1000.0;   // gerçek pencere (s) / real window (s)
28    oncekiZaman = simdi;
29    toplamDarbe += sayi;
30
31    float debi = (sayi / sure) * 60.0 / DARBE_LITRE;   // L/dk = Hz * 60 / 450 = Hz / 7,5
32    float litre = toplamDarbe / DARBE_LITRE;
33
34    Serial.print(F("Debi / Flow: "));
35    Serial.print(debi, 2);
36    Serial.print(F(" L/dk   Toplam / Total: "));
37    Serial.print(litre, 3);
38    Serial.println(F(" L"));
39  }
40}
LigneQue fait-elle ?
volatile unsigned long darbeCompteur partagé entre l'interruption et loop() ; volatile empêche le compilateur de garder sa valeur en cache
attachInterrupt(..., FALLING)darbeSay() s'exécute chaque fois que le signal passe de HIGH à LOW
noInterrupts() / interrupts()Suspend brièvement les interruptions pour qu'aucune ne corrompe le compteur de 4 octets pendant sa lecture
sure = (simdi - oncekiZaman) / 1000.0Calcule avec la fenêtre réelle même si elle ne fait pas exactement 1000 ms
(sayi / sure) * 60 / DARBE_LITREConvertit la fréquence en L/min ; avec DARBE_LITRE à 450, c'est équivalent à F / 7,5
toplamDarbe / DARBE_LITRECalcule le total en litres à partir des impulsions cumulées
Utiliser la constante DARBE_LITRE plutôt que 7,5 dans la formule ramène l'étalonnage à une seule ligne : tu y écris le nombre d'impulsions par litre trouvé pour ton capteur, et le débit comme le total sont corrigés ensemble. Pour conserver le total lors d'une coupure de courant, tu peux l'enregistrer en EEPROM ; mais pas à chaque impulsion, plutôt tous les 10 litres par exemple, pour ne pas user les cellules.

Étalonnage du capteur de débit d'eau

450 impulsions/L est la valeur moyenne du fabricant ; sur un vrai capteur, un écart de 5–10 % dû au sens de montage, à la pression, au diamètre du tuyau et au débit est normal. Pour l'étalonnage, un récipient de volume connu suffit : un verre doseur de 1 ou 2 litres, ou mieux un bidon de 5 litres. Tester dans l'installation définitive, à un débit proche de l'usage réel, donne le résultat le plus juste, car le nombre de tours de turbine par litre varie un peu entre faible et fort débit.

  1. Téléverse le code d'étalonnage ci-dessous et ouvre le moniteur série (fin de ligne : Nouvelle ligne).
  2. Tiens le bout du tuyau au-dessus du récipient vide et tape r dans le moniteur série pour remettre le compteur à zéro.
  3. Ouvre le robinet à ton débit habituel et ferme-le quand l'eau atteint exactement le trait.
  4. Tape le volume du récipient en litres dans le moniteur série (par ex. 2) ; le code calcule les impulsions par litre.
  5. Recommence au moins trois fois et inscris la moyenne dans la constante DARBE_LITRE du code principal.
C++ (Arduino IDE)
1// YF-S201 kalibrasyonu: litre başına darbe sayısını bul / find pulses per litre
2const byte SENSOR_PIN = 2;
3volatile unsigned long darbe = 0;
4
5void darbeSay() {
6  darbe++;
7}
8
9void setup() {
10  Serial.begin(9600);
11  pinMode(SENSOR_PIN, INPUT_PULLUP);
12  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), darbeSay, FALLING);
13  Serial.println(F("r: sifirla / reset, sayi: kap hacmi litre / container volume in litres"));
14}
15
16void loop() {
17  if (Serial.available()) {
18    String satir = Serial.readStringUntil('\n');   // kısa ömürlü, tek seferlik / short-lived, one-off
19    satir.trim();
20    noInterrupts();
21    unsigned long sayi = darbe;
22    interrupts();
23    if (satir == "r") {
24      noInterrupts();
25      darbe = 0;
26      interrupts();
27      Serial.println(F("Sayac sifirlandi / Counter reset"));
28    } else {
29      float litre = satir.toFloat();
30      if (litre > 0) {
31        Serial.print(F("Darbe / Pulses: "));
32        Serial.print(sayi);
33        Serial.print(F("   Darbe/L: "));
34        Serial.println(sayi / litre, 1);       // DARBE_LITRE için yeni değer / new DARBE_LITRE
35      }
36    }
37  }
38}

Par exemple, si tu as compté 931 impulsions en remplissant le récipient de 2 litres, le facteur de ton capteur vaut 931 / 2 = 465,5 impulsions/L ; en gardant 450, il afficherait environ 3,4 litres de trop tous les 100 litres. Pour vérifier aussi le débit, chronomètre le remplissage : si 2 litres se remplissent en 15 secondes, le débit réel vaut 2 / 15 × 60 = 8 L/min, à comparer avec la valeur du moniteur série.

Compteur d'eau et alarme de fuite

L'usage le plus utile d'un capteur de débit est de repérer un écoulement inattendu. De l'eau qui coule alors que personne n'en utilise, ou un robinet resté ouvert de longues minutes, signalent une fuite ou un tuyau oublié. Le code suivant fait sonner un buzzer et ferme, via un relais, une électrovanne qui coupe l'eau si l'écoulement dure sans interruption au-delà d'un temps fixé ou dépasse une quantité fixée d'un seul coup. Un appui sur le bouton réinitialise l'alarme et rouvre la vanne.

C++ (Arduino IDE)
1// Sızıntı alarmı: uzun süreli ya da aşırı akışta vanayı kapat
2// Leak alarm: close the valve on long or excessive flow
3const byte SENSOR_PIN = 2;
4const byte ROLE_PIN = 7;            // selenoid vana rölesi (HIGH = vana açık) / valve relay (HIGH = open)
5const byte BUZZER_PIN = 8;
6const byte BUTON_PIN = 4;           // alarmı sıfırla / reset alarm
7const float DARBE_LITRE = 450.0;
8const unsigned long MAKS_SURE = 20UL * 60UL * 1000UL;   // 20 dk kesintisiz akış / 20 min continuous flow
9const float MAKS_LITRE = 150.0;                          // tek seferde en fazla / max per session
10
11volatile unsigned long darbe = 0;
12unsigned long akisBaslangic = 0;    // akışın başladığı an / when flow started
13unsigned long sonAkis = 0;          // son darbe görülen an / last time flow was seen
14float oturumLitre = 0;
15bool alarmVar = false;
16unsigned long oncekiZaman = 0;
17
18void darbeSay() {
19  darbe++;
20}
21
22void setup() {
23  Serial.begin(9600);
24  pinMode(SENSOR_PIN, INPUT_PULLUP);
25  pinMode(ROLE_PIN, OUTPUT);
26  pinMode(BUZZER_PIN, OUTPUT);
27  pinMode(BUTON_PIN, INPUT_PULLUP);
28  digitalWrite(ROLE_PIN, HIGH);     // vana açık / valve open
29  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), darbeSay, FALLING);
30}
31
32void loop() {
33  unsigned long simdi = millis();
34  if (simdi - oncekiZaman >= 1000) {
35    oncekiZaman = simdi;
36    noInterrupts();
37    unsigned long sayi = darbe;
38    darbe = 0;
39    interrupts();
40
41    if (sayi > 2) {                           // gerçek akış var / real flow present
42      if (simdi - sonAkis > 10000) {          // 10 s'den uzun aradan sonra yeni oturum / new session
43        akisBaslangic = simdi;
44        oturumLitre = 0;
45      }
46      sonAkis = simdi;
47      oturumLitre += sayi / DARBE_LITRE;
48      if (!alarmVar && (simdi - akisBaslangic > MAKS_SURE || oturumLitre > MAKS_LITRE)) {
49        alarmVar = true;
50        digitalWrite(ROLE_PIN, LOW);          // vanayı kapat / close the valve
51        Serial.println(F("SIZINTI ALARMI / LEAK ALARM"));
52      }
53    }
54  }
55  if (alarmVar) {
56    tone(BUZZER_PIN, 2000, 200);              // aralıklı bip / intermittent beep
57    delay(400);
58    if (digitalRead(BUTON_PIN) == LOW) {      // sıfırla / reset
59      alarmVar = false;
60      oturumLitre = 0;
61      sonAkis = 0;
62      digitalWrite(ROLE_PIN, HIGH);
63      Serial.println(F("Alarm sifirlandi / Alarm reset"));
64    }
65  }
66}

Choisis les seuils selon ton usage : une douche coule à 8–12 L/min pendant 5–10 minutes et consomme 50–100 litres, alors qu'un arrosage de jardin peut durer bien plus. Les électrovannes fonctionnent généralement en 12 V et sont alimentées par un adaptateur séparé via un module relais ; pour le câblage, vois l'article module relais. Sache aussi qu'un robinet qui goutte ou une chasse d'eau qui fuit perdent quelques litres par heure, bien en dessous de la limite basse de 1 L/min du YF-S201 ; le capteur ne voit pas d'aussi petites fuites. Pour les détecter, ajoute un second contrôle qui enregistre chaque impulsion la nuit, ou un capteur de niveau d'eau posé au sol.

Suivre la consommation d'eau avec un ESP32

Carte de développement ESP32
L'ESP32 peut compter les impulsions du capteur de débit tout en servant une page web en Wi-Fi.

Toutes les broches GPIO de l'ESP32 gèrent les interruptions, et le Wi-Fi te permet de suivre la mesure sur ton téléphone. Le code ci-dessous lit le capteur sur la GPIO 27 (via le diviseur), affiche le débit actuel et le total en litres sur une page web actualisée toutes les deux secondes, et enregistre le total en flash avec Preferences, si bien que le compteur reprend là où il s'était arrêté même après une coupure. Pour ménager la flash, il n'enregistre que si le total a changé d'au moins 1 litre, et au plus une fois par minute.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4
5const char* AG_ADI = "AG_ADIN";          // Wi-Fi ağ adı / network name
6const char* SIFRE = "SIFREN";            // Wi-Fi şifresi / password
7const int SENSOR_PIN = 27;               // 10k + 20k bölücü üzerinden / through a 10k + 20k divider
8const float DARBE_LITRE = 450.0;
9
10volatile uint32_t darbe = 0;
11portMUX_TYPE kilit = portMUX_INITIALIZER_UNLOCKED;
12uint32_t toplamDarbe = 0;
13uint32_t kayitliDarbe = 0;
14float debi = 0;
15unsigned long oncekiOlcum = 0, oncekiKayit = 0;
16
17WebServer sunucu(80);
18Preferences ayarlar;
19
20void IRAM_ATTR darbeSay() {              // kesme RAM'de çalışır / ISR runs from IRAM
21  portENTER_CRITICAL_ISR(&kilit);
22  darbe++;
23  portEXIT_CRITICAL_ISR(&kilit);
24}
25
26void anaSayfa() {
27  char sayfa[300];
28  snprintf(sayfa, sizeof(sayfa),
29           "<html><head><meta charset='utf-8'><meta http-equiv='refresh' content='2'></head><body>"
30           "<h2>Su sayaci / Water meter</h2><p>Debi / Flow: %.2f L/dk</p><p>Toplam / Total: %.2f L</p></body></html>",
31           debi, toplamDarbe / DARBE_LITRE);
32  sunucu.send(200, "text/html", sayfa);
33}
34
35void sifirla() {                         // /sifirla adresi toplamı sıfırlar / resets the total
36  toplamDarbe = 0;
37  kayitliDarbe = 0;
38  ayarlar.putUInt("toplam", 0);
39  sunucu.send(200, "text/plain", "Sifirlandi / Reset");
40}
41
42void setup() {
43  Serial.begin(115200);
44  pinMode(SENSOR_PIN, INPUT);
45  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), darbeSay, FALLING);
46  ayarlar.begin("su", false);
47  toplamDarbe = ayarlar.getUInt("toplam", 0);   // kaldığı yerden devam / resume the total
48  kayitliDarbe = toplamDarbe;
49
50  WiFi.begin(AG_ADI, SIFRE);
51  while (WiFi.status() != WL_CONNECTED) {
52    delay(300);
53    Serial.print(".");
54  }
55  Serial.print("\nIP: ");
56  Serial.println(WiFi.localIP());
57  sunucu.on("/", anaSayfa);
58  sunucu.on("/sifirla", sifirla);
59  sunucu.begin();
60}
61
62void loop() {
63  sunucu.handleClient();
64  unsigned long simdi = millis();
65  if (simdi - oncekiOlcum >= 1000) {
66    float sure = (simdi - oncekiOlcum) / 1000.0;
67    oncekiOlcum = simdi;
68    portENTER_CRITICAL(&kilit);
69    uint32_t sayi = darbe;
70    darbe = 0;
71    portEXIT_CRITICAL(&kilit);
72    toplamDarbe += sayi;
73    debi = (sayi / sure) * 60.0 / DARBE_LITRE;
74  }
75  // en az 1 L değiştiyse ve 60 s geçtiyse kaydet / save if >= 1 L changed and 60 s passed
76  if (toplamDarbe - kayitliDarbe >= DARBE_LITRE && simdi - oncekiKayit >= 60000) {
77    ayarlar.putUInt("toplam", toplamDarbe);
78    kayitliDarbe = toplamDarbe;
79    oncekiKayit = simdi;
80  }
81}

Après le téléversement, il suffit de taper l'adresse IP affichée dans le moniteur série dans le navigateur d'un téléphone connecté au même réseau. Sur l'ESP32, on ajoute IRAM_ATTR à la fonction d'interruption, car elle doit pouvoir s'exécuter même pendant une lecture de la flash ; le compteur est protégé par portENTER_CRITICAL plutôt que noInterrupts(), car l'ESP32 a deux cœurs. Si tu veux des graphiques quotidiens ou une notification au dépassement d'un seuil, tu peux envoyer la même mesure vers MQTT et Home Assistant ou vers un bot Telegram.

Code MicroPython pour la Raspberry Pi Pico

Sur la Pico aussi, toutes les GPIO gèrent les interruptions. Alimente le capteur en 5 V depuis VBUS et branche le signal sur GP15 via un diviseur 10 kΩ + 20 kΩ. En MicroPython, la fonction d'interruption s'associe avec Pin.irq, et machine.disable_irq() coupe brièvement les interruptions pendant la lecture du compteur.

MicroPython
1from machine import Pin
2import machine
3import time
4
5DARBE_LITRE = 450                      # kalibrasyonla değiştir / change after calibration
6sayac = 0
7toplam_darbe = 0
8
9def darbe_say(pin):                    # kesme fonksiyonu / interrupt handler
10    global sayac
11    sayac += 1
12
13sensor = Pin(15, Pin.IN)               # bölücü üzerinden GP15 / GP15 through the divider
14sensor.irq(trigger=Pin.IRQ_FALLING, handler=darbe_say)
15
16onceki = time.ticks_ms()
17while True:
18    time.sleep_ms(1000)
19    simdi = time.ticks_ms()
20    sure = time.ticks_diff(simdi, onceki) / 1000   # gerçek pencere (s) / real window (s)
21    onceki = simdi
22    durum = machine.disable_irq()      # sayacı güvenle al / read the counter safely
23    n = sayac
24    sayac = 0
25    machine.enable_irq(durum)
26    toplam_darbe += n
27    debi = (n / sure) * 60 / DARBE_LITRE
28    print("Debi: {:.2f} L/dk  Toplam: {:.3f} L".format(debi, toplam_darbe / DARBE_LITRE))

Utilisation avec une pompe et un arrosage

Mini pompe à eau immergée 6 V
Les mini pompes immergées débitent généralement moins de 1–2 litres par minute ; pour cette plage, il faut un capteur de débit plus petit que le YF-S201.

Dans les projets d'arrosage, un capteur de débit sert aussi à vérifier que la pompe pousse réellement de l'eau. Si aucune impulsion n'arrive quelques secondes après la mise en marche, le réservoir est vide, le tuyau est bouché ou la pompe est en panne ; la couper évite alors qu'elle tourne à sec et grille. Cependant, les petites pompes immergées 3–6 V des kits débitent souvent moins de 1 L/min et sortent de la plage du YF-S201. Dans ces montages, utilise un petit capteur comme le YF-S401, prévu pour 0,3–6 L/min. Pour le câblage de la pompe, vois pompe à eau Arduino, et pour un système complet le projet de serre connectée.

Taille, pression et choix du modèle

ModèleRaccordPlage de mesureRelation des impulsionsImpulsions par litre
YF-S401Tuyau fin (environ 6 mm)0,3–6 L/minF = 98 × QEnviron 5880
YF-S201G1/2 (demi-pouce), plastique1–30 L/minF = 7,5 × QEnviron 450
YF-B1G1/2, corps en laiton1–25 L/minF = 11 × QEnviron 660
FS300AG3/4 (trois quarts de pouce)1–60 L/minF = 5,5 × QEnviron 330
  • Choisis selon le tuyau : dans un logement, les arrivées de robinets et de douches sont le plus souvent en demi-pouce ; le YF-S201 s'y monte sans adaptateur. Un petit capteur sur une conduite plus grosse étrangle le débit.
  • Pression : la pression du réseau dans une maison est généralement de 2 à 5 bars (0,2–0,5 MPa), bien en dessous de la limite de 1,75 MPa du YF-S201. La turbine freine néanmoins l'eau et crée une petite perte de charge à fort débit.
  • Sens d'écoulement et position : respecte la flèche du corps, monte le capteur à l'horizontale si possible et laisse quelques dizaines de centimètres de tuyau droit en amont. Juste après un coude, les turbulences augmentent l'erreur.
  • Bulles d'air et dépôts : l'air fait tourner la turbine à vide et crée de fausses impulsions, tandis que le sable et le calcaire la freinent. Si besoin, place un filtre avant le capteur.
  • Corps en plastique : le corps en nylon du YF-S201 résiste moins bien à l'eau chaude et aux chocs que les modèles en laiton. La plupart des modèles bon marché n'ont pas non plus d'agrément pour l'eau potable ; sur une conduite d'eau de boisson, choisis un modèle de qualité alimentaire.
  • Étanchéité : enroule du ruban PTFE sur les filetages, sans laisser de ruban entrer dans la chambre de la turbine. Serre le capteur à la main ; une pince peut fendre le filetage en plastique.

Idées de projets avec un capteur de débit d'eau

  • Compteur de douche : affiche sur un écran LCD I2C combien de litres une douche a consommés et préviens avec un buzzer au-delà d'un volume fixé.
  • Arrosage intelligent : démarre la pompe quand l'humidité du sol baisse, mesure en litres l'eau apportée et arrête-toi à la quantité visée. Pour l'humidité, vois l'article capteur d'humidité du sol.
  • Compteur d'eau de la maison : enregistre avec un ESP32 la consommation quotidienne, hebdomadaire et mensuelle, et envoie une notification si de l'eau coule la nuit.
  • Protection de pompe : si rien ne coule alors que la pompe tourne, coupe-la après quelques secondes et signale la panne par une LED.
  • Surveillance du filtre d'aquarium : suis le débit qui baisse à mesure que le filtre s'encrasse et préviens quand il faut le nettoyer.
  • Doseuse : monte une station de remplissage automatique qui remplit un récipient avec exactement 2 litres d'eau puis ferme la vanne.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Débit toujours à 0Signal sur une broche sans interruption ou capteur monté à l'enversUtilise D2 ou D3 sur l'Uno ; compare le sens de l'eau avec la flèche du corps
Des impulsions sont comptées sans écoulementParasites sur un long câble ou broche flottanteUtilise INPUT_PULLUP, ajoute 100 nF entre signal et GND, éloigne le câble des fils de moteurs
Les litres mesurés s'écartent de 10 % de la réalitéCapteur non étalonnéÉtalonne avec un verre doseur et mets à jour DARBE_LITRE
La mesure saute à faible débitTrop peu d'impulsions dans la fenêtre d'une secondeAllonge la fenêtre à 2–5 secondes ou fais une moyenne
L'ESP32 redémarre au hasard ou la broche est abîméeSignal 5 V branché directement sur une broche 3,3 VUtilise un pont diviseur 10 kΩ + 20 kΩ ou un convertisseur de niveau logique
Le total en litres s'efface après une coupureLe compteur n'existe qu'en RAMEnregistre le total à intervalles réguliers en EEPROM ou dans Preferences
Aucune impulsion avec une petite pompeDébit inférieur à 1 L/minUtilise un capteur bas débit comme le YF-S401
Quand tu montes une nouvelle installation, commence par quelques mesures avec le code d'étalonnage et note les résultats. Le même capteur peut mesurer quelques pour cent différemment à l'horizontale ou à la verticale, ou sous une autre pression ; étalonner à l'endroit où le capteur restera est la méthode la plus fiable.

Le capteur de débit d'eau YF-S201 est idéal pour apprendre à compter des impulsions par interruption, et bien étalonné, il fournit des mesures fiables dans de nombreux projets, du compteur d'eau domestique à l'arrosage automatique. Dans l'application BlueGrays, tu trouveras la station d'arrosage intelligente et des projets de mesure avec écran LCD, avec schémas et code pas à pas, auxquels tu pourras facilement ajouter le capteur de débit.

Questions fréquentes

Comment fonctionne un capteur de débit d'eau ?

Une turbine à l'intérieur du capteur tourne avec l'eau, et son aimant passe devant un capteur Hall à chaque tour. Le capteur Hall produit une impulsion à chaque passage, et plus l'eau coule vite, plus la fréquence des impulsions est élevée. L'Arduino compte ces impulsions pour calculer le débit et le total en litres.

Combien d'impulsions par litre donne le YF-S201 ?

La formule du fabricant est F = 7,5 × Q : il produit donc 7,5 Hz à 1 L/min. Cela correspond à environ 450 impulsions par litre. Un capteur réel peut s'écarter de 5–10 %, il est donc conseillé de l'étalonner avec un verre doseur pour trouver ton propre facteur.

Peut-on brancher un capteur de débit directement sur un ESP32 ?

Alimenté en 5 V, le YF-S201 fournit un signal de 5 V, trop élevé pour les broches 3,3 V de l'ESP32. Il faut ajouter sur la ligne de signal un pont diviseur de 10 kΩ et 20 kΩ ou un convertisseur de niveau logique. L'alimentation du capteur peut venir de la broche VIN de l'ESP32.

Pourquoi brancher le capteur de débit sur une broche d'interruption ?

À fort débit, le capteur produit plus de 200 impulsions par seconde, et un programme qui lit la broche dans loop() en perd pendant les pauses ou les mises à jour d'écran. L'interruption exécute instantanément une petite fonction à chaque impulsion, donc aucune n'est perdue. Sur l'Arduino Uno, les broches d'interruption sont D2 et D3.

Un capteur de débit peut-il détecter une fuite d'eau ?

Les grosses fuites, comme un robinet ou un tuyau restés ouverts longtemps, se détectent facilement en surveillant la durée d'écoulement continu et les litres consommés. En revanche, les très petites fuites comme un robinet qui goutte restent sous la limite basse de 1 L/min du YF-S201 et passent inaperçues. Pour elles, il faut un détecteur d'eau au sol ou un compteur plus sensible.

Sur quel tuyau se monte le YF-S201 ?

Le YF-S201 possède un filetage mâle G1/2, c'est-à-dire un demi-pouce, à chaque extrémité et s'adapte directement à la plupart des arrivées de robinets et de douches d'une maison. Pour des tuyaux plus fins, il existe le YF-S401, et pour les conduites de trois quarts de pouce le FS300A. Du ruban PTFE sur les filetages et un serrage à la main suffisent.

Voir tous les projets
Température et humidité avec DHT11
AR-55Intermédiaire

Température et humidité avec DHT11

Quelle température fait-il dans ta chambre, et l'air est-il humide ou sec ? Le capteur DHT11 mesure la température et l'humidité, et l'Arduino affiche les valeurs sur un écran LCD à deux lignes…

4.7(47)
83
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

HC-SR04 Mesure de la distance (affichage en série)

Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

4.6(50)
82
Station d'irrigation intelligente
AR-83Avancé
Premium

Station d'irrigation intelligente

Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

5.0(42)
57
Voltmètre numérique avec écran LCD
AR-56Intermédiaire
Premium

Voltmètre numérique avec écran LCD

Découvre quelle tension fournit une pile ou un adaptateur avec un appareil de mesure fait maison.

4.5(27)
36
Écran LCD I2C ESP32 (16x2)
ES-17Intermédiaire
Premium

Écran LCD I2C ESP32 (16x2)

Dans ce projet, on relie un écran LCD 16x2 caractères à l'ESP32 en I2C pour afficher du texte. Grâce à l'I2C, 2 broches de données (SDA et SCL) suffisent, au lieu des 6+ broches d'un branchement parallèle classique. Le code affiche un message fixe sur la première ligne et un compteur qui augmente chaque seconde sur la deuxième. Au démarrage, un scanner I2C écrit l'adresse de l'écran dans le Serial Monitor (souvent 0x27 ou 0x3F).

4.9(23)
40
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)

On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

4.8(16)
26
Connexion Wi-Fi STA ESP32 (avec écran LCD)
ES-25Avancé

Connexion Wi-Fi STA ESP32 (avec écran LCD)

Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

4.4(21)
38