Componentes · 12 min de leitura

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ísticaYF-S201 (valores típicos)
Faixa de medição1–30 L/min
Relação dos pulsosF (Hz) = 7,5 × Q (L/min)
Pulsos por litroCerca de 450 pulsos/L (um pulso equivale a cerca de 2,2 mL)
Tensão de alimentação5–18 V CC (5 V em projetos de hobby)
CorrenteAté cerca de 15 mA (a 5 V)
SaídaPulsos de onda quadrada, ciclo de trabalho de cerca de 50%, no nível da alimentação
PrecisãoCerca de ±10% sem calibração
ConexãoRosca macho G1/2 (meia polegada)
Pressão máxima1,75 MPa (alguns vendedores informam 2,0 MPa)
FiosVermelho: 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 segundoTempo para encher 1 L
1 (limite inferior)7,57–860 segundos
5 (torneira pouco aberta)37,537–3812 segundos
10 (torneira totalmente aberta)75756 segundos
201501503 segundos
30 (limite superior)2252252 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 sensorArduino UnoESP32Raspberry Pi Pico
Vermelho (VCC)5VVIN (5 V do USB)VBUS (5 V do USB)
Preto (GND)GNDGNDGND
Amarelo (sinal)D2 (direto)GPIO 27, por um divisor de tensãoGP15, por um divisor de tensão
Resistores do divisorNão são necessários10 kΩ (sinal–pino) + 20 kΩ (pino–GND)10 kΩ (sinal–pino) + 20 kΩ (pino–GND)
Nível alto recebido pelo pino5 VCerca de 3,3 VCerca de 3,3 V
Quando o YF-S201 é alimentado com 5 V, sua saída de sinal também fica em 5 V. Os pinos do ESP32 e do Pico aceitam no máximo 3,3 V; conectar o fio amarelo diretamente pode danificar o pino com o tempo. Um divisor de tensão de 10 kΩ e 20 kΩ reduz os 5 V para 5 × 20 / 30 ≈ 3,3 V. Você pode conferir os valores dos seus resistores com a calculadora de divisor de tensão e entender o funcionamento no artigo sobre o divisor de tensão.

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

  1. Instale o sensor para que a água flua na direção da seta no corpo.
  2. Conecte o fio vermelho a 5V, o preto a GND e o amarelo a D2.
  3. Carregue o código abaixo e abra o Monitor Serial a 9600 baud.
  4. Abra a torneira devagar; observe a vazão aumentar e o total de litros se acumular.
  5. Ao fechar a torneira, a vazão cai para zero, enquanto o total permanece no último valor.
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}
LinhaO 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.0Calcula com a janela real, mesmo que ela não seja exatamente de 1.000 ms
(sayi / sure) * 60 / DARBE_LITREConverte a frequência em L/min; com DARBE_LITRE em 450, equivale a F / 7,5
toplamDarbe / DARBE_LITRECalcula o total de litros a partir dos pulsos acumulados
Usar a constante DARBE_LITRE no lugar de 7,5 na fórmula reduz a calibração a uma única linha: você insere nessa constante o valor de pulsos por litro encontrado para seu sensor, e a vazão e o total de litros são corrigidos juntos. Para manter o total após uma queda de energia, você pode salvá-lo na EEPROM; mas grave, por exemplo, a cada 10 litros, não a cada pulso, para evitar o desgaste das células.

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.

  1. Carregue o código de calibração abaixo e abra o Monitor Serial (final de linha: Nova linha).
  2. Segure a ponta do tubo sobre a jarra vazia e digite r no Monitor Serial para zerar o contador.
  3. Abra a torneira na vazão normal de uso e feche-a quando a água atingir exatamente a marca da jarra.
  4. Digite o volume da jarra em litros no Monitor Serial (por exemplo, 2); o código calcula os pulsos por litro.
  5. Repita pelo menos três vezes e insira a média na constante DARBE_LITRE do código 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}

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.

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}

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

Placa de desenvolvimento ESP32
O ESP32 pode contar os pulsos do sensor de fluxo enquanto disponibiliza uma página web por Wi-Fi ao mesmo tempo.

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.

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}

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.

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 em um sistema de bomba e irrigação

Minibomba de água submersível de 6 V
Minibombas submersíveis geralmente fornecem menos de 1–2 litros por minuto; para essa faixa, você precisa de um sensor de fluxo menor que o YF-S201.

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

ModeloConexãoFaixa de mediçãoRelação dos pulsosPulsos por litro
YF-S401Mangueira fina (cerca de 6 mm)0,3–6 L/minF = 98 × QCerca de 5.880
YF-S201G1/2 (meia polegada), plástico1–30 L/minF = 7,5 × QCerca de 450
YF-B1G1/2, corpo de latão1–25 L/minF = 11 × QCerca de 660
FS300AG3/4 (três quartos de polegada)1–60 L/minF = 5,5 × QCerca 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

SintomaCausa provávelSolução
Vazão sempre em 0Sinal ligado a um pino sem interrupções ou sensor instalado ao contrárioUse D2 ou D3 no Uno; compare a direção da água com a seta no corpo
Pulsos contados mesmo sem fluxo de águaRuído em um cabo longo ou pino flutuanteUse 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 realSensor não calibradoCalibre com um recipiente graduado e atualize DARBE_LITRE
Leitura oscila em baixa vazãoPoucos pulsos em uma janela de 1 segundoAmplie a janela para 2–5 segundos ou calcule a média
ESP32 reinicia aleatoriamente ou o pino foi danificadoSinal de 5 V conectado diretamente a um pino de 3,3 VUse 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 energiaO contador fica apenas na RAMSalve o total na EEPROM ou com Preferences em intervalos regulares
Nenhum pulso com uma bomba pequenaVazão abaixo de 1 L/minUse um sensor de baixa vazão, como o YF-S401
Ao montar uma nova instalação, faça primeiro algumas medições com o código de calibração e anote os resultados. O mesmo sensor pode apresentar uma diferença de alguns por cento quando instalado na horizontal ou na vertical, ou sob outra pressão; calibrar no local onde o sensor ficará definitivamente é a abordagem mais confiável.

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.

Ver todos os projetos
Temperatura e umidade com DHT11
AR-55Intermediário

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…

4.7(47)
83
Medição de distância com HC-SR04 (Monitor Serial)
AR-27Iniciante

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.

4.6(50)
82
Estação de irrigação inteligente
AR-83Avançado
Premium

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.

5.0(42)
57
Voltímetro digital com display LCD
AR-56Intermediário
Premium

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

4.5(27)
36
Display LCD I2C com ESP32 (16x2)
ES-17Intermediário
Premium

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

4.9(23)
40
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

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.

4.8(16)
26
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

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.

4.4(21)
38