Componentes · 12 min de lectura

Sensor de flujo de agua Arduino: caudal y litros con YF-S201

Cómo conectar el sensor de flujo de agua YF-S201 a Arduino: contar pulsos, fórmula 7,5 Hz = 1 L/min, calibración, contador, alarma de fugas, ESP32 y Pico.

Un sensor de flujo de agua mide a qué velocidad pasa el agua por una tubería (el caudal) y cuánta ha pasado en total, y es una de las piezas de medida más fáciles de leer con Arduino. El modelo más común en proyectos de aficionados, el YF-S201, se monta en una tubería de media pulgada y genera pulsos con más frecuencia cuanta más agua circula. Contando esos pulsos puedes calcular cuántos litros por minuto fluyen, cuántos litros se gastaron en una ducha o en un ciclo de riego y si hay una fuga en algún punto de la tubería.

En esta guía aprenderás cómo funcionan la turbina y el sensor Hall de su interior, de dónde sale la fórmula 7,5 Hz = 1 L/min, cómo conectar el sensor con seguridad a un Arduino Uno, un ESP32 y una Raspberry Pi Pico, cómo contar pulsos con una interrupción y cómo calcular el caudal y los litros totales. Después calibrarás el sensor con una jarra medidora, montarás una alarma de fugas, seguirás el consumo de agua por Wi-Fi con un ESP32 y verás notas prácticas sobre tamaño, presión e instalación.

¿Qué es un sensor de flujo de agua y cómo funciona?

Dentro del cuerpo de plástico del YF-S201 hay una pequeña turbina (rodete) que gira con el paso del agua. La turbina lleva un imán y, en un compartimento estanco fuera del paso del agua, hay un sensor de efecto Hall. Cada vez que la turbina gira, el imán pasa por delante del sensor Hall y aparece un pulso de onda cuadrada en la salida. Cuanto más rápido fluye el agua, más rápido gira la turbina y mayor es la frecuencia de los pulsos. Así se mide el agua sin que toque nunca la electrónica. Encontrarás en detalle cómo responden los sensores Hall a un imán en el artículo sensor Hall.

CaracterísticaYF-S201 (valores típicos)
Rango de medida1–30 L/min
Relación de pulsosF (Hz) = 7,5 × Q (L/min)
Pulsos por litroUnos 450 pulsos/L (un pulso son unos 2,2 mL)
Tensión de alimentación5–18 V CC (5 V en proyectos de aficionados)
CorrienteHasta unos 15 mA (a 5 V)
SalidaPulsos de onda cuadrada, ciclo de trabajo cercano al 50 %, al nivel de la alimentación
PrecisiónUnos ±10 % sin calibrar
ConexiónRosca macho G1/2 (media pulgada)
Presión máxima1,75 MPa (algunos vendedores indican 2,0 MPa)
CablesRojo: VCC, negro: GND, amarillo: señal

¿Qué significa la fórmula 7,5 Hz = 1 L/min?

La relación del fabricante F = 7,5 × Q indica que con un caudal de 1 litro por minuto el sensor produce 7,5 pulsos por segundo. De ahí salen dos fórmulas prácticas: para el caudal, Q (L/min) = F / 7,5, y para el volumen total, Litros = pulsos totales / 450. El número 450 es el producto de 7,5 pulsos por segundo por los 60 segundos de un minuto. Por ejemplo, si cuentas 60 pulsos en un segundo, el caudal es 60 / 7,5 = 8 L/min; si cuentas 22.500 pulsos durante una ducha, se gastaron 22.500 / 450 = 50 litros de agua.

Caudal (L/min)Frecuencia (Hz)Pulsos en 1 segundoTiempo para 1 L
1 (límite inferior)7,57–860 segundos
5 (grifo poco abierto)37,537–3812 segundos
10 (grifo abierto del todo)75756 segundos
201501503 segundos
30 (límite superior)2252252 segundos

La primera fila muestra un límite importante: cuando en una ventana de 1 segundo solo se cuentan 7–8 pulsos, un pulso de error mueve la lectura cerca de un 13 %. Para un resultado más estable con caudal bajo puedes alargar la ventana a 2–5 segundos o promediar las últimas lecturas. El cálculo de litros totales no tiene este problema, porque los pulsos se acumulan sin perderse.

Conexión del sensor de flujo de agua

Cable del sensorArduino UnoESP32Raspberry Pi Pico
Rojo (VCC)5VVIN (5 V del USB)VBUS (5 V del USB)
Negro (GND)GNDGNDGND
Amarillo (señal)D2 (directo)GPIO 27, a través de un divisor de tensiónGP15, a través de un divisor de tensión
Resistencias del divisorNo hacen falta10 kΩ (señal–pin) + 20 kΩ (pin–GND)10 kΩ (señal–pin) + 20 kΩ (pin–GND)
Nivel alto que ve el pin5 VUnos 3,3 VUnos 3,3 V
Cuando el YF-S201 se alimenta con 5 V, su salida de señal también es de 5 V. Los pines del ESP32 y de la Pico admiten como máximo 3,3 V; conectar el cable amarillo directamente puede dañar el pin con el tiempo. Un divisor de tensión de 10 kΩ y 20 kΩ reduce 5 V a 5 × 20 / 30 ≈ 3,3 V. Puedes comprobar los valores con tus propias resistencias en la calculadora de divisor de tensión y leer cómo funciona en el artículo divisor de tensión.

En el Uno conecta siempre la señal a un pin de interrupción: en el Uno y el Nano solo D2 y D3 admiten interrupciones externas. Algunas placas de sensor tienen salida en colector abierto sin resistencia pull-up propia; por eso, abrir el pin con INPUT_PULLUP en el código del Uno es seguro con ambos tipos de sensor. Si el cable es largo (varios metros), aleja la línea de señal de los cables de motores y bombas y, si hace falta, añade un condensador de 100 nF entre señal y GND para reducir los pulsos de ruido.

¿Por qué se cuentan los pulsos con una interrupción?

A 30 L/min el sensor genera 225 pulsos por segundo, uno cada 4,4 milisegundos. Un programa que consulta el pin con digitalRead en loop() se pierde parte de esos pulsos cada vez que se interpone un delay(), una actualización de la LCD o una operación Wi-Fi, y la lectura sale baja sin avisar. Una interrupción hace que el procesador deje lo que está haciendo y ejecute una pequeña función en el instante en que cambia el nivel del pin; haga lo que haga el programa, no se pierde ningún pulso. La función de interrupción debe ser lo más corta posible: solo incrementa el contador, y los cálculos y la salida se hacen en loop(). Para los detalles consulta el artículo interrupciones en Arduino.

Código Arduino: caudal y litros totales

  1. Monta el sensor de modo que el agua fluya en el sentido de la flecha del cuerpo.
  2. Conecta el cable rojo a 5V, el negro a GND y el amarillo a D2.
  3. Sube el código de abajo y abre el Monitor Serie a 9600 baudios.
  4. Abre el grifo poco a poco; verás subir el caudal y acumularse los litros totales.
  5. Al cerrar el grifo, el caudal baja a cero y los litros totales se quedan en su ú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}
Línea¿Qué hace?
volatile unsigned long darbeContador compartido entre la interrupción y loop(); volatile impide que el compilador guarde su valor en caché
attachInterrupt(..., FALLING)darbeSay() se ejecuta cada vez que la señal baja de HIGH a LOW
noInterrupts() / interrupts()Detiene un momento las interrupciones para que ninguna corrompa el contador de 4 bytes mientras se lee
sure = (simdi - oncekiZaman) / 1000.0Calcula con la ventana real aunque no sea exactamente de 1000 ms
(sayi / sure) * 60 / DARBE_LITREConvierte la frecuencia a L/min; con DARBE_LITRE en 450 equivale a F / 7,5
toplamDarbe / DARBE_LITRECalcula los litros totales a partir de los pulsos acumulados
Usar la constante DARBE_LITRE en lugar de 7,5 en la fórmula reduce la calibración a una sola línea: escribes en ella el número de pulsos por litro que has obtenido para tu sensor, y el caudal y los litros totales se corrigen a la vez. Para no perder el total en un corte de luz puedes guardarlo en la EEPROM; pero no en cada pulso, sino por ejemplo cada 10 litros, para no desgastar las celdas.

Calibración del sensor de flujo de agua

450 pulsos/L es el valor medio del fabricante; en un sensor real es normal una desviación del 5–10 % por la posición de montaje, la presión del agua, el diámetro de la tubería y el caudal. Para calibrar basta un recipiente de volumen conocido: una jarra medidora de 1 o 2 litros, o mejor una garrafa de 5 litros. Probar en la instalación donde usarás el sensor, con un caudal parecido, da el resultado más exacto, porque las vueltas de la turbina por litro cambian algo entre caudal bajo y alto.

  1. Sube el código de calibración de abajo y abre el Monitor Serie (fin de línea: Nueva línea).
  2. Coloca el extremo de la tubería sobre la jarra vacía y escribe r en el Monitor Serie para poner el contador a cero.
  3. Abre el grifo con tu caudal habitual y ciérralo cuando la jarra llegue justo a la marca.
  4. Escribe el volumen de la jarra en litros en el Monitor Serie (p. ej. 2); el código calcula los pulsos por litro.
  5. Repite al menos tres veces y escribe la media en la constante DARBE_LITRE del 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 ejemplo, si al llenar la jarra de 2 litros contaste 931 pulsos, el factor de tu sensor es 931 / 2 = 465,5 pulsos/L; si siguieras usando 450, marcaría unos 3,4 litros de más por cada 100 litros. Para comprobar también el caudal, cronometra el llenado: si 2 litros se llenan en 15 segundos, el caudal real es 2 / 15 × 60 = 8 L/min y puedes compararlo con el valor del Monitor Serie.

Contador de agua y alarma de fugas

El uso más útil de un sensor de flujo de agua es detectar caudal inesperado. Que haya flujo cuando nadie en casa usa agua, o que un grifo quede abierto durante muchos minutos, apunta a una fuga o a una manguera olvidada. El código siguiente hace sonar un zumbador y cierra, a través de un relé, una electroválvula que corta el agua si el flujo continúa sin pausa durante más de un tiempo fijado o supera una cantidad fijada de una vez. Al pulsar el botón se reinicia la alarma y la válvula vuelve a abrirse.

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}

Elige los umbrales según tu uso: una ducha va a 8–12 L/min durante 5–10 minutos y gasta 50–100 litros, mientras que regar un jardín puede durar mucho más. Las electroválvulas suelen funcionar a 12 V y se alimentan desde un adaptador aparte a través de un módulo de relé; para el cableado consulta el artículo módulo relé. Ten en cuenta también que un grifo que gotea o una cisterna que pierde agua dejan escapar unos pocos litros por hora, muy por debajo del límite inferior de 1 L/min del YF-S201; el sensor no ve fugas tan pequeñas. Para detectarlas, añade una segunda comprobación que registre cada pulso de noche o un sensor de nivel de agua colocado en el suelo.

Seguir el consumo de agua con un ESP32

Placa de desarrollo ESP32
El ESP32 puede contar los pulsos del sensor de flujo y servir a la vez una página web por Wi-Fi.

Todos los pines GPIO del ESP32 admiten interrupciones y, gracias a la Wi-Fi, puedes seguir la medida desde el móvil. El código siguiente lee el sensor en el GPIO 27 (a través del divisor), muestra el caudal actual y los litros totales en una página web que se actualiza cada dos segundos y guarda el total en la flash con Preferences, de modo que el contador sigue donde lo dejó aunque se vaya la luz. Para no desgastar la flash, solo guarda cuando el total ha cambiado al menos 1 litro y como mucho una 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}

Después de subir el código, basta con escribir la dirección IP que aparece en el Monitor Serie en el navegador de un móvil de la misma red. En el ESP32 se añade IRAM_ATTR a la función de interrupción porque debe poder ejecutarse incluso mientras se lee la flash; el contador se protege con portENTER_CRITICAL en lugar de noInterrupts() porque el ESP32 tiene dos núcleos. Si quieres gráficos diarios o una notificación al superar un umbral, puedes enviar la misma medida a MQTT y Home Assistant o a un bot de Telegram.

Código MicroPython para la Raspberry Pi Pico

En la Pico también todos los GPIO admiten interrupciones. Alimenta el sensor con 5 V desde VBUS y conecta la señal a GP15 a través de un divisor de 10 kΩ + 20 kΩ. En MicroPython la función de interrupción se asigna con Pin.irq, y machine.disable_irq() desactiva las interrupciones un instante mientras se lee el 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 en un sistema con bomba y riego

Mini bomba de agua sumergible de 6 V
Las mini bombas sumergibles suelen dar menos de 1–2 litros por minuto; para ese rango necesitas un sensor de flujo más pequeño que el YF-S201.

En proyectos de riego, un sensor de flujo también sirve para confirmar que la bomba realmente impulsa agua. Si unos segundos después de arrancar la bomba no llegan pulsos, el depósito está vacío, la manguera está obstruida o la bomba ha fallado; apagarla entonces evita que funcione en seco y se queme. Sin embargo, las pequeñas bombas sumergibles de 3–6 V de los kits suelen dar menos de 1 L/min y quedan fuera del rango del YF-S201. En esos montajes usa un sensor pequeño como el YF-S401, para 0,3–6 L/min. Para el cableado de la bomba consulta bomba de agua con Arduino, y para un sistema completo el proyecto de invernadero inteligente.

Tamaño, presión y elección del modelo

ModeloConexiónRango de medidaRelación de pulsosPulsos por litro
YF-S401Manguera fina (unos 6 mm)0,3–6 L/minF = 98 × QUnos 5880
YF-S201G1/2 (media pulgada), plástico1–30 L/minF = 7,5 × QUnos 450
YF-B1G1/2, cuerpo de latón1–25 L/minF = 11 × QUnos 660
FS300AG3/4 (tres cuartos de pulgada)1–60 L/minF = 5,5 × QUnos 330
  • Elige según la tubería: En una vivienda, las tomas de grifos y duchas suelen ser de media pulgada; el YF-S201 se monta en ellas sin adaptadores. Poner un sensor pequeño en una tubería mayor estrangula el caudal.
  • Presión: La presión de la red en una casa suele estar entre 2 y 5 bar (0,2–0,5 MPa), muy por debajo del límite de 1,75 MPa del YF-S201. Aun así, la turbina opone resistencia al agua y provoca una pequeña pérdida de presión con caudales altos.
  • Sentido del flujo y posición: Respeta la flecha del cuerpo, monta el sensor en horizontal si puedes y deja delante unas decenas de centímetros de tubería recta. Un sensor colocado justo después de un codo se desvía más por las turbulencias.
  • Burbujas de aire y sedimentos: El aire hace girar la turbina en vacío y genera pulsos falsos, mientras que la arena y la cal la frenan. Si hace falta, pon un filtro antes del sensor.
  • Cuerpo de plástico: El cuerpo de nailon del YF-S201 no resiste el agua caliente y los golpes tan bien como los modelos de latón. La mayoría de los modelos baratos tampoco tienen homologación para agua potable; en una línea de agua de consumo elige un modelo apto para uso alimentario.
  • Estanqueidad: Enrolla cinta de teflón en las roscas, pero evita que entre cinta en la cámara de la turbina. Aprieta el sensor a mano; con alicates puedes partir la rosca de plástico.

Ideas de proyectos con un sensor de flujo de agua

  • Contador de ducha: Muestra en una pantalla LCD I2C cuántos litros se gastaron en una ducha y avisa con un zumbador al pasar de una cantidad fijada.
  • Riego inteligente: Arranca la bomba cuando baja la humedad del suelo, mide en litros el agua aportada y para al llegar a la cantidad objetivo. Para medir la humedad consulta el artículo sensor de humedad del suelo.
  • Contador de agua de casa: Registra con un ESP32 el consumo diario, semanal y mensual, y envía un aviso si detectas flujo por la noche.
  • Protección de la bomba: Si no hay flujo con la bomba en marcha, apágala tras unos segundos y señala la avería con un LED.
  • Control del filtro del acuario: Sigue el caudal, que baja a medida que el filtro se obstruye, y avisa cuando toque limpiarlo.
  • Dosificadora: Monta una estación de llenado automática que llene un recipiente con exactamente 2 litros de agua y cierre la válvula.

Errores frecuentes y cómo solucionarlos

SíntomaCausa probableSolución
El caudal siempre es 0Señal en un pin sin interrupción o sensor montado al revésUsa D2 o D3 en el Uno; compara el sentido del agua con la flecha del cuerpo
Se cuentan pulsos sin que fluya aguaRuido en un cable largo o pin al aireUsa INPUT_PULLUP, añade 100 nF entre señal y GND, aleja el cable de los de motores
Los litros medidos difieren un 10 % de la realidadSensor sin calibrarCalibra con una jarra medidora y actualiza DARBE_LITRE
La lectura salta con caudal bajoMuy pocos pulsos en la ventana de 1 segundoAlarga la ventana a 2–5 segundos o promedia
El ESP32 se reinicia al azar o el pin se dañóSeñal de 5 V conectada directamente a un pin de 3,3 VUsa un divisor de 10 kΩ + 20 kΩ o un conversor de nivel lógico
Los litros totales se borran al irse la luzEl contador solo está en la RAMGuarda el total cada cierto tiempo en la EEPROM o en Preferences
Ningún pulso con una bomba pequeñaCaudal inferior a 1 L/minUsa un sensor de bajo caudal como el YF-S401
Cuando montes una instalación nueva, haz primero unas cuantas medidas con el código de calibración y apunta los resultados. El mismo sensor puede medir unos puntos porcentuales distinto en horizontal o en vertical, o con otra presión; calibrar en el lugar donde quedará el sensor es lo más fiable.

El sensor de flujo de agua YF-S201 es una pieza perfecta para aprender a contar pulsos con interrupciones y, bien calibrado, da medidas fiables en muchos proyectos, desde un contador de agua doméstico hasta el riego automático. En la app BlueGrays encontrarás la estación de riego inteligente y proyectos de medida con LCD, con esquemas y código paso a paso, y podrás añadirles el sensor de flujo con facilidad.

Preguntas frecuentes

¿Cómo funciona un sensor de flujo de agua?

Una turbina dentro del sensor gira con el paso del agua y el imán que lleva pasa por delante de un sensor Hall en cada vuelta. El sensor Hall genera un pulso en cada paso, y cuanto más rápido fluye el agua, mayor es la frecuencia de los pulsos. Arduino cuenta esos pulsos para calcular el caudal y los litros totales.

¿Cuántos pulsos por litro da el YF-S201?

La fórmula del fabricante es F = 7,5 × Q, es decir, genera 7,5 Hz a 1 L/min. Eso equivale a unos 450 pulsos por litro. Un sensor real puede desviarse un 5–10 %, así que conviene calibrarlo con una jarra medidora para hallar tu propio factor.

¿Se puede conectar un sensor de flujo directamente a un ESP32?

Alimentado a 5 V, el YF-S201 da una señal de 5 V, demasiado para los pines de 3,3 V del ESP32. Debes añadir en la línea de señal un divisor de tensión de 10 kΩ y 20 kΩ o un conversor de nivel lógico. La alimentación del sensor puede tomarse del pin VIN del ESP32.

¿Por qué el sensor de flujo se conecta a un pin de interrupción?

Con caudal alto el sensor genera más de 200 pulsos por segundo, y un programa que consulta el pin en loop() pierde pulsos durante las pausas o las actualizaciones de pantalla. La interrupción ejecuta una pequeña función al instante en cada pulso, así que no se pierde ninguno. En el Arduino Uno los pines de interrupción son D2 y D3.

¿Un sensor de flujo detecta fugas de agua?

Las fugas grandes, como un grifo o una manguera abiertos mucho tiempo, se detectan fácilmente vigilando el tiempo de flujo continuo y los litros gastados. En cambio, fugas muy pequeñas como un grifo que gotea quedan por debajo del límite inferior de 1 L/min del YF-S201 y no se ven. Para ellas hace falta un detector de agua en el suelo o un contador más sensible.

¿En qué tubería se monta el YF-S201?

El YF-S201 tiene rosca macho G1/2, es decir, de media pulgada, en ambos extremos y encaja directamente en la mayoría de tomas de grifos y duchas de una vivienda. Para mangueras más finas existe el YF-S401 y para tuberías de tres cuartos el FS300A. Basta con poner cinta de teflón en las roscas y apretar el sensor a mano.

Ver todos los proyectos
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

HC-SR04 Medición de distancia (pantalla en serie)

El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

4.6(50)
82
Estación de riego inteligente
AR-83Avanzado
Premium

Estación de riego inteligente

Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.

5.0(42)
57
Voltímetro digital con pantalla LCD
AR-56Intermedio
Premium

Voltímetro digital con pantalla LCD

Descubre cuánto voltaje da una pila o un adaptador con un medidor hecho por ti. Un divisor de dos resistencias baja la tensión alta a un nivel que la placa puede leer, y el Arduino calcula el valor…

4.5(27)
36
Pantalla LCD I2C para ESP32 (16x2)
ES-17Intermedio
Premium

Pantalla LCD I2C para ESP32 (16x2)

En este proyecto conectamos una pantalla LCD de caracteres 16x2 al ESP32 por I2C para mostrar texto. Con I2C bastan 2 pines de datos (SDA y SCL), en lugar de los 6+ pines de una conexión paralela clásica. El código escribe un mensaje fijo en la primera línea y un contador que sube cada segundo en la segunda. Al arrancar, un escáner I2C muestra la dirección de la pantalla en el Serial Monitor (normalmente 0x27 o 0x3F).

4.9(23)
40
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)

En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

4.8(16)
26
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)

En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

4.4(21)
38