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éristique | YF-S201 (valeurs typiques) |
|---|---|
| Plage de mesure | 1–30 L/min |
| Relation des impulsions | F (Hz) = 7,5 × Q (L/min) |
| Impulsions par litre | Environ 450 impulsions/L (une impulsion vaut environ 2,2 mL) |
| Tension d'alimentation | 5–18 V CC (5 V dans les projets amateurs) |
| Courant | Jusqu'à environ 15 mA (sous 5 V) |
| Sortie | Impulsions carrées, rapport cyclique d'environ 50 %, au niveau de l'alimentation |
| Précision | Environ ±10 % sans étalonnage |
| Raccord | Filetage mâle G1/2 (demi-pouce) |
| Pression maximale | 1,75 MPa (certains vendeurs indiquent 2,0 MPa) |
| Fils | Rouge : 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 seconde | Temps pour 1 L |
|---|---|---|---|
| 1 (limite basse) | 7,5 | 7–8 | 60 secondes |
| 5 (robinet peu ouvert) | 37,5 | 37–38 | 12 secondes |
| 10 (robinet grand ouvert) | 75 | 75 | 6 secondes |
| 20 | 150 | 150 | 3 secondes |
| 30 (limite haute) | 225 | 225 | 2 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 capteur | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Rouge (VCC) | 5V | VIN (5 V de l'USB) | VBUS (5 V de l'USB) |
| Noir (GND) | GND | GND | GND |
| Jaune (signal) | D2 (direct) | GPIO 27, via un pont diviseur | GP15, via un pont diviseur |
| Résistances du diviseur | Inutiles | 10 kΩ (signal–broche) + 20 kΩ (broche–GND) | 10 kΩ (signal–broche) + 20 kΩ (broche–GND) |
| Niveau haut vu par la broche | 5 V | Environ 3,3 V | Environ 3,3 V |
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
- Monte le capteur de façon que l'eau s'écoule dans le sens de la flèche sur le corps.
- Relie le fil rouge au 5V, le noir au GND et le jaune à D2.
- Téléverse le code ci-dessous et ouvre le moniteur série à 9600 bauds.
- Ouvre doucement le robinet ; le débit monte et le total en litres s'accumule.
- Quand tu fermes le robinet, le débit retombe à zéro et le total reste à sa dernière valeur.
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}| Ligne | Que fait-elle ? |
|---|---|
| volatile unsigned long darbe | Compteur 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.0 | Calcule avec la fenêtre réelle même si elle ne fait pas exactement 1000 ms |
| (sayi / sure) * 60 / DARBE_LITRE | Convertit la fréquence en L/min ; avec DARBE_LITRE à 450, c'est équivalent à F / 7,5 |
| toplamDarbe / DARBE_LITRE | Calcule le total en litres à partir des impulsions cumulées |
É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.
- Téléverse le code d'étalonnage ci-dessous et ouvre le moniteur série (fin de ligne : Nouvelle ligne).
- 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.
- Ouvre le robinet à ton débit habituel et ferme-le quand l'eau atteint exactement le trait.
- Tape le volume du récipient en litres dans le moniteur série (par ex. 2) ; le code calcule les impulsions par litre.
- Recommence au moins trois fois et inscris la moyenne dans la constante DARBE_LITRE du code principal.
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.
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

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.
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.
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

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èle | Raccord | Plage de mesure | Relation des impulsions | Impulsions par litre |
|---|---|---|---|---|
| YF-S401 | Tuyau fin (environ 6 mm) | 0,3–6 L/min | F = 98 × Q | Environ 5880 |
| YF-S201 | G1/2 (demi-pouce), plastique | 1–30 L/min | F = 7,5 × Q | Environ 450 |
| YF-B1 | G1/2, corps en laiton | 1–25 L/min | F = 11 × Q | Environ 660 |
| FS300A | G3/4 (trois quarts de pouce) | 1–60 L/min | F = 5,5 × Q | Environ 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ôme | Cause probable | Solution |
|---|---|---|
| Débit toujours à 0 | Signal sur une broche sans interruption ou capteur monté à l'envers | Utilise D2 ou D3 sur l'Uno ; compare le sens de l'eau avec la flèche du corps |
| Des impulsions sont comptées sans écoulement | Parasites sur un long câble ou broche flottante | Utilise 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ébit | Trop peu d'impulsions dans la fenêtre d'une seconde | Allonge la fenêtre à 2–5 secondes ou fais une moyenne |
| L'ESP32 redémarre au hasard ou la broche est abîmée | Signal 5 V branché directement sur une broche 3,3 V | Utilise un pont diviseur 10 kΩ + 20 kΩ ou un convertisseur de niveau logique |
| Le total en litres s'efface après une coupure | Le compteur n'existe qu'en RAM | Enregistre le total à intervalles réguliers en EEPROM ou dans Preferences |
| Aucune impulsion avec une petite pompe | Débit inférieur à 1 L/min | Utilise un capteur bas débit comme le YF-S401 |
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.
Projets à réaliser après cet article
Voir tous les projets
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…

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…

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

Voltmètre numérique avec écran LCD
Découvre quelle tension fournit une pile ou un adaptateur avec un appareil de mesure fait maison.

É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).

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).

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.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

