Control Inteligente de Niveles en Depósitos de Agua con ESP32 y Blynk 💧

💧 Introducción al Monitoreo Inteligente de Depósitos de Agua

El monitoreo y control de los niveles de agua en depósitos es crucial en muchas aplicaciones, desde el hogar y la agricultura hasta la industria. Un sistema tradicional puede requerir revisiones manuales, lo que consume tiempo y recursos. Gracias al Internet de las Cosas (IoT), podemos automatizar esta tarea, obteniendo datos en tiempo real y gestionando nuestros depósitos de forma remota.

En este tutorial, construiremos un sistema robusto y fácil de usar que te permitirá conocer el nivel de agua de tu depósito desde cualquier lugar, recibir alertas cuando el nivel baje demasiado y, si lo deseas, incluso activar una bomba de llenado automáticamente. Usaremos el potente microcontrolador ESP32, conocido por su capacidad Wi-Fi y Bluetooth, junto con un sensor ultrasónico HC-SR04 para medir la distancia y, por ende, el nivel del agua. Todo esto se integrará con la popular plataforma Blynk, que nos proporcionará una interfaz de usuario intuitiva en nuestro smartphone.

🎯 Objetivos del Proyecto

Al finalizar este tutorial, serás capaz de:

• Entender el funcionamiento de un sensor ultrasónico HC-SR04.
• Conectar y programar un ESP32 para leer datos de sensores.
• Configurar la plataforma Blynk para crear un dashboard personalizado.
• Enviar datos del ESP32 a Blynk y visualizar el nivel de agua en tiempo real.
• Establecer notificaciones de alerta por bajo nivel de agua.
• (Opcional) Implementar un control básico de una bomba de llenado.

🛠️ Materiales Necesarios

Para llevar a cabo este proyecto, necesitarás los siguientes componentes:

⚙️ Preparación del Entorno de Desarrollo

Antes de empezar con el cableado y la programación, necesitamos configurar nuestro entorno de desarrollo.

1. Instalación del IDE de Arduino

Si aún no lo tienes, descarga e instala el IDE de Arduino desde la página oficial: arduino.cc/downloads.

2. Configuración del ESP32 en el IDE de Arduino

Para que el IDE de Arduino reconozca tu placa ESP32, sigue estos pasos:

a. Añadir la URL del gestor de tarjetas:

• Ve a Archivo > Preferencias.
• En el campo URLs Adicionales de Gestores de Tarjetas, añade la siguiente URL (si ya tienes otras, sepáralas con una coma):

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

b. Instalar el soporte para ESP32:

• Ve a Herramientas > Placa > Gestor de Tarjetas....
• Busca "esp32" e instala la versión más reciente del paquete esp32 by Espressif Systems. c. Seleccionar tu placa ESP32:
• Ve a Herramientas > Placa y selecciona el modelo específico de tu ESP32 (ej. ESP32 Dev Module).
• En Herramientas > Puerto, selecciona el puerto COM al que está conectado tu ESP32.

3. Instalación de la Librería Blynk

Blynk facilita enormemente la comunicación entre tu ESP32 y la aplicación móvil.

• Ve a Programa > Incluir Librería > Gestionar Librerías....
• Busca "Blynk" e instala la librería Blynk by Volodymyr Shymanskyy.
• También necesitarás la librería WiFiClientSecure si tu ESP32 no la incluye por defecto. Debería estar incluida con el paquete ESP32.

🔌 Diagrama de Conexión (Esquemático)

La conexión del sensor ultrasónico HC-SR04 al ESP32 es relativamente sencilla, pero requiere atención al detalle, especialmente con los voltajes.

📌 Conexiones Esenciales

Aquí tienes un esquema de cómo conectar los componentes:

• HC-SR04 VCC (5V) -> ESP32 VIN (o pin 5V si tu ESP32 lo tiene)
• HC-SR04 GND -> ESP32 GND
• HC-SR04 Trig -> ESP32 GPIO 23
• HC-SR04 Echo -> Divisor de voltaje -> ESP32 GPIO 22

Divisor de Voltaje para el pin Echo:

Para reducir los 5V del pin Echo a 3.3V seguros para el ESP32, usaremos dos resistencias en serie. Conectaremos:

1. El pin Echo del HC-SR04 a un extremo de la resistencia de 1kΩ.
2. El otro extremo de la resistencia de 1kΩ al extremo de la resistencia de 2kΩ.
3. El punto de unión entre las resistencias de 1kΩ y 2kΩ (donde se dividen los voltajes) lo conectamos al ESP32 GPIO 22.
4. El otro extremo de la resistencia de 2kΩ lo conectamos a GND.

De esta manera, los 5V del Echo se reducirán a aproximadamente 3.33V en el pin GPIO 22 (5V * (2kΩ / (1kΩ + 2kΩ)) = 3.33V).

💡 Conexiones Opcionales (Control de Bomba)

Si deseas añadir el control de una bomba, la conexión será a través de un módulo relé:

• Módulo Relé VCC -> ESP32 VIN (o 5V)
• Módulo Relé GND -> ESP32 GND
• Módulo Relé IN -> ESP32 GPIO 16 (o cualquier otro pin GPIO disponible)
• Bomba de Agua -> Conectar la bomba a los terminales NC (Normalmente Cerrado) o NO (Normalmente Abierto) del relé, dependiendo de cómo quieras que funcione (encendida por defecto o apagada por defecto), y el terminal COM del relé a la fuente de alimentación de la bomba.

📱 Configuración de la Aplicación Blynk

Blynk nos proporcionará la interfaz para interactuar con nuestro sistema IoT. Sigue estos pasos para configurarlo:

1. Descarga e Instala la Aplicación Blynk

Descarga la aplicación "Blynk IoT" (la versión nueva, no la clásica) desde Google Play Store o Apple App Store.

2. Crea una Cuenta y un Nuevo Proyecto

• Abre la aplicación y crea una nueva cuenta o inicia sesión.
• Una vez dentro, crea un Nuevo Dispositivo.
• En la configuración del dispositivo, selecciona ESP32 como tipo de hardware.
• Dale un nombre a tu dispositivo (ej. "Monitor Depósito Agua").
• Selecciona el tipo de conexión WiFi.
• Blynk te enviará un Auth Token a tu correo electrónico. Este token es crucial para que tu ESP32 se conecte a tu proyecto. Guárdalo bien.

3. Diseña la Interfaz de Usuario (Dashboard)

Ahora, vamos a añadir widgets a tu dashboard para visualizar y controlar el sistema:

a. Medidor de Nivel de Agua:

• Pulsa en + para añadir un nuevo widget.
• Selecciona Gauge (Medidor).
• Configúralo: * Pin: Selecciona Virtual Pin V0 (este será el pin donde el ESP32 enviará los datos de nivel). * Etiqueta: "Nivel de Agua" * Unidad: "%" (o "cm", lo que prefieras). * Rango: 0 - 100 (o el rango de centímetros de tu depósito). b. Alerta de Nivel Bajo:
• Añade un widget LED.
• Pin: Virtual Pin V1.
• Color: Rojo (cuando esté activo).
• Etiqueta: "Nivel Bajo" c. Notificaciones Push:
• Añade un widget Notification.
• No necesita configuración de pin, ya que el ESP32 lo activará directamente. d. (Opcional) Botón de Control de Bomba:
• Añade un widget Button.
• Pin: Virtual Pin V2.
• Modo: Push (momentáneo) o Switch (permanente).
• Etiqueta: "Control Bomba"

💻 Programación del ESP32 (Código Arduino)

Aquí tienes el código base que cargaremos en nuestro ESP32. Asegúrate de reemplazar los placeholders con tus credenciales y valores específicos.

#define BLYNK_TEMPLATE_ID "Tu_Template_ID_de_Blynk" // Reemplaza con tu Template ID
#define BLYNK_DEVICE_NAME "Tu_Nombre_de_Dispositivo_de_Blynk" // Reemplaza con tu Device Name
#define BLYNK_AUTH_TOKEN "Tu_Auth_Token_de_Blynk" // Reemplaza con tu Auth Token

#include <WiFi.h>
#include <WiFiClient.h>
#include <BlynkSimpleEsp32.h>

// Credenciales de tu red Wi-Fi
char ssid[] = "Tu_SSID_WiFi"; // Reemplaza con el nombre de tu red Wi-Fi
char pass[] = "Tu_Contrasena_WiFi"; // Reemplaza con la contraseña de tu red Wi-Fi

// Pines para el sensor ultrasónico HC-SR04
const int trigPin = 23; // Pin para el Trigger del HC-SR04
const int echoPin = 22; // Pin para el Echo del HC-SR04 (conectado a través del divisor de voltaje)

// Pines para el control de la bomba (opcional)
const int bombaPin = 16; // Pin al que está conectado el módulo relé de la bomba

// Variables para la medición de distancia
long duration; // Duración del pulso ultrasónico
int distanceCm; // Distancia en centímetros

// Dimensiones del depósito (ajusta estos valores a tu depósito real)
const int alturaDepositoCm = 100; // Altura total del depósito en cm
const int offsetSensorCm = 5; // Distancia desde el sensor hasta el nivel máximo del agua cuando el depósito está lleno (o distancia del sensor a la parte superior del agua cuando el depósito está lleno)
const int nivelBajoAlertaCm = 20; // Nivel en cm por debajo del cual se activará la alerta

BlynkTimer timer; // Objeto para manejar los temporizadores en Blynk

// Función para leer la distancia del sensor ultrasónico
int readDistanceCm()
{
  // Limpiar el pin Trig enviando un pulso bajo
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  // Enviar un pulso alto de 10 microsegundos al pin Trig
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Leer la duración del pulso en el pin Echo
  duration = pulseIn(echoPin, HIGH);

  // Calcular la distancia en cm
  // Velocidad del sonido en el aire es aprox. 343 metros/segundo o 0.0343 cm/microsegundo
  // La distancia es (duración * velocidad del sonido) / 2 (ida y vuelta)
  distanceCm = duration * 0.0343 / 2;

  return distanceCm;
}

// Función para enviar los datos de nivel a Blynk
void sendSensorData()
{
  int currentDistance = readDistanceCm();

  // Calcular el nivel de agua real desde la base del depósito
  // nivelAgua = alturaDepositoCm - (distancia medida por el sensor - offsetSensorCm)
  // Si el sensor está en la parte superior del depósito y mide hacia abajo:
  // Nivel de agua = Altura total del depósito - Distancia_sensor
  // Ajuste si el sensor no está exactamente al borde superior

  int nivelAguaActualCm = alturaDepositoCm - (currentDistance - offsetSensorCm);

  // Asegurarse de que el nivel no sea negativo o mayor que la altura total
  if (nivelAguaActualCm < 0) nivelAguaActualCm = 0;
  if (nivelAguaActualCm > alturaDepositoCm) nivelAguaActualCm = alturaDepositoCm;

  // Calcular el porcentaje de llenado
  int porcentajeLlenado = (nivelAguaActualCm * 100) / alturaDepositoCm;

  Serial.print("Distancia medida: ");
  Serial.print(currentDistance);
  Serial.print(" cm. Nivel de agua: ");
  Serial.print(nivelAguaActualCm);
  Serial.print(" cm. Porcentaje: ");
  Serial.print(porcentajeLlenado);
  Serial.println(" %");

  // Enviar el porcentaje de llenado al Virtual Pin V0 en Blynk
  Blynk.virtualWrite(V0, porcentajeLlenado);

  // Verificar si el nivel está bajo y enviar alerta
  if (nivelAguaActualCm <= nivelBajoAlertaCm) {
    Blynk.virtualWrite(V1, 255); // Activa el LED de alerta en Blynk
    Blynk.logEvent("nivel_bajo_alerta", "¡Alerta! El nivel de agua es bajo: " + String(nivelAguaActualCm) + " cm.");
    // Para enviar notificaciones push directamente:
    // Blynk.notify("¡ALERTA! Nivel de agua bajo: " + String(nivelAguaActualCm) + " cm.");
  } else {
    Blynk.virtualWrite(V1, 0); // Apaga el LED de alerta en Blynk
  }
}

// Función para controlar la bomba desde Blynk (Virtual Pin V2)
BLYNK_WRITE(V2)
{
  int pinValue = param.asInt(); // Obtiene el valor del botón (0 o 1)
  if (pinValue == 1) {
    Serial.println("Bomba ON");
    digitalWrite(bombaPin, HIGH); // Activa la bomba (revisa si tu relé es HIGH o LOW para activar)
    Blynk.logEvent("bomba_activada", "Bomba de agua activada manualmente.");
  } else {
    Serial.println("Bomba OFF");
    digitalWrite(bombaPin, LOW); // Desactiva la bomba
    Blynk.logEvent("bomba_desactivada", "Bomba de agua desactivada manualmente.");
  }
}

void setup()
{
  Serial.begin(115200);

  // Inicializar pines del sensor ultrasónico
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  // Inicializar pin de la bomba (si se usa)
  pinMode(bombaPin, OUTPUT);
  digitalWrite(bombaPin, LOW); // Asegurarse de que la bomba esté apagada al inicio

  // Conectar a Blynk
  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);

  // Configurar temporizador para leer y enviar datos del sensor cada 5 segundos
  timer.setInterval(5000L, sendSensorData);
}

void loop()
{
  Blynk.run(); // Ejecuta las operaciones de Blynk
  timer.run(); // Ejecuta los temporizadores configurados
}

✅ Pasos para Subir y Probar el Código

Sigue estos pasos para poner tu sistema en marcha:

1. Reemplaza los placeholders: Abre el código en el IDE de Arduino y modifica BLYNK_TEMPLATE_ID, BLYNK_DEVICE_NAME, BLYNK_AUTH_TOKEN, ssid y pass con tus credenciales. Ajusta también alturaDepositoCm, offsetSensorCm y nivelBajoAlertaCm a las características de tu depósito.
2. Verifica el código: Haz clic en el botón Verificar (el icono de ✓) para compilar el código y comprobar si hay errores de sintaxis.
3. Conecta tu ESP32: Conecta tu ESP32 al ordenador mediante el cable USB.
4. Selecciona Placa y Puerto: En el IDE de Arduino, ve a Herramientas > Placa y asegúrate de que tu modelo de ESP32 esté seleccionado. Luego, en Herramientas > Puerto, elige el puerto COM correcto para tu ESP32.
5. Sube el código: Haz clic en el botón Subir (el icono de →) para transferir el código a tu ESP32. Durante la subida, es posible que tengas que presionar el botón BOOT (o FLASH) de tu ESP32 cuando el IDE muestre Connecting.... o Waiting for download.
6. Abre el Monitor Serie: Una vez subido el código, abre el Monitor Serie (icono de lupa en la esquina superior derecha del IDE) y configura la velocidad a 115200 baudios. Deberías ver los mensajes de conexión Wi-Fi y las lecturas del sensor.
7. Prueba en la aplicación Blynk: Abre la aplicación Blynk en tu móvil. Si todo está conectado correctamente, deberías ver las lecturas del medidor actualizándose en tiempo real. Prueba a acercar y alejar la mano del sensor para simular cambios de nivel y observa cómo reacciona el dashboard.

📈 Calibración y Ajustes del Sistema

La precisión de tu sistema dependerá en gran medida de una buena calibración. Aquí te damos algunos consejos:

1. Ajuste de offsetSensorCm

• Vacía el depósito: Lo ideal es que esté completamente vacío o con un nivel mínimo conocido.
• Mide la distancia: Coloca el sensor en su posición final y mide la distancia desde el sensor hasta el fondo del depósito con una cinta métrica. Esta será tu alturaDepositoCm (la distancia máxima que puede medir el sensor si el depósito está vacío hasta el fondo).
• Llena el depósito: Llena el depósito hasta su nivel máximo deseado.
• Mide la distancia actual: Con el depósito lleno, el sensor ultrasónico medirá una distancia menor (la distancia desde el sensor hasta la superficie del agua). La diferencia entre alturaDepositoCm y esta lectura será tu offsetSensorCm (la distancia que 'sobra' desde el sensor hasta el nivel máximo real del agua).
• Fórmula: nivelAguaActualCm = alturaDepositoCm - (distancia_leida_sensor - offsetSensorCm).

2. Estabilidad de la Lectura

• Superficie del Agua: Las ondas ultrasónicas pueden rebotar de manera irregular si la superficie del agua está agitada. Intenta que el sensor esté lo más estable posible y en una zona con poca agitación.
• Filtro de Datos: Para suavizar las lecturas, puedes implementar un promedio móvil de varias lecturas en tu código. Esto evitará saltos bruscos en el medidor.

3. Consideraciones Ambientales

• Temperatura y Humedad: La velocidad del sonido varía ligeramente con la temperatura y la humedad. Para aplicaciones de alta precisión, se pueden añadir sensores de temperatura y algoritmos de compensación, pero para la mayoría de los casos, la variación es mínima.
• Condensación: En ambientes húmedos, la condensación en el sensor puede afectar su rendimiento. Asegúrate de que el sensor esté protegido o de que sea un modelo resistente a la intemperie si se va a usar en exteriores.

🚀 Mejoras y Funcionalidades Adicionales

Este sistema es una base sólida, pero puedes ampliarlo con muchas otras funcionalidades:

1. Control Automático de Bomba

En lugar de un control manual, puedes modificar el código para que la bomba se active automáticamente cuando el nivel baje de un umbral (nivelBajoAlertaCm) y se desactive cuando alcance un nivel de llenado preestablecido.

// En la función sendSensorData()
// ...

  // Control automático de bomba (ejemplo básico)
  static bool bombaActivada = false;

  if (nivelAguaActualCm <= nivelBajoAlertaCm && !bombaActivada) {
    digitalWrite(bombaPin, HIGH); // Activa la bomba
    bombaActivada = true;
    Blynk.logEvent("bomba_auto_on", "¡Bomba activada automáticamente! Nivel bajo.");
    Blynk.notify("¡Bomba activada! Nivel bajo de " + String(nivelAguaActualCm) + " cm.");
  } else if (nivelAguaActualCm >= (alturaDepositoCm * 0.90) && bombaActivada) { // Llenar hasta el 90%
    digitalWrite(bombaPin, LOW); // Desactiva la bomba
    bombaActivada = false;
    Blynk.logEvent("bomba_auto_off", "Bomba desactivada automáticamente. Depósito lleno.");
    Blynk.notify("¡Bomba desactivada! Depósito lleno al " + String(porcentajeLlenado) + "%.");
  }

// ...

2. Múltiples Sensores

Si tienes varios depósitos, puedes replicar el sistema para cada uno o incluso usar un solo ESP32 con múltiples sensores ultrasónicos (asignando pines GPIO diferentes para cada sensor) y varios Virtual Pins en Blynk para cada depósito.

3. Historial de Datos y Gráficos

Blynk te permite añadir widgets de History Graph para visualizar la evolución del nivel de agua a lo largo del tiempo, lo cual es útil para analizar patrones de consumo o llenado.

4. Batería y Modo de Bajo Consumo

Para instalaciones remotas, puedes alimentar el ESP32 con una batería y configurar el microcontrolador para que entre en modo de deep sleep entre lecturas. Esto reducirá drásticamente el consumo de energía y prolongará la vida de la batería.

5. Interfaz Web Local

Además de Blynk, podrías crear una interfaz web simple directamente en el ESP32 para acceder a los datos de nivel desde cualquier navegador en tu red local, incluso sin conexión a la nube de Blynk (aunque perderías las notificaciones push y el acceso remoto a través de la app).

troubleshoot_and_faq ❓ Solución de Problemas y Preguntas Frecuentes

🏁 Conclusión

¡Felicidades! Has construido un sistema de monitoreo inteligente de niveles de agua utilizando un ESP32 y la plataforma Blynk. Este proyecto no solo te proporciona una solución práctica para la gestión de depósitos, sino que también te introduce en los conceptos fundamentales del Internet de las Cosas, el control de sensores y la interacción con plataformas en la nube. Con esta base, las posibilidades de expansión y mejora son prácticamente ilimitadas, permitiéndote adaptar este sistema a una gran variedad de necesidades.

Esperamos que este tutorial te haya sido útil y te inspire a seguir explorando el fascinante mundo de la electrónica y el IoT. ¡No dudes en experimentar y personalizar tu proyecto!