Sistema de Monitoreo Ambiental Acuático Inteligente con ESP32 y Sensores Sumergibles

💧 Introducción al Monitoreo Acuático Inteligente

El monitoreo constante de la calidad del agua es crucial para mantener la salud de los ecosistemas acuáticos, ya sean acuarios domésticos, estanques ornamentales o incluso pequeños cultivos acuapónicos. Los parámetros como el pH, la temperatura y la turbidez son indicadores vitales que, si se descuidan, pueden llevar a problemas graves para la vida acuática.

Tradicionalmente, este monitoreo se realiza de forma manual, lo que es tedioso, propenso a errores y no permite una reacción inmediata ante cambios bruscos. Aquí es donde el Internet de las Cosas (IoT) entra en juego. Al integrar sensores con microcontroladores como el ESP32 y plataformas en la nube, podemos automatizar la recolección de datos, visualizarlos en tiempo real y recibir alertas, transformando la gestión de nuestros entornos acuáticos.

Este tutorial te equipará con los conocimientos y habilidades para construir tu propio sistema de monitoreo ambiental acuático inteligente. Aprenderás sobre los componentes necesarios, cómo interconectarlos, programar el ESP32 y configurar una plataforma IoT para visualizar tus datos.

¿Por qué es importante el monitoreo de la calidad del agua?

La calidad del agua afecta directamente a la salud y el bienestar de los organismos que habitan en ella. Un pH inadecuado, temperaturas extremas o una turbidez elevada pueden causar estrés, enfermedades e incluso la muerte de peces y plantas. Un sistema de monitoreo automatizado permite:

• Detección Temprana: Identificar problemas antes de que se vuelvan críticos.
• Optimización: Ajustar condiciones para un crecimiento óptimo de especies.
• Ahorro de Tiempo: Reducir la necesidad de pruebas manuales frecuentes.
• Registro Histórico: Analizar tendencias y patrones para una mejor comprensión del ecosistema.

🛠️ Materiales Necesarios

Para construir este sistema, necesitarás los siguientes componentes. Hemos optado por una selección que ofrece un buen equilibrio entre funcionalidad y coste.

💡 Conceptos Fundamentales

Antes de sumergirnos en la conexión y programación, es útil entender brevemente cómo funcionan nuestros sensores clave.

Sensor de pH (Electrodo de Vidrio)

El sensor de pH consta de un electrodo de vidrio que genera una pequeña tensión eléctrica proporcional a la concentración de iones de hidrógeno en la solución. Esta tensión es muy pequeña y requiere un circuito amplificador (incluido en el módulo del sensor de pH) para convertirla en una señal que el ESP32 pueda leer a través de su convertidor analógico-digital (ADC).

• Rango de pH: El pH se mide en una escala de 0 a 14, donde 7 es neutro. Menos de 7 es ácido y más de 7 es alcalino (básico).
• Calibración: Los sensores de pH requieren calibración periódica con soluciones tampón (buffer) conocidas (ej. pH 4.0, pH 7.0, pH 10.0) para asegurar mediciones precisas.

Sensor de Temperatura DS18B20

Este sensor digital utiliza el protocolo One-Wire de Dallas Semiconductor. Solo necesita un pin de datos para comunicarse con el ESP32. Es ideal para entornos acuáticos por su encapsulado impermeable y su alta precisión.

• Precisión: Generalmente ±0.5°C en un rango de -10°C a +85°C.
• Cableado: Necesita una resistencia pull-up de 4.7kΩ entre el pin de datos y VCC, aunque muchos módulos ya la incluyen.

Sensor de Turbidez Analógico

El sensor de turbidez funciona emitiendo una luz infrarroja y midiendo la cantidad de luz que es dispersada o absorbida por las partículas en el agua. A mayor turbidez (más partículas), menos luz llega al receptor, resultando en una lectura de voltaje más baja (o más alta, dependiendo del sensor). Los módulos analógicos proporcionan un voltaje variable que se lee con un ADC.

• Unidades: La turbidez a menudo se mide en Unidades Nefelométricas de Turbidez (NTU), pero nuestros sensores de bajo costo suelen dar un valor analógico que necesitaremos correlacionar.
• Interferencia: Es sensible a la luz ambiental, por lo que es mejor usarlo en un entorno oscuro o sumergido completamente.

🔌 Conexión de los Componentes (Hardware)

Ahora vamos a ensamblar nuestro sistema. Sigue el diagrama y las instrucciones cuidadosamente.

Paso 1: Conectar el Sensor de Temperatura DS18B20

El DS18B20 tiene tres cables:

• Rojo/VCC: Conectar a 3.3V del ESP32.
• Negro/GND: Conectar a GND del ESP32.
• Amarillo/Verde/Datos (DQ): Conectar a un pin digital del ESP32, por ejemplo, GPIO 4. Añade una resistencia pull-up de 4.7kΩ entre el cable de datos y VCC si tu módulo no la trae integrada.

Paso 2: Conectar el Módulo Sensor de pH

El módulo de pH típicamente tiene 3 o 4 pines:

• VCC: Conectar a 5V del ESP32 (o una fuente externa de 5V si el ESP32 no puede suministrar suficiente corriente).
• GND: Conectar a GND del ESP32.
• Analog Output (AOUT): Conectar a un pin ADC del ESP32, por ejemplo, GPIO 34 (es un pin ADC de solo lectura).

Paso 3: Conectar el Módulo Convertidor ADC ADS1115 (para el Sensor de Turbidez)

Este módulo utiliza el protocolo I2C.

• VCC: Conectar a 3.3V del ESP32.
• GND: Conectar a GND del ESP32.
• SDA (Datos I2C): Conectar a GPIO 21 del ESP32.
• SCL (Reloj I2C): Conectar a GPIO 22 del ESP32.

Paso 4: Conectar el Sensor de Turbidez al ADS1115

El sensor de turbidez tiene 3 pines (VCC, GND, Salida Analógica).

• VCC: Conectar a 5V (si tu sensor requiere 5V) o 3.3V (si tu sensor es de 3.3V) desde el ESP32 o una fuente externa. ¡Verifica el voltaje de tu sensor!
• GND: Conectar a GND.
• Salida Analógica (AOUT): Conectar a una de las entradas analógicas del ADS1115, por ejemplo, A0.

Resumen de Conexiones (ESP32)

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

Necesitarás el Arduino IDE con el soporte para ESP32 instalado, además de algunas librerías esenciales.

Paso 1: Instalar Soporte para ESP32 en Arduino IDE

Si aún no lo tienes, sigue estos pasos:

1. Abre Archivo > Preferencias.
2. En "URLs Adicionales para el Gestor de Tarjetas", añade: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
3. Ve a Herramientas > Placa > Gestor de Tarjetas...
4. Busca "esp32" e instala la última versión.
5. Selecciona tu placa ESP32 en Herramientas > Placa > ESP32 Arduino > ESP32 Dev Module.

Paso 2: Instalar Librerías Necesarias

Ve a Programa > Incluir Librería > Gestionar Librerías... y busca e instala las siguientes:

1. DallasTemperature: Para el sensor DS18B20.
2. OneWire: Dependencia de DallasTemperature.
3. Adafruit ADS1X15: Para el módulo ADC ADS1115.
4. WiFiManager: Para una fácil configuración de la red Wi-Fi (opcional pero muy recomendable).
5. PubSubClient: Para comunicación MQTT con la plataforma IoT.

📝 Programación del ESP32

Este es el corazón de nuestro sistema. El código leerá los sensores, calibrará los datos y los enviará a una plataforma IoT. Utilizaremos MQTT para la comunicación.

#include <WiFi.h>
#include <PubSubClient.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Adafruit_ADS1X15.h>
// WiFiManager es excelente para configurar el WiFi sin quemar credenciales en el código
// Si no quieres usar WiFiManager, puedes hardcodear tus credenciales WiFi
#include <WiFiManager.h> // https://github.com/tzapu/WiFiManager

// --- Credenciales de tu Plataforma IoT (ej. Adafruit IO, ThingSpeak, etc.) ---
#define MQTT_SERVER       "io.adafruit.com" // O el servidor MQTT de tu elección
#define MQTT_PORT         1883
#define MQTT_USERNAME     "tu_nombre_usuario_mqtt" // Tu username MQTT
#define MQTT_KEY          "tu_clave_mqtt"       // Tu clave MQTT
#define CLIENT_ID         "ESP32AcuarioMonitor" // ID único para tu dispositivo

// --- Feeds MQTT para publicar datos ---
#define TOPIC_TEMP        "tu_nombre_usuario_mqtt/feeds/acuario.temperatura"
#define TOPIC_PH          "tu_nombre_usuario_mqtt/feeds/acuario.ph"
#define TOPIC_TURBIDEZ    "tu_nombre_usuario_mqtt/feeds/acuario.turbidez"

// --- Pines del ESP32 ---
#define ONE_WIRE_BUS      4  // GPIO donde está conectado el DS18B20
#define PH_PIN            34 // GPIO para la salida analógica del módulo de pH
// ADS1115 conectado a I2C (SDA=GPIO21, SCL=GPIO22)
// El sensor de turbidez se conecta a la entrada A0 del ADS1115

// --- Variables para Sensores ---
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

Adafruit_ADS1115 ads; // Usamos la dirección I2C por defecto (0x48)

// --- Calibración del Sensor de pH ---
// Estos valores pueden requerir ajuste. Calibra tu sensor y obtén los valores ADC correspondientes.
// Ejemplo: voltaje a pH 7.0 y voltaje a pH 4.0
float phCalibrationValue_7 = 2.50; // Voltaje del sensor a pH 7.0
float phCalibrationValue_4 = 3.00; // Voltaje del sensor a pH 4.0

// --- Calibración del Sensor de Turbidez ---
// Estos valores son aproximados y deben obtenerse experimentalmente
// en agua limpia y agua turbia para tu sensor específico.
// Ejemplo: valores ADC en agua clara y agua turbia conocida.
int clearWaterADC = 20000; // Valor ADC aproximado en agua clara (ajusta)
int turbidWaterADC = 5000; // Valor ADC aproximado en agua turbia (ajusta)

// --- Configuración de MQTT y WiFi ---
WiFiClient espClient;
PubSubClient client(espClient);

long lastMsg = 0;

void setup() {
  Serial.begin(115200);
  while (!Serial);
  Serial.println("\nIniciando sistema de monitoreo acuático...");

  // Iniciar WiFiManager para configurar la red
  WiFiManager wifiManager;
  // Descomentar la siguiente línea para resetear las credenciales WiFi y forzar el modo AP
  // wifiManager.setDebugOutput(true);
  // wifiManager.resetSettings();
  Serial.println("Conectando a WiFi (o iniciando AP para configuración)...");
  if (!wifiManager.autoConnect("AcuarioMonitorAP", "passwordiot")) {
    Serial.println("Fallo la conexión y timeout.");
    ESP.restart();
  }
  Serial.println("WiFi conectado.");
  Serial.print("Dirección IP: ");
  Serial.println(WiFi.localIP());

  // Configurar MQTT
  client.setServer(MQTT_SERVER, MQTT_PORT);
  // No necesitamos un callback para recibir mensajes en este tutorial, solo publicamos.

  // Iniciar sensores
  sensors.begin();
  
  if (!ads.begin()) {
    Serial.println("Fallo al encontrar ADS1115. Verifica conexiones.");
    while (1);
  }
  Serial.println("ADS1115 encontrado.");
  // Rango de ganancia, ajusta para obtener mayor resolución para tu rango de voltaje de entrada
  // ads.setGain(GAIN_ONE); // ±4.096V (max resolution)
  ads.setGain(GAIN_TWOTHIRDS); // ±6.144V (good for 5V signals, but be careful with 3.3V logic)

  Serial.println("Sensores inicializados.");
}

void loop() {
  if (!client.connected()) {
    reconnectMqtt();
  }
  client.loop();

  long now = millis();
  if (now - lastMsg > 15000) { // Publicar datos cada 15 segundos
    lastMsg = now;

    // --- Leer Sensor de Temperatura ---
    sensors.requestTemperatures();
    float temperatureC = sensors.getTempCByIndex(0);
    Serial.print("Temperatura: ");
    Serial.print(temperatureC);
    Serial.println(" C");
    client.publish(TOPIC_TEMP, String(temperatureC).c_str());

    // --- Leer Sensor de pH ---
    // El sensor de pH devuelve un voltaje. Debemos convertirlo a pH.
    // El ADS1115 puede leer hasta 4 canales. Usamos A0 para turbidez, pH directo al ESP32.
    // Asumiendo que el módulo de pH tiene su propia amplificación y salida de 0-5V que mapeamos a 0-3.3V en ESP32 ADC.
    // Necesitamos mapear el valor ADC del ESP32 (0-4095) a voltaje (0-3.3V).
    int phAdcRaw = analogRead(PH_PIN);
    float phVoltage = phAdcRaw * (3.3 / 4095.0); // Convertir lectura ADC a voltaje (para ESP32 a 3.3V)
    
    // Fórmula de linealización del pH (requiere calibración de 2 puntos)
    // ph = (voltage - phCalibrationValue_7) * ((4.0 - 7.0) / (phCalibrationValue_4 - phCalibrationValue_7)) + 7.0;
    // Ejemplo simplificado (solo con 7.0V punto de calibración): pH = 7.0 - ((phVoltage - phCalibrationValue_7) / 0.17);
    // Asumiendo una relación lineal simple y un offset:
    // Para el módulo pH de DFRobot, por ejemplo, pH = 3.5 * phVoltage + offset
    // O usando la referencia del módulo pH a voltaje de 2.5V=pH7.0 y un factor de 0.17 por unidad de pH
    // float pH = 7.0 - ((phVoltage - 2.5) / 0.17); // Esto es un ejemplo, calibra con tus propios valores
    
    // Usaremos una aproximación lineal simple para este ejemplo. ¡Realiza una calibración adecuada!
    // Basado en el punto de calibración a pH 7.0 (phCalibrationValue_7) y una pendiente aproximada.
    // Si phCalibrationValue_7 es el voltaje a pH 7.0, y asumimos una pendiente de -0.17V/pH (típico para electrodos)
    float pH_value = 7.0 - ((phVoltage - phCalibrationValue_7) / 0.17); // Ajusta la pendiente (0.17) y el punto de calibración.

    Serial.print("pH: ");
    Serial.print(pH_value, 2);
    Serial.print(" (Voltaje: ");
    Serial.print(phVoltage, 3);
    Serial.println("V)");
    client.publish(TOPIC_PH, String(pH_value, 2).c_str());

    // --- Leer Sensor de Turbidez (vía ADS1115) ---
    int16_t turbidezAdcRaw = ads.readADC_SingleEnded(0); // Leer canal A0 del ADS1115
    
    // Convertir el valor ADC a un porcentaje o NTU aproximados
    // Esto es una interpolación lineal simple. Para mayor precisión, se necesita una curva de calibración.
    float turbidezPercent = map(turbidezAdcRaw, turbidWaterADC, clearWaterADC, 100, 0); // Mapea de 100% turbio a 0% turbio
    turbidezPercent = constrain(turbidezPercent, 0, 100); // Asegura que esté entre 0 y 100

    Serial.print("Turbidez (ADC): ");
    Serial.print(turbidezAdcRaw);
    Serial.print(" (Aprox. ");
    Serial.print(turbidezPercent, 1);
    Serial.println("% turbio)");
    client.publish(TOPIC_TURBIDEZ, String(turbidezPercent, 1).c_str());
  }
}

void reconnectMqtt() {
  // Bucle hasta que estemos reconectados
  while (!client.connected()) {
    Serial.print("Intentando conexión MQTT...");
    // Intenta conectar
    if (client.connect(CLIENT_ID, MQTT_USERNAME, MQTT_KEY)) {
      Serial.println("conectado.");
      // Si te suscribes a algún tema, hazlo aquí
    } else {
      Serial.print("falló, rc=");
      Serial.print(client.state());
      Serial.println(" reintentando en 5 segundos.");
      // Espera 5 segundos antes de reintentar
      delay(5000);
    }
  }
}

☁️ Configuración de la Plataforma IoT (Adafruit IO)

Adafruit IO es una excelente plataforma para este tipo de proyectos. Es gratuita para uso básico y fácil de integrar con MQTT.

Paso 1: Crear una Cuenta en Adafruit IO

1. Ve a io.adafruit.com.
2. Regístrate para obtener una cuenta gratuita.
3. Una vez iniciada la sesión, haz clic en "My Key" para encontrar tu ADAFRUIT_USERNAME y ADAFRUIT_AIO_KEY (tu clave MQTT). Anótalos y reemplázalos en el código del ESP32 (MQTT_USERNAME y MQTT_KEY).

Paso 2: Crear Feeds

Los "feeds" son donde tus datos se almacenan y se hacen accesibles. Necesitaremos uno para cada sensor.

1. En el menú de Adafruit IO, ve a "Feeds > Actions > Create a New Feed".

2. Crea tres feeds con los siguientes nombres (puedes usar otros, pero asegúrate de que coincidan con los TOPIC_ definidos en tu código):

   • temperatura
   • ph
   • turbidez

   Por ejemplo, si tu ADAFRUIT_USERNAME es myuser, los tópicos completos serían:

   • myuser/feeds/temperatura
   • myuser/feeds/ph
   • myuser/feeds/turbidez

Paso 3: Crear un Dashboard

Los dashboards te permiten visualizar tus datos de forma gráfica.

1. Ve a "Dashboards > Actions > Create a New Dashboard".
2. Dale un nombre, como "Acuario Monitor".
3. Haz clic en el dashboard para abrirlo.
4. Haz clic en el botón de "+" (Add Block) en la esquina superior derecha.
5. Elige el tipo de bloque que quieres (ej. "Line Chart" para temperatura y pH, "Gauge" para turbidez).
6. Selecciona el feed correspondiente (ej. temperatura para el gráfico de temperatura).
7. Configura los parámetros del bloque (rango, título, etc.) y haz clic en "Create Block".
8. Repite para el pH y la turbidez.

Ahora tu dashboard debería mostrar los datos en cuanto el ESP32 empiece a publicarlos.

🚀 Puesta en Marcha y Pruebas

Con todo el hardware conectado y el software programado, ¡es hora de la verdad!

📈 Mejoras y Próximos Pasos

Este sistema es una base sólida, pero las posibilidades de expansión son infinitas:

• Alertas por Email/SMS: Configura Adafruit IO para enviar alertas cuando los valores de los sensores superen ciertos umbrales (ej. pH muy bajo, temperatura muy alta).
• Actuadores: Integra bombas de dosificación para ajustar el pH automáticamente, calentadores para controlar la temperatura, o aireadores.
• Más Sensores: Añade sensores de oxígeno disuelto, conductividad eléctrica (TDS/EC), nivel de agua o incluso cámaras para monitoreo visual.
• Almacenamiento Local: Guarda los datos en una tarjeta SD en el ESP32 como respaldo o para análisis offline.
• Interfaz Web Local: Crea una interfaz web sencilla en el propio ESP32 para visualizar datos sin depender de una conexión a la nube constante.
• Batería y Energía Solar: Para monitorear estanques remotos, podrías alimentar el ESP32 con una batería y un panel solar.

Este proyecto no solo te ayuda a mantener un ecosistema acuático saludable, sino que también te introduce a los principios del IoT, la electrónica y la programación. ¡Experimenta y personaliza tu sistema para adaptarlo a tus necesidades!