Sistema IoT de Detección Temprana de Fugas de Agua con ESP32 y Notificaciones Push

💧 Introducción al Monitoreo de Fugas de Agua con IoT

Las fugas de agua pueden causar daños considerables en el hogar o la oficina, desde problemas estructurales hasta riesgos eléctricos y crecimiento de moho. Detectarlas a tiempo es crucial para minimizar los costos de reparación y proteger tus bienes. La tecnología del Internet de las Cosas (IoT) nos ofrece una solución ideal para este problema, permitiéndonos monitorear áreas críticas y recibir alertas inmediatas.

En este tutorial, construiremos un sistema de detección temprana de fugas de agua utilizando un ESP32, un microcontrolador potente y versátil con conectividad Wi-Fi y Bluetooth. Nuestro sistema detectará la presencia de agua y te notificará instantáneamente a través de una aplicación móvil, incluso cuando no estés en casa.

¿Por qué un Sistema IoT para Fugas de Agua? 🤔

Los sistemas tradicionales suelen ser reactivos. Con IoT, pasamos a ser proactivos:

• Prevención de daños mayores: Una alerta temprana puede significar la diferencia entre una pequeña mancha y una inundación.
• Tranquilidad: Monitorea tu hogar 24/7, sin importar dónde estés.
• Ahorro económico: Evita reparaciones costosas de techos, pisos, paredes y electrodomésticos.
• Fácil implementación: Con el ESP32, crear un sistema robusto es más sencillo de lo que parece.

🛠️ Materiales Necesarios

Para este proyecto, necesitarás los siguientes componentes. La mayoría son fáciles de conseguir en tiendas de electrónica en línea o locales.

⚙️ Conexión del Hardware: ¡Manos a la Obra!

La conexión del sensor de agua al ESP32 es relativamente sencilla. Utilizaremos un sensor de tipo digital, que nos proporcionará una señal ALTA o BAJA dependiendo de si detecta agua o no.

Diagrama de Conexión 🔌

Aquí tienes un esquema básico de cómo conectar el sensor de agua al ESP32. Si utilizas múltiples sensores, cada uno se conectará a un pin GPIO digital diferente del ESP32.

Conexiones Detalladas:

1. VCC del Sensor de Agua (positivo) ➡️ 3V3 del ESP32
2. GND del Sensor de Agua (tierra) ➡️ GND del ESP32
3. DO del Sensor de Agua (Salida Digital) ➡️ GPIO 13 del ESP32 (o cualquier otro pin digital disponible)

Verificación Inicial del Sensor (Opcional) ✨

Antes de programar la lógica completa, puedes hacer una prueba rápida para asegurarte de que el sensor funciona correctamente:

1. Conecta solo el sensor al ESP32 como se describe.
2. Sube un programa simple a tu ESP32 que lea el pin GPIO 13 y muestre su estado en el monitor serial.
3. Toca el sensor con un paño húmedo o sumérgelo ligeramente en agua. Deberías ver el estado del pin cambiar en el monitor serial (por ejemplo, de HIGH a LOW o viceversa, dependiendo de tu sensor).

void setup() {
  Serial.begin(115200);
  pinMode(13, INPUT_PULLUP); // Usamos PULLUP si el sensor es de salida LOW al detectar agua
}

void loop() {
  int sensorState = digitalRead(13);
  Serial.print("Estado del sensor: ");
  Serial.println(sensorState);
  delay(500);
}

💻 Configuración del Entorno de Desarrollo (Arduino IDE)

Para programar el ESP32, utilizaremos el entorno de desarrollo de Arduino (Arduino IDE), que es ampliamente conocido y cuenta con una gran comunidad.

1. Instalar Arduino IDE

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

2. Añadir Soporte para ESP32

El Arduino IDE no incluye soporte para el ESP32 por defecto. Debes añadirlo:

1. Abre el Arduino IDE.
2. Ve a Archivo > Preferencias.
3. En el campo URLs Adicionales de Gestores de Tarjetas, pega la siguiente URL: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
4. Haz clic en OK.
5. Ve a Herramientas > Placa > Gestor de Tarjetas....
6. Busca esp32 e instala el paquete esp32 by Espressif Systems.

3. Seleccionar Placa y Puerto

Una vez instalado el soporte, selecciona tu placa ESP32 y el puerto COM correcto:

1. Conecta tu ESP32 al ordenador mediante el cable USB.
2. Ve a Herramientas > Placa.
3. Busca y selecciona tu modelo de placa ESP32 (por ejemplo, ESP32 Dev Module).
4. Ve a Herramientas > Puerto y selecciona el puerto COM al que está conectado tu ESP32.

📡 Configuración de Notificaciones Push con IFTTT

Para recibir notificaciones en tu móvil, utilizaremos IFTTT (If This Then That), una plataforma que permite automatizar tareas creando "applets" (pequeñas reglas).

1. Crear una Cuenta IFTTT

Si no tienes una, regístrate en ifttt.com y descarga la aplicación IFTTT en tu smartphone (disponible para iOS y Android).

2. Crear un Applet ➕

Necesitamos un applet que, al recibir una petición web (webhook) del ESP32, envíe una notificación a tu teléfono:

1. En IFTTT, ve a Create (o Explorar > Hacer uno propio).
2. Haz clic en If This (+).
3. Busca y selecciona el servicio Webhooks.
4. Elige el Trigger (disparador) Receive a web request.
5. Asigna un Event Name (nombre del evento). Por ejemplo, fuga_agua. Recuerda este nombre, lo usarás en el código del ESP32.
6. Haz clic en Create trigger.
7. Haz clic en Then That (+).
8. Busca y selecciona el servicio Notifications.
9. Elige la acción Send a notification from the IFTTT app.
10. Puedes personalizar el mensaje de la notificación. Por ejemplo: ¡Fuga de agua detectada en {{EventName}}! o ¡Alerta! Fuga detectada en tu [ubicación]. Los {{}} son ingredientes que puedes usar, pero para nuestro caso simple, un mensaje fijo es suficiente. ¡ALERTA! Posible fuga de agua detectada!
11. Haz clic en Create action.
12. Revisa tu applet y haz clic en Finish.

3. Obtener tu Clave Webhooks 🔑

Para que el ESP32 pueda enviar la petición a IFTTT, necesitas tu clave personal de Webhooks:

1. En IFTTT, ve a Explorar > busca Webhooks.
2. Haz clic en Documentation (documentación) en la página del servicio Webhooks.
3. Verás una URL base de la forma https://maker.ifttt.com/trigger/{event}/with/key/{tu_clave}.
4. Tu clave ({tu_clave}) es una cadena alfanumérica larga. Cópiala y guárdala en un lugar seguro. ¡No la compartas!

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

Ahora, escribiremos el código para el ESP32. Este código conectará el ESP32 a tu red Wi-Fi, leerá el estado del sensor de agua y, si detecta una fuga, enviará una petición a IFTTT para activar la notificación.

#include <WiFi.h>
#include <HTTPClient.h>

// Configuración de la red Wi-Fi
const char* ssid = "TU_NOMBRE_DE_WIFI";       // Reemplaza con el nombre de tu red Wi-Fi
const char* password = "TU_CONTRASEÑA_DE_WIFI"; // Reemplaza con la contraseña de tu red Wi-Fi

// Configuración del sensor de agua
const int SENSOR_PIN = 13; // Pin GPIO al que está conectado el sensor de agua (DO)
const int DEBOUNCE_DELAY = 2000; // Tiempo en ms para evitar lecturas falsas (2 segundos)

// Configuración de IFTTT Webhooks
const char* IFTTT_EVENT_NAME = "fuga_agua"; // Nombre del evento que creaste en IFTTT
const char* IFTTT_API_KEY = "TU_CLAVE_IFTTT"; // Tu clave Webhooks de IFTTT

// Variables de estado
bool waterDetected = false;
unsigned long lastDetectionTime = 0;

void setup() {
  Serial.begin(115200);
  pinMode(SENSOR_PIN, INPUT_PULLUP); // Configura el pin del sensor como entrada con pull-up

  // Conexión a Wi-Fi
  Serial.print("Conectando a ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi conectado");
  Serial.print("Dirección IP: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  int sensorState = digitalRead(SENSOR_PIN);

  // Asumiendo que el sensor envía LOW cuando detecta agua (común con pull-up)
  if (sensorState == LOW) {
    if (!waterDetected && (millis() - lastDetectionTime > DEBOUNCE_DELAY)) {
      // Si el agua es detectada por primera vez o después de un tiempo de debounce
      waterDetected = true;
      lastDetectionTime = millis();
      Serial.println("!!! AGUA DETECTADA !!!");
      sendIFTTTNotification();
    }
  } else {
    // Si no hay agua, reseteamos el estado de detección
    waterDetected = false;
  }

  delay(100); // Pequeño delay para no saturar el bucle
}

void sendIFTTTNotification() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    String url = "https://maker.ifttt.com/trigger/" + String(IFTTT_EVENT_NAME) + "/with/key/" + String(IFTTT_API_KEY);

    http.begin(url);
    
    Serial.println("Enviando notificación IFTTT...");
    int httpCode = http.GET(); // O POST, si IFTTT requiere datos en el cuerpo

    if (httpCode > 0) {
      Serial.printf("[HTTP] GET... code: %d\n", httpCode);
      if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
        String payload = http.getString();
        Serial.println(payload);
      }
    } else {
      Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
    }
    http.end();
  } else {
    Serial.println("WiFi no conectado, no se puede enviar notificación.");
  }
}

Explicación del Código 📖

• Bibliotecas: Incluye WiFi.h para la conectividad Wi-Fi y HTTPClient.h para hacer peticiones HTTP a IFTTT.
• Credenciales: Define tu ssid (nombre de la red Wi-Fi), password (contraseña) y la IFTTT_API_KEY (tu clave Webhooks de IFTTT).
• SENSOR_PIN: El pin GPIO del ESP32 conectado al sensor de agua. GPIO 13 es un buen comienzo.
• DEBOUNCE_DELAY: Este retardo es crucial. Evita que el sensor envíe múltiples alertas si el agua se rocía y se retira rápidamente, o si hay un contacto intermitente. Solo se enviará una notificación si ha pasado este tiempo desde la última detección.
• setup(): Inicializa la comunicación serial, configura el pin del sensor y establece la conexión Wi-Fi.
• loop(): Lee continuamente el estado del SENSOR_PIN. Si detecta agua (LOW en nuestro ejemplo, pero podría ser HIGH según tu sensor) y no es una detección reciente (gracias al DEBOUNCE_DELAY), actualiza el estado waterDetected a true y llama a la función sendIFTTTNotification().
• sendIFTTTNotification(): Construye la URL de IFTTT con tu nombre de evento y clave, y realiza una petición HTTP GET. Si la petición es exitosa, IFTTT activará el applet y enviará la notificación push a tu móvil.

✅ Puesta en Marcha y Pruebas

Una vez que hayas cargado el código en tu ESP32, es hora de probar el sistema.

1. Subir el Código

1. Asegúrate de haber configurado el entorno de Arduino IDE correctamente (soporte ESP32, placa y puerto seleccionados).
2. Conecta tu ESP32 al ordenador.
3. Abre el código que acabamos de escribir en Arduino IDE.
4. Asegúrate de reemplazar los placeholders:
   • "TU_NOMBRE_DE_WIFI"
   • "TU_CONTRASEÑA_DE_WIFI"
   • "TU_CLAVE_IFTTT"
5. Haz clic en el botón Subir (la flecha hacia la derecha) en Arduino IDE. Es posible que tengas que mantener presionado el botón BOOT en tu ESP32 mientras se sube el código, dependiendo del modelo.
6. Abre el Monitor Serial (icono de lupa en la esquina superior derecha) para ver los mensajes de depuración y verificar la conexión Wi-Fi.

2. Realizar la Prueba de Fuga

1. Coloca el sensor de agua en una superficie que no sea conductora (para evitar falsas lecturas) y cerca del ESP32.
2. Con el sistema encendido y conectado a tu Wi-Fi, toma una pequeña cantidad de agua (una gota o un algodón húmedo).
3. Aplica el agua sobre las pistas conductoras del sensor.
4. Observa el Monitor Serial: Deberías ver un mensaje como !!! AGUA DETECTADA !!! y luego Enviando notificación IFTTT....
5. Revisa tu Teléfono: En pocos segundos, deberías recibir una notificación push de IFTTT en tu smartphone con el mensaje configurado.

3. Consideraciones para la Implementación Final

• Ubicación: Coloca los sensores en los puntos más bajos de las áreas de riesgo (suelo, bandejas de electrodomésticos, etc.).
• Alimentación: Para un uso continuo, necesitarás alimentar el ESP32 con una fuente de alimentación de 5V (como un cargador de móvil) en lugar de depender del USB del ordenador.
• Carcasa: Considera imprimir una carcasa 3D o usar una caja estanca para proteger el ESP32 y los cables de la humedad y el polvo.
• Múltiples Sensores: Puedes expandir el sistema conectando varios sensores a diferentes pines GPIO del ESP32 y modificando el código para monitorear cada uno y especificar qué sensor activó la alerta. Podrías pasar el SENSOR_PIN o un nombre de ubicación como un value1 a IFTTT para tener notificaciones más detalladas.

http.begin(url);
Serial.printf("Enviando notificación IFTTT para %s...\n", location.c_str());
int httpCode = http.GET();
// ... (manejo de respuesta HTTP)
http.end();

</details>

<div class="progress-bar"><div class="progress-fill" style="width: 90%; background: #28a745;">90% Completado</div></div>

---

## 🚀 Ideas para Mejorar tu Sistema

Este es solo el comienzo. Aquí tienes algunas ideas para llevar tu sistema al siguiente nivel:

*   **Indicador Visual/Audible:** Añade un LED o un pequeño zumbador (buzzer) al ESP32 para una alerta local instantánea.
*   **Registros de Eventos:** Envía los eventos a una plataforma IoT como Thingspeak o Blynk para graficar el historial de detecciones.
*   **Batería de Respaldo:** Integra una batería recargable (con un módulo de carga como el TP4056) para que el sistema siga funcionando durante cortes de energía.
*   **Modo de Bajo Consumo:** Para soluciones alimentadas por batería, investiga el modo `deep sleep` del ESP32 para reducir significativamente el consumo de energía y prolongar la vida de la batería.
*   **Más Sensores:** Conecta otros tipos de sensores, como un DHT11/DHT22 para monitorear temperatura y humedad ambiental, lo cual puede ser útil en sótanos o áreas propensas a la condensación.
*   **Válvula de Cierre Automático:** Para usuarios avanzados, se podría integrar una electroválvula para cortar automáticamente el suministro de agua principal cuando se detecta una fuga (requeriría un relé y una instalación profesional).

<div class="timeline">
  <div class="timeline-item"><strong>Paso 1:</strong> Agregar LED de alerta (GPIO 2, por ejemplo)</div>
  <div class="timeline-item"><strong>Paso 2:</strong> Implementar modo Deep Sleep para ahorro de energía</div>
  <div class="timeline-item"><strong>Paso 3:</strong> Integrar módulo de batería LiPo</div>
  <div class="timeline-item"><strong>Paso 4:</strong> Conectar a plataforma de visualización de datos (Blynk/Thingspeak)</div>
</div>

<span class="badge blue">Intermedio</span> <span class="badge yellow">Importante</span>

--- 

## Conclusión ✨

Has construido un sistema de detección de fugas de agua basado en IoT, una herramienta poderosa y proactiva para proteger tu propiedad. Este proyecto no solo te brinda tranquilidad, sino que también es una excelente introducción al vasto mundo del Internet de las Cosas y la automatización del hogar con ESP32. ¡Experimenta, mejora y adapta este sistema a tus necesidades específicas!