Control Inteligente de Riego Agrícola con ESP32 y Plataforma IoT

🚀 Introducción al Riego Inteligente con IoT

En un mundo donde la eficiencia y la sostenibilidad son clave, la agricultura moderna se beneficia enormemente de las tecnologías emergentes como el Internet de las Cosas (IoT). Un sistema de riego inteligente no solo permite un control preciso sobre el suministro de agua, sino que también contribuye a la conservación de este recurso vital y a la mejora de la salud de los cultivos.

Este tutorial te sumergirá en el fascinante mundo del IoT aplicado a la agricultura, mostrándote cómo construir tu propio sistema de riego inteligente. Utilizaremos el versátil microcontrolador ESP32, sensores de humedad del suelo y una plataforma IoT para visualizar datos y controlar el sistema a distancia.

¿Por qué un Sistema de Riego Inteligente? 🤔

Tradicionalmente, el riego se realiza en intervalos fijos o por observación manual, lo que a menudo lleva a un riego excesivo o insuficiente. Ambas situaciones son perjudiciales:

• Riego excesivo: Desperdicio de agua, lixiviación de nutrientes, enfermedades fúngicas.
• Riego insuficiente: Estrés hídrico en las plantas, crecimiento stunted, baja productividad.

Un sistema inteligente basado en IoT permite:

• Optimización del agua: Riega solo cuando es necesario y con la cantidad justa.
• Monitoreo en tiempo real: Conoce el estado de tu suelo en todo momento.
• Control remoto: Activa o desactiva el riego desde cualquier lugar.
• Automatización: Establece reglas para que el sistema opere por sí mismo.
• Mejora de cultivos: Plantas más sanas y mayores rendimientos.

🛠️ Materiales Necesarios

Para embarcarte en este proyecto, necesitarás los siguientes componentes. Asegúrate de tenerlos a mano antes de comenzar.

🔌 Diagrama de Conexiones

Antes de empezar a programar, es crucial entender cómo se conectarán todos los componentes. Este diagrama te mostrará las conexiones principales. Siempre ten cuidado al manipular componentes electrónicos y asegúrate de que todo esté desconectado de la energía mientras realizas las conexiones.

Detalles de Conexión:

1. Sensor de Humedad de Suelo:

   • VCC del sensor al 3.3V (o 5V con divisor de voltaje) del ESP32.
   • GND del sensor al GND del ESP32.
   • Analog Output del sensor a un pin ADC del ESP32 (ej. VP o GPIO36).
   ⚠️ Advertencia: Algunos sensores de humedad operan a 5V. El ESP32 tiene pines de entrada analógica de 3.3V. Si tu sensor es de 5V, necesitarás un divisor de voltaje (dos resistencias) para reducir la señal a 3.3V y evitar dañar el ESP32. Consulta la hoja de datos de tu sensor.

2. Módulo Relé:

   • VCC del relé al 3.3V o 5V (dependiendo del relé) del ESP32.
   • GND del relé al GND del ESP32.
   • IN del relé a un pin GPIO digital del ESP32 (ej. GPIO2).

3. Bomba de Agua:

   • Conecta los dos terminales de la bomba a los pines COM y NO (Normalmente Abierto) del relé. De esta manera, cuando el relé se activa, completa el circuito y enciende la bomba.
   • La bomba debe alimentarse con su propia fuente de alimentación (ej. 5V o 12V DC), NO directamente del ESP32.
   • Asegúrate de que el GND de la fuente de alimentación de la bomba esté conectado al GND del ESP32 (masa común).

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

Para programar el ESP32, usaremos el Arduino IDE, una herramienta sencilla y muy extendida.

1. Instalar Arduino IDE

Si aún no lo tienes, descarga e instala el Arduino IDE desde arduino.cc.

2. Configurar la Tarjeta ESP32

Para que el Arduino IDE pueda programar el ESP32, necesitas añadir el soporte de tarjetas:

• Ve a Archivo > Preferencias.
• En el campo URLs Adicionales para Gestores de Tarjetas, añade la siguiente URL: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
• Haz clic en OK.
• Ve a Herramientas > Placa > Gestor de Tarjetas....
• Busca esp32 e instala la plataforma esp32 by Espressif Systems.

3. Instalar Librerías Adicionales

Dependiendo de la plataforma IoT que elijas y si usarás alguna librería específica para el sensor o el relé, puede que necesites instalar más. Para este tutorial, asumiremos que usaremos la librería WiFi.h (ya incluida con el soporte ESP32) y la librería PubSubClient para MQTT si optamos por un broker MQTT.

• Si necesitas PubSubClient (para MQTT), ve a Programa > Incluir Librería > Administrar Librerías....
• Busca PubSubClient e instálala.

☁️ Selección y Configuración de una Plataforma IoT

Una plataforma IoT es esencial para visualizar los datos del sensor y controlar el relé de forma remota. Hay muchas opciones disponibles, tanto gratuitas como de pago. Para este tutorial, consideraremos opciones populares y relativamente fáciles de usar.

Opciones de Plataformas IoT:

1. ThingSpeak: Ideal para monitoreo de datos con visualización básica. Es simple de configurar y permite enviar datos a canales y ver gráficos. Se basa en HTTP/MQTT.
2. Adafruit IO: Ofrece una interfaz amigable, feeds de datos y dashboards personalizables. Permite control bidireccional (enviar y recibir datos). Utiliza MQTT.
3. Blynk: Muy popular para proyectos de prototipado. Permite crear una interfaz de usuario móvil personalizada arrastrando y soltando widgets. Utiliza su propio protocolo.

Para este tutorial, utilizaremos una aproximación genérica basada en MQTT (Message Queuing Telemetry Transport), un protocolo ligero ideal para IoT. Puedes usar un broker MQTT público (como broker.hivemq.com o test.mosquitto.org) o configurar uno propio. Adafruit IO es una excelente opción que implementa MQTT y ofrece una capa de abstracción fácil de usar.

Pasos Básicos con Adafruit IO (Ejemplo): 🎯

1. Crear una cuenta: Regístrate en io.adafruit.com.
2. Obtener AIO Key: Ve a My Key para encontrar tu AIO Username y AIO Key. ¡Guarda esta información de forma segura!
3. Crear Feeds: Crea dos feeds, por ejemplo, humedad-suelo para los datos del sensor y control-riego para el estado del relé.
4. Crear un Dashboard: Crea un dashboard y añade bloques (Block) como un Gauge para la humedad y un Toggle o Button para el control del riego, vinculándolos a tus feeds.

📝 Código del ESP32 (Arduino IDE)

Ahora viene la parte de programación. El código realizará las siguientes tareas:

• Conectarse a la red Wi-Fi.
• Leer datos del sensor de humedad.
• Enviar los datos a la plataforma IoT (via MQTT).
• Recibir comandos de la plataforma IoT para activar/desactivar el relé.
• Implementar lógica de riego automático basada en el umbral de humedad.

#include <WiFi.h>
#include <PubSubClient.h> // Para MQTT

// --- Configuración WiFi ---
const char* ssid = "TU_WIFI_SSID";
const char* password = "TU_WIFI_PASSWORD";

// --- Configuración MQTT / Adafruit IO ---
#define AIO_SERVER      "io.adafruit.com"
#define AIO_SERVERPORT  1883
#define AIO_USERNAME    "TU_AIO_USERNAME"
#define AIO_KEY         "TU_AIO_KEY"

// Temas MQTT
#define HUMEDAD_FEED    AIO_USERNAME "/feeds/humedad-suelo"
#define RIEGO_FEED      AIO_USERNAME "/feeds/control-riego"

// Pines del ESP32
const int sensorHumedadPin = 36; // Pin ADC1_0, GPIO36
const int relePin = 2;           // GPIO2 para el relé

// Umbral de humedad (ajústalo según tus pruebas y tipo de suelo)
const int UMBRAL_HUMEDAD = 2000; // Valor RAW del sensor. Menor valor = más seco.

// Variables de estado
int valorHumedad = 0;
bool estadoRiego = false;

WiFiClient client;
PubSubClient mqttClient(client);

unsigned long lastMsg = 0;
#define MSG_INTERVAL 5000 // Intervalo de envío de datos (5 segundos)

// --- Funciones ---

void setup_wifi() {
  delay(10);
  Serial.println();
  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.println("Dirección IP: ");
  Serial.println(WiFi.localIP());
}

// Callback para mensajes MQTT recibidos
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje recibido en tema: ");
  Serial.print(topic);
  Serial.print(" - Mensaje: ");
  String message;
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
    message += (char)payload[i];
  }
  Serial.println();

  // Controlar relé si el mensaje es para el tema de control de riego
  if (String(topic) == RIEGO_FEED) {
    if (message == "ON") {
      digitalWrite(relePin, LOW); // LOW activa muchos relés de 5V (normalmente abierto)
      estadoRiego = true;
      Serial.println("Riego ACTIVADO manualmente.");
    } else if (message == "OFF") {
      digitalWrite(relePin, HIGH); // HIGH desactiva muchos relés de 5V
      estadoRiego = false;
      Serial.println("Riego DESACTIVADO manualmente.");
    }
  }
}

void reconnect_mqtt() {
  // Bucle hasta que estemos reconectados
  while (!mqttClient.connected()) {
    Serial.print("Intentando conexión MQTT...");
    // Crea un ID de cliente aleatorio
    String clientId = "ESP32Client-";
    clientId += String(random(0xffff), HEX);
    // Intenta conectar
    if (mqttClient.connect(clientId.c_str(), AIO_USERNAME, AIO_KEY)) {
      Serial.println("conectado");
      // Una vez conectado, suscríbete a los temas de control
      mqttClient.subscribe(RIEGO_FEED);
    } else {
      Serial.print("falló, rc=");
      Serial.print(mqttClient.state());
      Serial.println(" reintento en 5 segundos");
      // Espera 5 segundos antes de reintentar
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(relePin, OUTPUT);
  digitalWrite(relePin, HIGH); // Asegurarse de que el riego esté APAGADO al inicio

  setup_wifi();
  mqttClient.setServer(AIO_SERVER, AIO_SERVERPORT);
  mqttClient.setCallback(callback);
}

void loop() {
  if (!mqttClient.connected()) {
    reconnect_mqtt();
  }
  mqttClient.loop();

  unsigned long now = millis();
  if (now - lastMsg > MSG_INTERVAL) {
    lastMsg = now;

    // Leer el sensor de humedad (valor RAW, 0-4095 para ESP32)
    valorHumedad = analogRead(sensorHumedadPin);
    Serial.print("Humedad del suelo (RAW): ");
    Serial.println(valorHumedad);

    // Publicar humedad en Adafruit IO
    mqttClient.publish(HUMEDAD_FEED, String(valorHumedad).c_str());

    // Lógica de riego automático (si no hay control manual activo)
    if (!estadoRiego) { // Si no estamos en modo manual de riego
      if (valorHumedad > UMBRAL_HUMEDAD) { // Si el suelo está muy seco
        Serial.println("Suelo seco, activando riego automático...");
        digitalWrite(relePin, LOW); // Activa el riego
        estadoRiego = true; // Marca que el riego está activo (por auto o manual)
        mqttClient.publish(RIEGO_FEED, "ON"); // Actualiza el estado en la plataforma
        // Opcional: temporizar el riego automático, luego apagarlo
        // delay(TIEMPO_RIEGO_MS); // Riega por X milisegundos
        // digitalWrite(relePin, HIGH); 
        // estadoRiego = false;
        // mqttClient.publish(RIEGO_FEED, "OFF");
      } else {
        Serial.println("Humedad OK. Riego automático no necesario.");
        digitalWrite(relePin, HIGH); // Asegurarse de que esté APAGADO
        if (estadoRiego) { // Si el riego estaba activo y ya no es necesario
           estadoRiego = false; // Desactiva el estado de riego
           mqttClient.publish(RIEGO_FEED, "OFF"); // Actualiza la plataforma
        }
      }
    } else { // Si el riego está activo (ya sea manual o automático)
       Serial.println("Riego actualmente activo.");
       // Aquí puedes añadir lógica para apagar el riego si ya está muy húmedo
       // y fue activado manualmente, o si ya pasó el tiempo de riego automático.
    }
  }
}

Explicación del Código 📖

• Bibliotecas: Se incluyen WiFi.h para conectividad y PubSubClient.h para comunicación MQTT.
• Credenciales: Define tu SSID y contraseña de Wi-Fi, así como tus credenciales de Adafruit IO (AIO_USERNAME, AIO_KEY).
• Pines: Se configuran los pines sensorHumedadPin (analógico) y relePin (digital).
• setup_wifi(): Conecta el ESP32 a tu red Wi-Fi.
• reconnect_mqtt(): Establece la conexión con el broker MQTT de Adafruit IO. Si la conexión se pierde, intentará reconectar automáticamente.
• callback(): Esta función se ejecuta cuando el ESP32 recibe un mensaje MQTT en uno de los temas a los que está suscrito. Aquí, si recibe un ON u OFF en el tema control-riego, activa o desactiva el relé.
• setup(): Inicializa la comunicación serial, configura el relePin como salida (y lo apaga por defecto), y llama a las funciones de configuración de Wi-Fi y MQTT.
• loop(): Es el bucle principal. En cada iteración:
  • Verifica y mantiene la conexión MQTT.
  • Lee el valor del sensor de humedad analógico.
  • Publica el valor de humedad en el feed humedad-suelo de Adafruit IO cada MSG_INTERVAL (5 segundos).
  • Contiene la lógica de riego automático: Si el suelo está más seco que UMBRAL_HUMEDAD y el riego no está ya activo (manual o auto), enciende la bomba. Si el suelo ya no está seco y el riego estaba activo, lo apaga.
  • Actualiza el estado del riego en la plataforma IoT (control-riego).

🧪 Pruebas y Calibración

Una vez que hayas cargado el código en tu ESP32, es crucial realizar pruebas y calibrar el sistema.

1. Monitor Serial

Abre el Monitor Serial en el Arduino IDE (asegúrate de que la velocidad de baudios sea 115200). Deberías ver mensajes indicando la conexión Wi-Fi, la conexión MQTT y las lecturas del sensor de humedad.

2. Calibración del Sensor de Humedad

• Tierra muy seca: Coloca el sensor en tierra completamente seca. Anota el valor RAW que muestra el Monitor Serial. Este será tu valor_seco_maximo.
• Tierra húmeda: Coloca el sensor en tierra bien húmeda (pero no encharcada). Anota el valor RAW. Este será tu valor_humedo_minimo.
• Define tu umbral: Elige un valor entre estos dos para tu UMBRAL_HUMEDAD en el código. Por ejemplo, si seco es 3500 y húmedo es 1500, un umbral de 2000 podría ser adecuado para activar el riego cuando esté bastante seco. Experimenta hasta encontrar el punto óptimo para tus cultivos.

3. Prueba de Riego Manual y Automático

• Manual: Desde tu dashboard de Adafruit IO, usa el Toggle o Button para activar y desactivar el riego. Observa si el relé se enciende/apaga y si la bomba funciona.
• Automático: Ajusta el UMBRAL_HUMEDAD para forzar la condición de 'seco' (o simula tierra seca). Observa si el sistema de riego se activa automáticamente. Luego, humedece el sensor (o la tierra) y verifica si el sistema se desactiva cuando la humedad supera el umbral.

📈 Visualización y Control en la Plataforma IoT

Una vez que tu ESP32 está enviando datos, podrás verlos y controlarlos desde tu dashboard. Si usaste Adafruit IO:

1. Dashboard de Humedad: Verás un gráfico en tiempo real o un medidor (Gauge) que muestra las lecturas de humedad del suelo. Esto te permite entender los patrones de humedad de tus cultivos.
2. Control de Riego: Con el widget de Toggle o Button conectado al feed control-riego, podrás encender o apagar la bomba de forma remota. El código del ESP32 también actualizará este feed cuando el riego se active o desactive automáticamente.

✨ Mejoras y Futuras Expansiones

Este sistema es una excelente base, pero hay muchas formas de mejorarlo y expandir sus capacidades:

• Múltiples Sensores: Añade más sensores de humedad en diferentes puntos de tu área de cultivo para una monitorización más precisa.
• Sensores Adicionales: Integra sensores de temperatura del aire/suelo, luz solar, pH del suelo, o incluso nivel de agua en el depósito de riego.
• Programación por Horarios: Implementa una función para regar en horarios específicos, además de la lógica basada en humedad, usando un RTC (Real Time Clock) o el NTP del ESP32.
• Valores Promedio: Calcula promedios de humedad para suavizar las lecturas y evitar riegos impulsivos debido a variaciones momentáneas del sensor.
• Sistema de Alertas: Configura alertas (email, SMS, notificaciones push) cuando los niveles de humedad sean críticos o cuando el sistema se active/desactive.
• Batería y Energía Solar: Haz el sistema autónomo con una batería recargable y un panel solar, ideal para ubicaciones remotas.
• Integración con Home Assistant: Si ya usas un sistema de domótica, integra tu sistema de riego para un control centralizado.
• Bomba más Potente: Para áreas de cultivo más grandes, necesitarás una bomba de mayor capacidad y quizás un sistema de electroválvulas para controlar zonas de riego individuales.

✅ Conclusión

¡Felicidades! Has construido un sistema de riego agrícola inteligente con ESP32 y una plataforma IoT. Este proyecto no solo te ha familiarizado con los fundamentos del IoT y la electrónica, sino que también te ha proporcionado una herramienta práctica para la gestión eficiente del agua en la agricultura o en tu jardín personal.

El potencial de la tecnología IoT en el sector agrícola es inmenso. Sigue explorando y adaptando este sistema a tus necesidades específicas para llevar tus habilidades al siguiente nivel. ¡El futuro de la agricultura es inteligente!