¡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!
¿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.
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.
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
No products found.
¿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.
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.
Citar este Artículo
¡Hola! Soy Sergio Andrés Castaño Giraldo. Bienvenidos a Control Automático Educación, un espacio dedicado a una de mis grandes pasiones: la Ingeniería de Control y la Automatización.
Mi objetivo aquí es tender un puente entre la teoría académica y la práctica profesional. Como profesor e investigador, he tenido la oportunidad de trabajar en proyectos complejos —desde sistemas de compresión en plataformas offshore hasta modelos de control avanzado— y todo ese aprendizaje lo vuelco en este sitio.
Aquí encontrarás material que crece constantemente: desde fundamentos de instrumentación hasta estrategias de control avanzado y programación profesional. Mi meta es que la información que comparto te sea de utilidad real en tu carrera o formación.
Te invito a que te suscribas, te unas a nuestro canal de YouTube y formemos una comunidad de aprendizaje continuo. ¡Gracias por estar aquí!