Sensor de fluxo de água com Arduino: meça vazão e litros com YF-S201
Como conectar o sensor de fluxo de água YF-S201 ao Arduino: contagem de pulsos, fórmula 7,5 Hz = 1 L/min, calibração, medidor de água, alarme de vazamento e código para ESP32 e Pico.
Um sensor de fluxo de água mede a rapidez com que a água passa por um tubo (a vazão) e o volume total que passou, e é um dos componentes de medição mais fáceis de ler com um Arduino. O YF-S201, modelo mais comum em projetos de hobby, encaixa em tubos de meia polegada e produz pulsos com maior frequência quanto mais água passa por ele. Contando esses pulsos, você pode calcular quantos litros por minuto estão passando, quantos litros um banho ou ciclo de irrigação consumiu e se há um vazamento em algum ponto da tubulação.
Neste guia, você aprenderá como funcionam a turbina e o sensor Hall internos, de onde vem a fórmula 7,5 Hz = 1 L/min, como conectar o sensor com segurança a um Arduino Uno, ESP32 e Raspberry Pi Pico, como contar pulsos com uma interrupção e como calcular a vazão e o total de litros. Depois, vai calibrar o sensor com um recipiente graduado, montar um alarme de vazamento, monitorar o consumo de água por Wi-Fi com um ESP32 e conferir orientações práticas sobre tamanho, pressão e instalação.
O que é um sensor de fluxo de água e como funciona?
Dentro do corpo plástico do YF-S201 há uma pequena turbina (rotor) que gira com o fluxo da água. A turbina carrega um ímã, e um sensor de efeito Hall fica em um compartimento vedado, fora do caminho da água. A cada volta da turbina, o ímã passa pelo sensor Hall e um pulso de onda quadrada aparece na saída. Quanto mais rápido a água flui, mais rápido a turbina gira e maior é a frequência dos pulsos. A água é medida sem nunca tocar na eletrônica. Veja em detalhes como os sensores Hall respondem a ímãs no artigo sobre o sensor Hall.
| Característica | YF-S201 (valores típicos) |
|---|---|
| Faixa de medição | 1–30 L/min |
| Relação dos pulsos | F (Hz) = 7,5 × Q (L/min) |
| Pulsos por litro | Cerca de 450 pulsos/L (um pulso equivale a cerca de 2,2 mL) |
| Tensão de alimentação | 5–18 V CC (5 V em projetos de hobby) |
| Corrente | Até cerca de 15 mA (a 5 V) |
| Saída | Pulsos de onda quadrada, ciclo de trabalho de cerca de 50%, no nível da alimentação |
| Precisão | Cerca de ±10% sem calibração |
| Conexão | Rosca macho G1/2 (meia polegada) |
| Pressão máxima | 1,75 MPa (alguns vendedores informam 2,0 MPa) |
| Fios | Vermelho: VCC, preto: GND, amarelo: sinal |
O que significa a fórmula 7,5 Hz = 1 L/min?
A relação do fabricante F = 7,5 × Q indica que, com uma vazão de 1 litro por minuto, o sensor produz 7,5 pulsos por segundo. Dela vêm duas fórmulas práticas: para a vazão, Q (L/min) = F / 7,5; para o volume total, Litros = total de pulsos / 450. O número 450 vem de 7,5 pulsos por segundo multiplicados pelos 60 segundos de um minuto. Por exemplo, se você contar 60 pulsos em um segundo, a vazão será 60 / 7,5 = 8 L/min; se contar 22.500 pulsos durante um banho, foram usados 22.500 / 450 = 50 litros de água.
| Vazão (L/min) | Frequência (Hz) | Pulsos em 1 segundo | Tempo para encher 1 L |
|---|---|---|---|
| 1 (limite inferior) | 7,5 | 7–8 | 60 segundos |
| 5 (torneira pouco aberta) | 37,5 | 37–38 | 12 segundos |
| 10 (torneira totalmente aberta) | 75 | 75 | 6 segundos |
| 20 | 150 | 150 | 3 segundos |
| 30 (limite superior) | 225 | 225 | 2 segundos |
A primeira linha mostra um limite importante: quando apenas 7–8 pulsos são contados em uma janela de 1 segundo, um erro de um pulso altera a leitura em cerca de 13%. Para obter um resultado mais estável em baixa vazão, você pode ampliar a janela para 2–5 segundos ou calcular a média das últimas leituras. O cálculo do total de litros não tem esse problema, porque os pulsos se acumulam sem serem perdidos.
Ligação do sensor de fluxo de água
| Fio do sensor | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Vermelho (VCC) | 5V | VIN (5 V do USB) | VBUS (5 V do USB) |
| Preto (GND) | GND | GND | GND |
| Amarelo (sinal) | D2 (direto) | GPIO 27, por um divisor de tensão | GP15, por um divisor de tensão |
| Resistores do divisor | Não são necessários | 10 kΩ (sinal–pino) + 20 kΩ (pino–GND) | 10 kΩ (sinal–pino) + 20 kΩ (pino–GND) |
| Nível alto recebido pelo pino | 5 V | Cerca de 3,3 V | Cerca de 3,3 V |
No Uno, conecte sempre o sinal a um pino de interrupção: no Uno e no Nano, apenas D2 e D3 suportam interrupções externas. Algumas placas de sensor têm saída de coletor aberto sem resistor de pull-up próprio, então configurar o pino com INPUT_PULLUP no código do Uno é seguro para os dois tipos de sensor. Se o cabo for longo (alguns metros), mantenha o fio de sinal longe dos fios de motores e bombas e, se necessário, adicione um capacitor de 100 nF entre o sinal e GND para reduzir pulsos causados por ruído.
Por que contar pulsos com uma interrupção?
A 30 L/min, o sensor produz 225 pulsos por segundo, um a cada 4,4 milissegundos. Um programa que consulta o pino com digitalRead em loop() perde alguns desses pulsos sempre que um delay(), uma atualização do LCD ou uma operação de Wi-Fi interrompe a consulta, e a leitura fica abaixo do valor real sem nenhum aviso. Uma interrupção faz o processador suspender o que está fazendo e executar uma pequena função no instante em que o nível do pino muda; independentemente do que o programa estiver fazendo, nenhum pulso é perdido. A função de interrupção deve ser o mais curta possível: ela apenas incrementa o contador, enquanto os cálculos e a saída para o display acontecem em loop(). Para saber mais, veja o artigo sobre interrupções no Arduino.
Código Arduino: vazão e total de litros
- Instale o sensor para que a água flua na direção da seta no corpo.
- Conecte o fio vermelho a 5V, o preto a GND e o amarelo a D2.
- Carregue o código abaixo e abra o Monitor Serial a 9600 baud.
- Abra a torneira devagar; observe a vazão aumentar e o total de litros se acumular.
- Ao fechar a torneira, a vazão cai para zero, enquanto o total permanece no último valor.
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}| Linha | O que faz? |
|---|---|
| volatile unsigned long darbe (contador de pulsos compartilhado com a interrupção) | Contador compartilhado entre a interrupção e loop(); volatile impede que o compilador mantenha seu valor em cache |
| attachInterrupt(..., FALLING) | darbeSay() é executada toda vez que o sinal passa de HIGH para LOW |
| noInterrupts() / interrupts() | Pausa as interrupções brevemente para que nenhuma corrompa o contador de 4 bytes no meio da leitura |
| sure = (simdi - oncekiZaman) / 1000.0 | Calcula com a janela real, mesmo que ela não seja exatamente de 1.000 ms |
| (sayi / sure) * 60 / DARBE_LITRE | Converte a frequência em L/min; com DARBE_LITRE em 450, equivale a F / 7,5 |
| toplamDarbe / DARBE_LITRE | Calcula o total de litros a partir dos pulsos acumulados |
Calibração do sensor de fluxo de água
450 pulsos/L é a média do fabricante; em um sensor real, é normal haver um desvio de 5–10% causado pela orientação de montagem, pressão da água, diâmetro do tubo e vazão. Para calibrar, você só precisa de um recipiente com volume conhecido: uma jarra graduada de 1 ou 2 litros ou, melhor ainda, um galão de 5 litros. Testar na instalação em que o sensor será usado, com uma vazão aproximadamente igual, dá o resultado mais preciso, porque o número de voltas da turbina por litro varia um pouco entre vazões baixas e altas.
- Carregue o código de calibração abaixo e abra o Monitor Serial (final de linha: Nova linha).
- Segure a ponta do tubo sobre a jarra vazia e digite r no Monitor Serial para zerar o contador.
- Abra a torneira na vazão normal de uso e feche-a quando a água atingir exatamente a marca da jarra.
- Digite o volume da jarra em litros no Monitor Serial (por exemplo, 2); o código calcula os pulsos por litro.
- Repita pelo menos três vezes e insira a média na constante DARBE_LITRE do código 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}Por exemplo, se você contou 931 pulsos ao encher a jarra de 2 litros, o fator do seu sensor é 931 / 2 = 465,5 pulsos/L; se continuasse usando 450, a leitura indicaria cerca de 3,4 litros a mais a cada 100 litros. Para verificar também a vazão, cronometre quanto tempo a jarra leva para encher: se 2 litros enchem em 15 segundos, a vazão real é 2 / 15 × 60 = 8 L/min e você pode compará-la à leitura do Monitor Serial.
Medidor de água e alarme de vazamento
A função mais útil de um sensor de fluxo de água é identificar fluxo inesperado. Água passando quando ninguém em casa está usando água, ou uma torneira aberta por muitos minutos, indica um vazamento ou uma mangueira esquecida aberta. O código abaixo aciona um buzzer e, por meio de um relé, fecha uma válvula solenoide para cortar a água se o fluxo continuar sem pausa por mais que o tempo definido ou se o volume ultrapassar o limite de uma só vez. Pressionar o botão redefine o alarme e reabre a válvula.
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}Escolha os limites conforme seu uso: um banho tem vazão de 8–12 L/min durante 5–10 minutos e consome 50–100 litros, enquanto regar um jardim pode levar muito mais tempo. Válvulas solenoides geralmente funcionam com 12 V e são alimentadas por uma fonte separada por meio de um módulo relé; veja a ligação no artigo sobre o módulo relé. Lembre-se de que uma torneira pingando ou uma caixa de descarga vazando perde alguns litros por hora, muito abaixo do limite inferior de 1 L/min do YF-S201; o sensor não consegue detectar vazamentos tão pequenos. Para identificá-los, adicione uma segunda verificação que registre cada pulso durante a noite ou um sensor de nível de água colocado no chão.
Monitoramento do consumo de água com ESP32

Todos os pinos GPIO do ESP32 suportam interrupções, e o Wi-Fi permite acompanhar as leituras pelo celular. O código abaixo lê o sensor no GPIO 27 (por meio do divisor), mostra a vazão atual e o total de litros em uma página web que atualiza a cada dois segundos e salva o total na flash com Preferences, para que o medidor continue de onde parou mesmo após uma queda de energia. Para evitar o desgaste da flash, ele só salva quando o total muda pelo menos 1 litro e, no máximo, uma vez por minuto.
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}Após carregar o código, basta digitar o endereço IP mostrado no Monitor Serial no navegador de um celular conectado à mesma rede. No ESP32, IRAM_ATTR é adicionado à função de interrupção porque ela precisa poder ser executada mesmo durante a leitura da flash; portENTER_CRITICAL protege o contador no lugar de noInterrupts(), porque o ESP32 tem dois núcleos. Se você quiser gráficos diários ou uma notificação no celular quando um limite for ultrapassado, pode enviar a mesma leitura para MQTT e Home Assistant ou para um bot do Telegram.
Código MicroPython para Raspberry Pi Pico
Todos os GPIO do Pico também suportam interrupções. Alimente o sensor com 5 V de VBUS e conecte o sinal a GP15 por meio de um divisor de 10 kΩ + 20 kΩ. No MicroPython, a função de interrupção é vinculada com Pin.irq, e machine.disable_irq() desativa as interrupções brevemente durante a leitura do contador.
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 em um sistema de bomba e irrigação

Em projetos de irrigação, um sensor de fluxo também é muito útil para confirmar que a bomba está realmente bombeando água. Se nenhum pulso chegar em alguns segundos após ligar a bomba, o reservatório está vazio, a mangueira está obstruída ou a bomba falhou; desligá-la nessa situação evita que funcione a seco e queime. Porém, as pequenas bombas submersíveis de 3–6 V dos kits de hobby costumam fornecer menos de 1 L/min e ficam fora da faixa de medição do YF-S201. Nesses sistemas, use um sensor pequeno, como o YF-S401, especificado para 0,3–6 L/min. Para a ligação da bomba, veja Bomba de água com Arduino; para um sistema completo, veja o projeto de estufa inteligente.
Tamanho, pressão e escolha do modelo
| Modelo | Conexão | Faixa de medição | Relação dos pulsos | Pulsos por litro |
|---|---|---|---|---|
| YF-S401 | Mangueira fina (cerca de 6 mm) | 0,3–6 L/min | F = 98 × Q | Cerca de 5.880 |
| YF-S201 | G1/2 (meia polegada), plástico | 1–30 L/min | F = 7,5 × Q | Cerca de 450 |
| YF-B1 | G1/2, corpo de latão | 1–25 L/min | F = 11 × Q | Cerca de 660 |
| FS300A | G3/4 (três quartos de polegada) | 1–60 L/min | F = 5,5 × Q | Cerca de 330 |
- Escolha pelo diâmetro do tubo: As linhas de torneiras e chuveiros das instalações residenciais são, em sua maioria, de meia polegada; o YF-S201 encaixa nelas sem adaptadores. Usar um sensor pequeno em uma linha maior restringe o fluxo.
- Pressão: A pressão da rede de água em uma residência costuma ser de 2–5 bar (0,2–0,5 MPa), muito abaixo do limite de 1,75 MPa do YF-S201. Mesmo assim, a turbina oferece resistência ao fluxo e provoca uma pequena queda de pressão na linha em vazões altas.
- Direção do fluxo e posição: Siga a seta no corpo, instale o sensor na horizontal se possível e deixe algumas dezenas de centímetros de tubo reto antes dele. Um sensor instalado logo após um cotovelo apresenta maior desvio devido à turbulência.
- Bolhas de ar e sedimentos: O ar faz a turbina girar livremente e gera pulsos falsos, enquanto areia e calcário reduzem sua velocidade. Instale um filtro de tela antes do sensor, se necessário.
- Corpo plástico: O corpo de náilon do YF-S201 não resiste tão bem à água quente e a impactos quanto os modelos de latão. A maioria dos modelos baratos também não tem aprovação para água potável; em uma linha de água para consumo, escolha um modelo adequado para contato com alimentos.
- Vedação: Enrole fita de PTFE nas roscas, mas não deixe a fita entrar na câmara da turbina. Aperte o sensor à mão; usar um alicate pode rachar a rosca plástica.
Ideias de projetos com sensor de fluxo de água
- Medidor de banho: Mostre quantos litros um banho consumiu em um display LCD I2C e avise com um buzzer quando o volume definido for ultrapassado.
- Irrigação inteligente: Ligue a bomba quando a umidade do solo cair, meça a água fornecida em litros e pare ao atingir o volume desejado. Para medir a umidade, veja o artigo sobre o sensor de umidade do solo.
- Medidor de água residencial: Registre o consumo diário, semanal e mensal com um ESP32 e envie uma notificação se detectar fluxo durante a noite.
- Proteção da bomba: Se não houver fluxo enquanto a bomba estiver funcionando, desligue-a após alguns segundos e indique a falha com um LED.
- Monitor do filtro de aquário: Acompanhe a redução da vazão conforme o filtro fica obstruído e avise quando for hora de limpar.
- Máquina dosadora: Monte uma estação de enchimento automático que coloque exatamente 2 litros de água em um recipiente e feche a válvula.
Erros comuns e como resolvê-los
| Sintoma | Causa provável | Solução |
|---|---|---|
| Vazão sempre em 0 | Sinal ligado a um pino sem interrupções ou sensor instalado ao contrário | Use D2 ou D3 no Uno; compare a direção da água com a seta no corpo |
| Pulsos contados mesmo sem fluxo de água | Ruído em um cabo longo ou pino flutuante | Use INPUT_PULLUP, adicione 100 nF entre o sinal e GND e mantenha o cabo longe dos fios dos motores |
| Litros medidos 10% acima ou abaixo do valor real | Sensor não calibrado | Calibre com um recipiente graduado e atualize DARBE_LITRE |
| Leitura oscila em baixa vazão | Poucos pulsos em uma janela de 1 segundo | Amplie a janela para 2–5 segundos ou calcule a média |
| ESP32 reinicia aleatoriamente ou o pino foi danificado | Sinal de 5 V conectado diretamente a um pino de 3,3 V | Use um divisor de tensão de 10 kΩ + 20 kΩ ou um conversor de nível lógico |
| Total de litros zera após uma queda de energia | O contador fica apenas na RAM | Salve o total na EEPROM ou com Preferences em intervalos regulares |
| Nenhum pulso com uma bomba pequena | Vazão abaixo de 1 L/min | Use um sensor de baixa vazão, como o YF-S401 |
O sensor de fluxo de água YF-S201 é um componente perfeito para aprender a contar pulsos com interrupções e, com a calibração adequada, fornece leituras confiáveis em muitos projetos, de um medidor de água residencial à irrigação automática. No app BlueGrays, você encontra a Estação de irrigação inteligente e projetos de medição com LCD, com esquemas do circuito e código passo a passo, e pode adicionar um sensor de fluxo a eles com facilidade.
Perguntas frequentes
Como funciona um sensor de fluxo de água?
Uma turbina dentro do sensor gira quando a água passa, e o ímã preso a ela passa por um sensor Hall a cada volta. O sensor Hall produz um pulso a cada passagem e, quanto mais rápido a água flui, maior é a frequência dos pulsos. O Arduino conta esses pulsos para calcular a vazão e o total de litros.
Quantos pulsos por litro o YF-S201 gera?
A fórmula do fabricante é F = 7,5 × Q, então ele produz 7,5 Hz a 1 L/min. Isso significa cerca de 450 pulsos por litro. Um sensor real pode apresentar um desvio de 5–10%, por isso é recomendável calibrá-lo com um recipiente graduado para encontrar seu próprio fator.
Um sensor de fluxo de água pode ser conectado diretamente ao ESP32?
Quando o YF-S201 funciona com 5 V, seu sinal é de 5 V, o que excede o limite dos pinos de 3,3 V do ESP32. Você deve adicionar um divisor de tensão de 10 kΩ e 20 kΩ ou um conversor de nível lógico à linha de sinal. A alimentação do sensor pode vir do pino VIN do ESP32.
Por que o sensor de fluxo de água é conectado a um pino de interrupção?
Em alta vazão, o sensor produz mais de 200 pulsos por segundo, e um programa que consulta o pino em loop() perde pulsos durante atrasos ou atualizações do display. Uma interrupção executa instantaneamente uma pequena função a cada pulso, evitando perdas. No Arduino Uno, os pinos de interrupção são D2 e D3.
Um sensor de fluxo de água pode detectar vazamentos?
Vazamentos grandes, como uma torneira ou mangueira deixada aberta por muito tempo, são fáceis de identificar acompanhando o tempo de fluxo contínuo e os litros consumidos. Porém, vazamentos muito pequenos, como uma torneira pingando, ficam abaixo do limite inferior de 1 L/min do YF-S201 e passam despercebidos. Para esses casos, você precisa de um sensor de água no chão ou de um medidor mais sensível.
Em qual tubo o YF-S201 encaixa?
O YF-S201 tem rosca macho G1/2, ou meia polegada, nas duas extremidades e encaixa diretamente na maioria das linhas de torneiras e chuveiros das instalações residenciais. Para mangueiras mais finas, há modelos como o YF-S401; para linhas de três quartos de polegada, o FS300A. Basta enrolar fita de PTFE nas roscas e apertar o sensor à mão.
Projetos para montar depois desta leitura
Ver todos os projetos
Temperatura e umidade com DHT11
Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

Medição de distância com HC-SR04 (Monitor Serial)
O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

Estação de irrigação inteligente
Um jardineiro que rega suas plantas sozinho para que elas não sequem enquanto você está de férias.

Voltímetro digital com display LCD
Descubra a tensão de uma pilha ou de um adaptador de alimentação com um medidor feito por você.

Display LCD I2C com ESP32 (16x2)
Neste projeto, exibimos texto conectando um display LCD de 16x2 caracteres ao ESP32 pelo protocolo I2C. Com o I2C, controlamos o display usando apenas dois pinos de dados (SDA e SCL), dispensando o uso de seis ou mais pinos da conexão paralela tradicional. O código mostra uma mensagem fixa na primeira linha e um contador que aumenta a cada segundo na segunda linha. Na inicialização, também executamos um scanner I2C para mostrar o endereço do display no Monitor Serial (geralmente 0x27 ou 0x3F).

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

