Componenti · 11 min di lettura

Sensore di flusso acqua Arduino: portata e litri con YF-S201

Collegare il sensore di flusso acqua YF-S201 ad Arduino: conteggio impulsi, formula 7,5 Hz = 1 L/min, calibrazione, contatore, allarme perdite, ESP32 e Pico.

Un sensore di flusso acqua misura la velocità con cui l'acqua passa in un tubo (la portata) e quanta ne è passata in totale, ed è uno dei componenti di misura più facili da leggere con Arduino. Il modello più diffuso nei progetti hobbistici, lo YF-S201, si monta su un tubo da mezzo pollice e genera impulsi tanto più spesso quanta più acqua scorre. Contando questi impulsi puoi calcolare quanti litri al minuto stanno scorrendo, quanti litri ha consumato una doccia o un ciclo di irrigazione e se c'è una perdita in qualche punto del tubo.

In questa guida imparerai come funzionano la turbina e il sensore Hall al suo interno, da dove viene la formula 7,5 Hz = 1 L/min, come collegare il sensore in sicurezza ad Arduino Uno, ESP32 e Raspberry Pi Pico, come contare gli impulsi con un interrupt e come calcolare portata e litri totali. Poi calibrerai il sensore con un misurino, costruirai un allarme perdite, seguirai i consumi via Wi-Fi con un ESP32 e leggerai note pratiche su dimensioni, pressione e installazione.

Che cos'è un sensore di flusso acqua e come funziona?

Nel corpo in plastica dello YF-S201 c'è una piccola turbina (girante) che ruota con il flusso dell'acqua. Sulla turbina c'è un magnete e, in un vano stagno fuori dal passaggio dell'acqua, si trova un sensore a effetto Hall. A ogni giro il magnete passa davanti al sensore Hall e in uscita compare un impulso a onda quadra. Più l'acqua scorre veloce, più la turbina gira in fretta e più sale la frequenza degli impulsi. Così l'acqua viene misurata senza mai toccare l'elettronica. Trovi come funzionano i sensori Hall con i magneti nell'articolo sensore Hall.

CaratteristicaYF-S201 (valori tipici)
Campo di misura1–30 L/min
Relazione degli impulsiF (Hz) = 7,5 × Q (L/min)
Impulsi per litroCirca 450 impulsi/L (un impulso circa 2,2 mL)
Tensione di alimentazione5–18 V DC (5 V nei progetti hobbistici)
CorrenteAl massimo circa 15 mA (a 5 V)
UscitaImpulsi a onda quadra, duty cycle circa 50%, al livello dell'alimentazione
PrecisioneCirca ±10% senza calibrazione
AttaccoFiletto maschio G1/2 (mezzo pollice)
Pressione massima1,75 MPa (alcuni venditori indicano 2,0 MPa)
CaviRosso: VCC, nero: GND, giallo: segnale

Cosa significa la formula 7,5 Hz = 1 L/min?

La relazione del produttore F = 7,5 × Q dice che con una portata di 1 litro al minuto il sensore produce 7,5 impulsi al secondo. Ne derivano due formule pratiche: per la portata Q (L/min) = F / 7,5, per il volume totale Litri = impulsi totali / 450. Il numero 450 è il prodotto di 7,5 impulsi al secondo per i 60 secondi di un minuto. Per esempio, se conti 60 impulsi in un secondo la portata è 60 / 7,5 = 8 L/min; se durante una doccia conti 22.500 impulsi, sono stati usati 22.500 / 450 = 50 litri d'acqua.

Portata (L/min)Frequenza (Hz)Impulsi in 1 secondoTempo per 1 L
1 (limite inferiore)7,57–860 secondi
5 (rubinetto poco aperto)37,537–3812 secondi
10 (rubinetto tutto aperto)75756 secondi
201501503 secondi
30 (limite superiore)2252252 secondi

La prima riga mostra un limite importante: quando in una finestra di 1 secondo si contano solo 7–8 impulsi, un impulso di errore sposta la misura di circa il 13%. Per un risultato più stabile a bassa portata puoi allungare la finestra a 2–5 secondi o fare la media delle ultime misure. Il calcolo dei litri totali non ha questo problema, perché gli impulsi si sommano senza perdersi.

Collegamento del sensore di flusso acqua

Cavo del sensoreArduino UnoESP32Raspberry Pi Pico
Rosso (VCC)5VVIN (5 V dall'USB)VBUS (5 V dall'USB)
Nero (GND)GNDGNDGND
Giallo (segnale)D2 (diretto)GPIO 27, tramite partitore di tensioneGP15, tramite partitore di tensione
Resistenze del partitoreNon servono10 kΩ (segnale–pin) + 20 kΩ (pin–GND)10 kΩ (segnale–pin) + 20 kΩ (pin–GND)
Livello alto visto dal pin5 VCirca 3,3 VCirca 3,3 V
Quando lo YF-S201 è alimentato a 5 V, anche la sua uscita di segnale è a 5 V. I pin di ESP32 e Pico accettano al massimo 3,3 V; collegare direttamente il cavo giallo può danneggiare il pin col tempo. Un partitore di tensione da 10 kΩ e 20 kΩ porta 5 V a 5 × 20 / 30 ≈ 3,3 V. Puoi verificare i valori con le tue resistenze nel calcolatore del partitore di tensione e leggerne il principio nell'articolo partitore di tensione.

Sull'Uno collega sempre il segnale a un pin di interrupt: su Uno e Nano solo D2 e D3 supportano interrupt esterni. Alcune schede sensore hanno un'uscita open collector senza resistenza di pull-up propria; per questo aprire il pin con INPUT_PULLUP nel codice dell'Uno è sicuro con entrambi i tipi di sensore. Se il cavo è lungo (qualche metro), tieni la linea del segnale lontana dai cavi di motori e pompe e, se serve, aggiungi un condensatore da 100 nF tra segnale e GND per ridurre gli impulsi di disturbo.

Perché si contano gli impulsi con un interrupt?

A 30 L/min il sensore produce 225 impulsi al secondo, uno ogni 4,4 millisecondi. Un programma che interroga il pin con digitalRead nel loop() ne perde una parte ogni volta che si mette in mezzo un delay(), un aggiornamento dell'LCD o un'operazione Wi-Fi, e la misura risulta più bassa senza avvisare. Un interrupt fa sì che il processore lasci ciò che sta facendo ed esegua una piccola funzione nell'istante in cui cambia il livello del pin; qualunque cosa faccia il programma, nessun impulso va perso. La funzione di interrupt deve essere il più corta possibile: incrementa solo il contatore, mentre calcoli e stampe avvengono nel loop(). Per i dettagli leggi l'articolo interrupt su Arduino.

Codice Arduino: portata e litri totali

  1. Monta il sensore in modo che l'acqua scorra nel verso della freccia sul corpo.
  2. Collega il cavo rosso a 5V, il nero a GND e il giallo a D2.
  3. Carica il codice qui sotto e apri il Monitor seriale a 9600 baud.
  4. Apri piano il rubinetto; vedrai salire la portata e accumularsi i litri totali.
  5. Quando chiudi il rubinetto la portata torna a zero, mentre i litri totali restano all'ultimo valore.
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}
RigaCosa fa?
volatile unsigned long darbeContatore condiviso tra interrupt e loop(); volatile impedisce al compilatore di tenerne il valore in cache
attachInterrupt(..., FALLING)darbeSay() viene eseguita ogni volta che il segnale scende da HIGH a LOW
noInterrupts() / interrupts()Sospende per un attimo gli interrupt perché nessuno alteri il contatore da 4 byte mentre lo si legge
sure = (simdi - oncekiZaman) / 1000.0Calcola con la finestra reale anche se non è esattamente di 1000 ms
(sayi / sure) * 60 / DARBE_LITREConverte la frequenza in L/min; con DARBE_LITRE a 450 equivale a F / 7,5
toplamDarbe / DARBE_LITRECalcola i litri totali dagli impulsi accumulati
Usare nella formula la costante DARBE_LITRE al posto di 7,5 riduce la calibrazione a una sola riga: scrivi lì il numero di impulsi per litro trovato per il tuo sensore e portata e litri totali si correggono insieme. Per non perdere il totale durante un blackout puoi salvarlo in EEPROM; ma non a ogni impulso, piuttosto per esempio ogni 10 litri, così le celle non si consumano.

Calibrazione del sensore di flusso acqua

450 impulsi/L è il valore medio del produttore; su un sensore reale uno scarto del 5–10% dovuto a posizione di montaggio, pressione, diametro del tubo e portata è normale. Per calibrare basta un recipiente di volume noto: un misurino da 1 o 2 litri, meglio ancora una tanica da 5 litri. Provare nell'impianto in cui userai il sensore, con una portata simile, dà il risultato più preciso, perché i giri della turbina per litro cambiano un po' tra portata bassa e alta.

  1. Carica il codice di calibrazione qui sotto e apri il Monitor seriale (fine riga: A capo).
  2. Tieni l'estremità del tubo sopra il misurino vuoto e scrivi r nel Monitor seriale per azzerare il contatore.
  3. Apri il rubinetto alla portata abituale e chiudilo quando il misurino arriva esattamente al segno.
  4. Scrivi nel Monitor seriale il volume del misurino in litri (es. 2); il codice calcola gli impulsi per litro.
  5. Ripeti almeno tre volte e inserisci la media nella costante DARBE_LITRE del codice principale.
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}

Per esempio, se riempiendo il misurino da 2 litri hai contato 931 impulsi, il fattore del tuo sensore è 931 / 2 = 465,5 impulsi/L; continuando a usare 450 segnerebbe circa 3,4 litri in più ogni 100 litri. Per verificare anche la portata, cronometra il riempimento: se 2 litri si riempiono in 15 secondi, la portata reale è 2 / 15 × 60 = 8 L/min e puoi confrontarla con il valore del Monitor seriale.

Contatore d'acqua e allarme perdite

L'uso più utile di un sensore di flusso è accorgersi di un flusso inatteso. Acqua che scorre mentre nessuno in casa la usa, o un rubinetto rimasto aperto per molti minuti, indicano una perdita o una gomma dimenticata. Il codice seguente fa suonare un buzzer e chiude, tramite un relè, un'elettrovalvola che interrompe l'acqua se il flusso continua senza pause oltre un tempo stabilito o supera in una volta una quantità stabilita. Premendo il pulsante l'allarme si azzera e la valvola si riapre.

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}

Scegli le soglie in base al tuo uso: una doccia scorre a 8–12 L/min per 5–10 minuti e consuma 50–100 litri, mentre irrigare un giardino può durare molto di più. Le elettrovalvole di solito funzionano a 12 V e si alimentano da un alimentatore separato tramite un modulo relè; per il cablaggio leggi l'articolo modulo relè. Tieni presente anche che un rubinetto che gocciola o una cassetta che perde disperdono pochi litri all'ora, molto sotto il limite inferiore di 1 L/min dello YF-S201; perdite così piccole il sensore non le vede. Per scoprirle aggiungi un secondo controllo che registra ogni impulso di notte, oppure un sensore di livello dell'acqua appoggiato a terra.

Monitorare i consumi d'acqua con un ESP32

Scheda di sviluppo ESP32
L'ESP32 può contare gli impulsi del sensore di flusso e intanto servire una pagina web via Wi-Fi.

Tutti i pin GPIO dell'ESP32 supportano gli interrupt e il Wi-Fi ti permette di seguire la misura dal telefono. Il codice seguente legge il sensore sul GPIO 27 (tramite il partitore), mostra la portata attuale e i litri totali in una pagina web che si aggiorna ogni due secondi e salva il totale in flash con Preferences, così il contatore riparte da dove era anche dopo un blackout. Per non consumare la flash, salva solo quando il totale è cambiato di almeno 1 litro e al massimo una volta al minuto.

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}

Dopo il caricamento basta scrivere l'indirizzo IP mostrato nel Monitor seriale nel browser di un telefono sulla stessa rete. Sull'ESP32 si aggiunge IRAM_ATTR alla funzione di interrupt perché deve poter girare anche mentre si legge la flash; il contatore si protegge con portENTER_CRITICAL invece di noInterrupts() perché l'ESP32 ha due core. Se vuoi grafici giornalieri o una notifica quando si supera una soglia, puoi inviare la stessa misura a MQTT e Home Assistant o a un bot Telegram.

Codice MicroPython per Raspberry Pi Pico

Anche sul Pico tutti i GPIO supportano gli interrupt. Alimenta il sensore a 5 V da VBUS e collega il segnale a GP15 tramite un partitore da 10 kΩ + 20 kΩ. In MicroPython la funzione di interrupt si assegna con Pin.irq, e machine.disable_irq() disattiva per un attimo gli interrupt mentre si legge il contatore.

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

Uso con pompa e impianto di irrigazione

Mini pompa sommersa da 6 V
Le mini pompe sommerse di solito erogano meno di 1–2 litri al minuto; per questo campo serve un sensore di flusso più piccolo dello YF-S201.

Nei progetti di irrigazione un sensore di flusso serve anche a confermare che la pompa spinga davvero acqua. Se pochi secondi dopo l'avvio non arrivano impulsi, il serbatoio è vuoto, il tubo è ostruito o la pompa è guasta; spegnerla in quel momento evita che giri a secco e si bruci. Le piccole pompe sommerse da 3–6 V dei kit, però, spesso erogano meno di 1 L/min e restano fuori dal campo di misura dello YF-S201. In questi montaggi usa un sensore piccolo come lo YF-S401, per 0,3–6 L/min. Per il collegamento della pompa leggi pompa d'acqua con Arduino, per un sistema completo il progetto di serra intelligente.

Dimensioni, pressione e scelta del modello

ModelloAttaccoCampo di misuraRelazione degli impulsiImpulsi per litro
YF-S401Tubo sottile (circa 6 mm)0,3–6 L/minF = 98 × QCirca 5880
YF-S201G1/2 (mezzo pollice), plastica1–30 L/minF = 7,5 × QCirca 450
YF-B1G1/2, corpo in ottone1–25 L/minF = 11 × QCirca 660
FS300AG3/4 (tre quarti di pollice)1–60 L/minF = 5,5 × QCirca 330
  • Scegli in base al tubo: in casa gli attacchi di rubinetti e docce sono per lo più da mezzo pollice; lo YF-S201 si monta senza adattatori. Un sensore piccolo su una tubazione più grande strozza la portata.
  • Pressione: la pressione dell'acquedotto in casa è di solito tra 2 e 5 bar (0,2–0,5 MPa), molto sotto il limite di 1,75 MPa dello YF-S201. La turbina oppone comunque resistenza all'acqua e a portate alte crea una piccola perdita di carico.
  • Verso del flusso e posizione: rispetta la freccia sul corpo, monta il sensore in orizzontale se puoi e lascia davanti qualche decina di centimetri di tubo diritto. Subito dopo una curva le turbolenze aumentano l'errore.
  • Bolle d'aria e sedimenti: l'aria fa girare la turbina a vuoto e crea falsi impulsi, mentre sabbia e calcare la frenano. Se serve, metti un filtro prima del sensore.
  • Corpo in plastica: il corpo in nylon dello YF-S201 resiste all'acqua calda e agli urti meno dei modelli in ottone. Inoltre la maggior parte dei modelli economici non è omologata per l'acqua potabile; su una linea di acqua da bere scegli un modello per uso alimentare.
  • Tenuta: avvolgi del nastro in PTFE sui filetti, senza lasciarlo entrare nella camera della turbina. Stringi il sensore a mano; con una pinza puoi crepare il filetto in plastica.

Idee di progetto con un sensore di flusso acqua

  • Contatore per la doccia: mostra su un display LCD I2C quanti litri ha consumato una doccia e avvisa con un buzzer oltre una quantità stabilita.
  • Irrigazione intelligente: avvia la pompa quando l'umidità del terreno scende, misura in litri l'acqua erogata e fermati alla quantità obiettivo. Per misurare l'umidità leggi l'articolo sensore di umidità del terreno.
  • Contatore d'acqua di casa: registra con un ESP32 i consumi giornalieri, settimanali e mensili e invia una notifica se rilevi flusso di notte.
  • Protezione della pompa: se a pompa accesa non c'è flusso, spegnila dopo qualche secondo e segnala il guasto con un LED.
  • Controllo del filtro dell'acquario: segui la portata che cala man mano che il filtro si intasa e avvisa quando va pulito.
  • Dosatrice: costruisci una stazione di riempimento automatica che riempie un contenitore con esattamente 2 litri d'acqua e chiude la valvola.

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
Portata sempre 0Segnale su un pin senza interrupt o sensore montato al contrarioUsa D2 o D3 sull'Uno; confronta il verso dell'acqua con la freccia sul corpo
Impulsi contati senza flusso d'acquaDisturbi su un cavo lungo o pin flottanteUsa INPUT_PULLUP, aggiungi 100 nF tra segnale e GND, allontana il cavo dai fili dei motori
I litri misurati differiscono del 10% dalla realtàSensore non calibratoCalibra con un misurino e aggiorna DARBE_LITRE
La misura salta a bassa portataTroppo pochi impulsi nella finestra di 1 secondoAllunga la finestra a 2–5 secondi o fai la media
L'ESP32 si riavvia a caso o il pin è danneggiatoSegnale a 5 V collegato direttamente a un pin a 3,3 VUsa un partitore da 10 kΩ + 20 kΩ o un convertitore di livello logico
I litri totali si azzerano dopo un blackoutIl contatore esiste solo in RAMSalva periodicamente il totale in EEPROM o in Preferences
Nessun impulso con una pompa piccolaPortata inferiore a 1 L/minUsa un sensore per basse portate come lo YF-S401
Quando monti un nuovo impianto, fai prima qualche misura con il codice di calibrazione e annota i risultati. Lo stesso sensore può misurare qualche punto percentuale diverso in orizzontale o in verticale, o con un'altra pressione; calibrare nel punto in cui il sensore resterà è il metodo più affidabile.

Il sensore di flusso acqua YF-S201 è perfetto per imparare a contare impulsi con gli interrupt e, ben calibrato, fornisce misure affidabili in molti progetti, dal contatore d'acqua di casa all'irrigazione automatica. Nell'app BlueGrays trovi la stazione di irrigazione intelligente e progetti di misura con LCD, con schemi e codice passo passo, a cui puoi aggiungere facilmente il sensore di flusso.

Domande frequenti

Come funziona un sensore di flusso acqua?

Una turbina dentro il sensore gira con l'acqua e il suo magnete passa davanti a un sensore Hall a ogni giro. Il sensore Hall genera un impulso a ogni passaggio e, più l'acqua scorre veloce, più sale la frequenza degli impulsi. Arduino conta questi impulsi per calcolare portata e litri totali.

Quanti impulsi per litro dà lo YF-S201?

La formula del produttore è F = 7,5 × Q, quindi produce 7,5 Hz a 1 L/min. Ciò corrisponde a circa 450 impulsi per litro. Un sensore reale può scostarsi del 5–10%, perciò conviene calibrarlo con un misurino per trovare il tuo fattore.

Si può collegare un sensore di flusso direttamente a un ESP32?

Alimentato a 5 V, lo YF-S201 dà un segnale a 5 V, troppo alto per i pin a 3,3 V dell'ESP32. Devi aggiungere sulla linea del segnale un partitore da 10 kΩ e 20 kΩ o un convertitore di livello logico. L'alimentazione del sensore può arrivare dal pin VIN dell'ESP32.

Perché il sensore di flusso va su un pin di interrupt?

A portate alte il sensore produce oltre 200 impulsi al secondo, e un programma che interroga il pin nel loop() ne perde durante le pause o gli aggiornamenti del display. L'interrupt esegue subito una piccola funzione a ogni impulso, quindi non se ne perde nessuno. Sull'Arduino Uno i pin di interrupt sono D2 e D3.

Un sensore di flusso rileva le perdite d'acqua?

Le perdite grandi, come un rubinetto o una gomma aperti a lungo, si scoprono facilmente controllando la durata del flusso continuo e i litri consumati. Le perdite molto piccole come un rubinetto che gocciola, invece, restano sotto il limite inferiore di 1 L/min dello YF-S201 e non si vedono. Per quelle serve un rilevatore d'acqua a pavimento o un contatore più sensibile.

Su quale tubo si monta lo YF-S201?

Lo YF-S201 ha un filetto maschio G1/2, cioè da mezzo pollice, a entrambe le estremità e si adatta direttamente alla maggior parte degli attacchi di rubinetti e docce di casa. Per tubi più sottili c'è lo YF-S401, per le tubazioni da tre quarti l'FS300A. Basta avvolgere nastro in PTFE sui filetti e stringere il sensore a mano.

Vedi tutti i progetti
Temperatura e umidità con DHT11
AR-55Intermedio

Temperatura e umidità con DHT11

Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

4.7(47)
83
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

HC-SR04 Misura della distanza (display seriale)

Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

4.6(50)
82
Stazione di irrigazione intelligente
AR-83Avanzato
Premium

Stazione di irrigazione intelligente

Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

5.0(42)
57
Voltmetro digitale con display LCD
AR-56Intermedio
Premium

Voltmetro digitale con display LCD

Scopri quanta tensione dà una pila o un alimentatore con uno strumento costruito da te.

4.5(27)
36
Schermo LCD I2C per ESP32 (16x2)
ES-17Intermedio
Premium

Schermo LCD I2C per ESP32 (16x2)

In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).

4.9(23)
40
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)

In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

4.8(16)
26
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

Connessione Wi-Fi STA con ESP32 (con display LCD)

In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.

4.4(21)
38