▷ Sensor de Flujo YF-S201: Medición de Caudal con Arduino

¡Saludos controlera o controlero! En esta ocasión, nos sumergiremos en el fascinante mundo de los sensores de flujo de agua. Aprenderás a trabajar con el sensor de flujo YF-S201, conocido también como sensor de caudal o caudalímetro. Integraremos este dispositivo con nuestro querido Arduino, y exploraremos su funcionamiento y aplicaciones. Y como siempre, acompaña este post con nuestro video tutorial en YouTube.

Antes de comenzar, te invito a que eches un vistazo a todas las entradas de nuestro CURSO GRATUITO ARDUINO DESDE CERO.

¡Y no olvides suscribirte a nuestro canal de YouTube! Si eres un apasionado de la programación de sistemas embebidos, ¡este es tu lugar!

Contenidos mostrar

¿Por qué y dónde se utiliza un sensor de flujo de agua?

El YF-S201 es un caudalímetro diseñado para medir el flujo y volumen de líquidos. Su diseño compacto, con un cuerpo de cobre y un rotor de agua, lo hace ideal para múltiples aplicaciones, desde proyectos DIY hasta usos industriales.

Pero, ¿dónde se utiliza un sensor de flujo de agua como el YF-S201? Si has visitado industrias de automatización, especialmente en sectores como el de bebidas, habrás observado la necesidad de monitorear con precisión la cantidad de líquido que se distribuye. Imagina una línea de producción de refrescos: es esencial asegurar que cada botella se llene con la cantidad exacta de bebida. También encontramos estos sensores en máquinas de café, sistemas de riego inteligente, dispensadores automáticos de agua, entre otros.

Pinout del Sensor de Caudal YF-S201

El siguiente diagrama muestra el pinout del sensor de flujo de agua YF-S201. Está compuesto por tres pines:

A continuación, discutimos el pinout del sensor de flujo de agua YF-S201. Los detalles de la configuración de los cables en forma tabular se mencionan a continuación:

Pin Number	Pin Name	Function
1	RED	Cable de suministro positivo
2	BLACK	Cable de tierra (Ground)
3	YELLOW	Cable de salida de voltaje (Output Voltage)

Funcionamiento del YF-S201

Este innovador sensor de flujo de agua integra dos componentes clave para su funcionamiento: un rotor (o rueda de turbina) y un sensor de efecto Hall.

Componentes internos del YF-S201

El YF-S201 alberga en su interior una pequeña turbina. Cuando el agua entra y fluye a través del sensor, impacta esta rueda de turbina, causando que gire. La velocidad de esta rueda de turbina está directamente relacionada con la velocidad del flujo de agua que pasa a través del sensor.

Creditos: microcontrollerslab

Operación basada en el Efecto Hall

El sensor YF-S201 opera a partir del Efecto Hall. Este efecto se basa en la generación de un voltaje cuando un conductor eléctrico atraviesa un campo magnético. En el caso de nuestro sensor, la turbina tiene un pequeño imán incorporado que, al girar, altera este campo magnético.

El sensor de efecto Hall detecta estas alteraciones y, a cada revolución completa de la turbina, genera un pulso en su pin de salida. Dicho de otro modo, el número de pulsos que aparecen en el pin de salida es proporcional directamente a la velocidad de rotación de la turbina, y, por lo tanto, al flujo de agua.

Creditos: Seeedstudio

Características del YF-S201

Voltaje Operacional: 4.5 – 24 Volts
Voltaje Normal: 5 – 18 Volts
Corriente Máxima: 15 mA @ 5V
Capacidad de Carga: ≤10 mA @ 5V
Tasa de Flujo: 1 -30 L/min
Temperatura Operacional: ≤ 80°C
Temperatura operativa del fluido: ≤ 1200C
Rango de humedad: 35% – 90% HR
Resistencia de aislamiento: ≥ 100 Mohmios
Sensor de flujo de agua que interactúa con Arduino

Comprar YF-S201

Bestseller No. 1

ELEGOO UNO Project Super Starter Kit with Tutorial…

Bestseller No. 2

Arduino UNO R4 WiFi [ABX00087] – Renesas RA4M1 /…

RebajasBestseller No. 3

Arduino Uno REV3 [A000066]

¿Quieres Profundizar Tus Conocimientos? 🚀

Si este post te está despertado curiosidad sobre el funcionamiento y aplicación de sensores como el YF-S201, ¡tienes que conocer nuestro curso premium «Fundamentos en Instrumentación Industrial»!

No solo abordaremos en profundidad los sensores de flujo, sino que también desvelaremos cómo estos y otros instrumentos son esenciales en la industria moderna.

🔍 En el curso, explorarás:

El funcionamiento interno de los sensores más utilizados.
Cómo se integran en sistemas industriales complejos.
Las mejores prácticas y estándares en instrumentación.

Si te apasiona la instrumentación y buscas dominar las herramientas y técnicas que impulsan la industria, este es tu curso ideal.

Accede al Curso de Instrumentación Industrial

Interfaz del YF-S201 con Arduino

Medir el caudal con el YF-S201 y Arduino es un proceso intuitivo. Se basa en contar los pulsos que el sensor genera a medida que el líquido fluye a través de él. Estos pulsos pueden ser contabilizados utilizando los pines de interrupción de Arduino, permitiendo determinar la tasa de flujo en tiempo real.

Conversión de Pulsos

Cuando trabajamos con sensores de flujo de agua como el YF-S201, una parte esencial es convertir los pulsos generados por el sensor en una medición de flujo de agua. Esta sección te guiará paso a paso a través de este proceso.

Paso 1: La Relación entre Pulsos y Volumen

Cada pulso generado por el sensor YF-S201 es equivalente a 2.25 ml de agua. Si conoces la cantidad de pulsos en un período de tiempo, puedes calcular el volumen de agua.

Paso 2: Convertir Pulsos en Frecuencia (L/min)

Para calcular el flujo de agua en litros por minuto (L/min), puedes utilizar la fórmula dada en la hoja de datos del sensor:

\text{frecuencia (hz)} = 7.5 \times Q(L/min)

Esto significa que puedes calcular el flujo en litros por minuto usando un conteo de pulsos. Por ejemplo, si tu conteo de pulsos se encuentra en la variable pulseCount y tu flujo en la variable flowRate sería:

\text{flowRate} = \dfrac{\text{pulseCount}}{7.5}\ [\rm L/min]

Paso 3: Convertir a Litros por Hora (L/h)

Si prefieres tener la medición en litros por hora, simplemente multiplica el resultado por 60:

\text{flowRate} = \dfrac{\text{pulseCount}\times 60}{7.5}\ [\rm L/h]

En tu código de Arduino, esto se verá así:

flowRate1 = (pulseCount1 * 60.0) / 7.5;

¿Por Qué 7.5?

Te estarás preguntando de dónde viene el número 7.5 en estas ecuaciones. Este valor proviene directamente de las características del sensor y es la relación entre la frecuencia de pulsos y el flujo de agua en L/min. Es un valor específico para el sensor YF-S201 y es esencial para la conversión precisa.

Ejemplo práctico: Control de una bomba de corriente CC con Arduino y medición de caudal

Objetivo: Modular una bomba de corriente continua (CC) para transportar agua desde un reservorio hasta un tanque con geometría esférica, midiendo la tasa de caudal con el sensor YF-S201 y mostrando el resultado a través del puerto serial.

Componentes necesarios:

Arduino Mega (aunque se puede utilizar cualquier otro modelo de Arduino)
Sensor de flujo de agua YF-S201
Bomba de agua de corriente continua (CC)
Driver de potencia BTS7960 (también se mostrará el uso del driver L298)
Tanque con geometría esférica
Tubo para transportar el agua

Descripción:

Configuración Inicial:
- Conectaremos la bomba de agua CC al driver de potencia BTS7960. El BTS7960 permitirá modular la bomba mediante PWM (Modulación por Ancho de Pulso) controlado por el Arduino.
- También explicaremos cómo realizar esta conexión con el driver L298, cuyo código de modulación es muy similar.
Medición del Caudal:
- Colocaremos el sensor YF-S201 en la tubería de ingreso al tanque esférico.
- Conectaremos el sensor al Arduino según las instrucciones previamente mencionadas.

Circuito:

Código:

Puedes bajar el código desde mi repositorio en GitHub o copiarlo de aqui:

//***************************************************//
//***************************************************//
//*****   Sensor de Flujo YF-S201               *****//
//*****                                         *****//
//***** by: Sergio Andres Castaño Giraldo       *****//
//***** https://controlautomaticoeducacion.com/ *****//
//*****                                         *****//
//***************************************************//
//***************************************************//

// BTS7960 - 1 (Bomba 1)
byte RPWM1 = 4;
byte LPWM1 = 6;

// l298 - 1 (Bomba 3)
byte IN3_L1 = 24;
byte IN4_L1 = 25;
byte BEN_L1 = 5;

// Sensor YF-S201 
byte flowSensor1Pin = 2;
volatile unsigned long pulseCount1 = 0;
float flowRate1 = 0.0;

unsigned long oldTime = 0;

//Estructura da Bomba L298
typedef struct{
  byte enPin1;
  byte enPin2;
  byte pwmPin;
}BombaL;

//Estructura da Bomba BTS7960
typedef struct{
  byte pwmA;
  byte pwmB;
}BombaBTS;


//Crear las bombas con las estructuras
const BombaBTS bomba1 = {RPWM1, LPWM1};
const BombaL   bomba3 = {IN3_L1, IN4_L1, BEN_L1};


float inputValue  = 0;
int   velocity = 0;

String inputString = "";         // Una cadena para mantener los datos recibidos
boolean stringComplete = false;  // Ya se recibió toda la cadena?


void setup() {
  Serial.begin(9600); //Comunicación Serial
  inputString.reserve(200); // Reserva espacio para la cadena
  pinMode(flowSensor1Pin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(flowSensor1Pin), flowSensor1Interrupt, RISING);
}

void loop() {
  //Transforma el valor de porcentaje a velocidad
  velocity = map(inputValue,0,100,0,255);

  // Ativar bomba1 (BombaBTS)
  digitalWrite(bomba1.pwmA, LOW);
  analogWrite(bomba1.pwmB, velocity);
  
  /*
  // Ativar bomba3 (BombaL) 
  digitalWrite(bomba3.enPin1, HIGH);
  digitalWrite(bomba3.enPin2, LOW);
  analogWrite(bomba3.pwmPin, velocity);
  */  

  //Calcular flujo cada 1segundo
  if ((millis() - oldTime) > 1000) { 
    detachInterrupt(digitalPinToInterrupt(flowSensor1Pin));

    flowRate1 = (pulseCount1 * 60.0) / 7.5; // L/h (YF-S201: 1 pulso = 2.25 mL)

    // Reiniciar conteo de pulsos y tiempo
    pulseCount1 = 0;
    oldTime = millis();

    attachInterrupt(digitalPinToInterrupt(flowSensor1Pin), flowSensor1Interrupt, RISING);

    // Mostrar la tasa de vazão
    Serial.print("Flujo en el tanque 1: ");
    Serial.print(flowRate1);
    Serial.println(" L/h \n\n");
  }
}

// Esta función se llama cada vez que el puerto serie recibe un byte:
void serialEvent() {
  while (Serial.available()) {
    char inChar = (char)Serial.read(); // Obtiene el nuevo byte
    inputString += inChar; // Añade el byte a la cadena
    if (inChar == '\n') { // Si es un byte de nueva línea, la entrada está completa
      inputValue = inputString.toInt(); // Convierte la cadena a int
      // Si inputValue está en el rango de 0 a 100
      if(inputValue > 100){inputValue = 100;}
      if(inputValue < 0){inputValue = 0;}
      inputString = ""; // Limpia la cadena
    }
  }
}



//Función de la interrupción
void flowSensor1Interrupt() {
  pulseCount1++;
}

Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:

👉 Invitar a Sergio a un Café ☕️

Que esten muy bien, nos vemos en la siguiente entrada.

Volver al Curso de Arduino

Sergio A. Castaño Giraldo

Mi nombre es Sergio Andres Castaño Giraldo, y en este sitio web voy a compartir una de las cosas que mas me gusta en la vida y es sobre la Ingeniería de Control y Automatización. El sitio web estará en constante crecimiento, voy a ir publicando material sobre el asunto desde temas básicos hasta temas un poco más complejos. Suscríbete al sitio web, dale me gusta a la página en Facebook y únete al canal de youtube. Espero de corazón que la información que comparto en este sitio, te pueda ser de utilidad. Y nuevamente te doy las gracias y la bienvenida a control automático educación.