Gestión Remota de Invernaderos con Sensores de Suelo y Actuadores usando ESP32

🚀 Introducción a la Gestión Remota de Invernaderos con IoT

El internet de las Cosas (IoT) ha revolucionado muchas industrias, y la agricultura no es una excepción. Los invernaderos, que tradicionalmente requieren una supervisión constante, pueden beneficiarse enormemente de la automatización y el monitoreo remoto. Con un sistema IoT, puedes optimizar las condiciones de crecimiento de tus plantas, reducir el consumo de recursos y minimizar el esfuerzo manual.

En este tutorial, construiremos un sistema robusto y escalable para monitorear y controlar un invernadero utilizando el potente microcontrolador ESP32. Nos enfocaremos en la lectura de humedad del suelo, temperatura y humedad ambiental, y en el control de actuadores como bombas de agua y luces, todo ello accesible a través de una plataforma IoT en la nube.

🎯 Objetivos del Tutorial

Al finalizar este tutorial, serás capaz de:

• Entender los fundamentos de un sistema IoT para invernaderos.
• Seleccionar y conectar sensores de humedad del suelo, temperatura y humedad ambiental al ESP32.
• Controlar actuadores como bombas de agua o relés para luces usando el ESP32.
• Configurar el ESP32 para conectarse a una red Wi-Fi y enviar datos a una plataforma IoT.
• Visualizar los datos del invernadero en tiempo real desde una aplicación o navegador web.
• Implementar lógica básica para la automatización (ej. riego automático cuando la humedad baja).

🛠️ Materiales Necesarios

Para llevar a cabo este proyecto, necesitarás los siguientes componentes. Te recomendamos adquirir una placa de desarrollo ESP32, ya que es versátil y fácil de programar.

⚙️ Configuración del Entorno de Desarrollo

Utilizaremos el IDE de Arduino para programar nuestro ESP32, ya que es ampliamente conocido y cuenta con una gran comunidad y librerías.

1. Instalación del IDE de Arduino

Si aún no lo tienes, descarga e instala el IDE de Arduino desde su sitio web oficial.

2. Configuración de la Placa ESP32 en el IDE de Arduino

Para poder programar el ESP32, necesitas añadir sus "Board Managers" al IDE de Arduino:

1. Abre el IDE de Arduino.
2. Ve a Archivo > Preferencias.
3. En el campo URLs adicionales de gestores de tarjetas, añade 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. Instalación de Librerías Necesarias

Para interactuar con los sensores y la plataforma IoT, necesitarás instalar algunas librerías. Ve a Programa > Incluir Librería > Administrar Librerías... y busca e instala las siguientes:

• DHT sensor library by Adafruit (para DHT11/DHT22)
• PubSubClient by Nick O'Leary (para MQTT, si usas esta opción para la plataforma IoT)
• Otras librerías específicas de tu plataforma IoT si es necesario (ej. Adafruit MQTT Library si usas Adafruit IO)

🔌 Diagrama de Conexiones (Esquemático)

La correcta conexión de los componentes es crucial. A continuación, se presenta un diagrama general. Asegúrate de consultar las hojas de datos de tus sensores específicos para la asignación de pines.

Detalle de Conexiones:

1. Sensor de Humedad del Suelo Capacitivo:

   • VCC a 3.3V del ESP32
   • GND a GND del ESP32
   • AO (Salida Analógica) a GPIO34 (o cualquier pin analógico ADC del ESP32)

2. Sensor DHT11/DHT22:

   • VCC a 3.3V del ESP32
   • GND a GND del ESP32
   • Data a GPIO16 del ESP32 (o cualquier pin digital)
   • Algunos módulos DHT ya incluyen una resistencia pull-up, si no, añade una resistencia de 10k entre VCC y Data.

3. Módulo de Relé:

   • VCC a 5V de la fuente externa (o ESP32 si soporta la carga)
   • GND a GND de la fuente externa y GND del ESP32
   • IN (Input del relé) a GPIO27 del ESP32 (o cualquier pin digital)

4. Mini Bomba de Agua:

   • Conecta un cable del terminal NO (Normalmente Abierto) del relé a un terminal de la bomba.
   • Conecta el otro terminal de la bomba al GND de la fuente de alimentación externa.
   • Conecta el terminal COM (Común) del relé al VCC de la fuente de alimentación externa (5V).
   • De esta forma, el ESP32 activa el relé, que a su vez completa el circuito de la bomba con la fuente de alimentación externa.

☁️ Plataforma IoT en la Nube

Para este tutorial, utilizaremos Adafruit IO debido a su facilidad de uso, su capa gratuita y su buena integración con ESP32. Otras opciones incluyen Blynk, Thingspeak, o incluso plataformas más avanzadas como AWS IoT o Google Cloud IoT.

1. Creación de una Cuenta en Adafruit IO

1. Ve a io.adafruit.com y crea una cuenta gratuita.
2. Una vez iniciada la sesión, anota tu Usuario AIO y tu Clave AIO (disponible en My Key en el panel de control).

2. Creación de Feeds (Canales de Datos)

Los feeds son donde tus sensores enviarán los datos. Necesitarás crear feeds para cada dato que quieras monitorear:

1. En el panel de Adafruit IO, ve a Feeds > Actions > Create a New Feed.
2. Crea los siguientes feeds:
   • humedad-suelo
   • temperatura
   • humedad-ambiente
   • estado-bomba (para enviar el estado de la bomba o para controlarla de forma manual)

3. Creación de un Dashboard (Panel de Control)

Un dashboard te permitirá visualizar los datos y controlar los actuadores de forma interactiva.

1. Ve a Dashboards > Actions > Create a New Dashboard.
2. Nombra tu dashboard (ej. Invernadero Inteligente).
3. Abre el dashboard recién creado y haz clic en el icono de engranaje (Configuración) > Add New Block.
4. Añade los siguientes bloques:
   • Gauge Block: Para humedad-suelo (configura rangos min/max adecuados, ej. 0-1023 si el sensor es de 10 bits).
   • Line Chart Block: Para temperatura y humedad-ambiente (puedes añadir ambos al mismo gráfico).
   • Toggle Block: Para estado-bomba (para activar/desactivar la bomba manualmente).

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

Ahora vamos a escribir el código para el ESP32. Este código leerá los sensores, enviará los datos a Adafruit IO y recibirá comandos para controlar la bomba.

#include <WiFi.h>
#include <AdafruitIO_WiFi.h>
#include "DHT.h"

// --- Configuración de Wi-Fi y Adafruit IO ---
#define IO_USERNAME    "tu_usuario_aio" // Reemplaza con tu usuario AIO
#define IO_KEY         "tu_clave_aio"   // Reemplaza con tu clave AIO

#define WIFI_SSID      "nombre_red_wifi" // Reemplaza con el nombre de tu red Wi-Fi
#define WIFI_PASS      "contrasena_wifi" // Reemplaza con la contraseña de tu red Wi-Fi

// --- Definición de Feeds de Adafruit IO ---
AdafruitIO_WiFi io(IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);

AdafruitIO_Feed *humedadSuelo = io.feed("humedad-suelo");
AdafruitIO_Feed *temperaturaFeed = io.feed("temperatura");
AdafruitIO_Feed *humedadAmbienteFeed = io.feed("humedad-ambiente");
AdafruitIO_Feed *estadoBomba = io.feed("estado-bomba");

// --- Configuración de Pines de Sensores y Actuadores ---
#define PIN_HUMEDAD_SUELO 34 // Pin analógico para el sensor de humedad del suelo
#define PIN_DHT           16 // Pin digital para el sensor DHT
#define PIN_RELE          27 // Pin digital para el módulo de relé

// --- Configuración del sensor DHT ---
#define DHTTYPE DHT11 // O DHT22 si usas ese sensor
DHT dht(PIN_DHT, DHTTYPE);

// --- Variables de control ---
long lastSendTime = 0; // Para controlar el envío de datos
const long sendInterval = 60000; // Intervalo de envío de datos (60 segundos)

// --- Umbral de humedad del suelo para riego automático ---
const int UMBRAL_HUMEDAD_MIN = 400; // Valor de lectura del sensor (ajusta según tus pruebas)

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

  // Inicializar pines
  pinMode(PIN_RELE, OUTPUT);
  digitalWrite(PIN_RELE, HIGH); // Asegura que la bomba esté APAGADA al inicio (relé activo en LOW)

  dht.begin();

  Serial.print("Conectando a Adafruit IO...");
  io.connect();

  // Configurar callback para el feed de la bomba (control manual)
  estadoBomba->onMessage(handleBombaMessage);

  // Esperar a la conexión
  while (io.status() < AIO_CONNECTED) {
    Serial.print(".");
    delay(500);
  }

  Serial.println();
  Serial.print("Adafruit IO Conectado. IP: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  io.run(); // Mantiene la conexión con Adafruit IO

  // Lectura y envío de datos cada 'sendInterval'
  if (millis() - lastSendTime > sendInterval) {
    readAndSendSensorData();
    lastSendTime = millis();
  }

  // Lógica de riego automático
  automaticIrrigationLogic();
}

// --- Función para manejar mensajes del feed 'estado-bomba' ---
void handleBombaMessage(AdafruitIO_Data *data) {
  Serial.print("Comando de bomba recibido: ");
  Serial.println(data->to  String());

  if (data->to  String() == "ON") {
    digitalWrite(PIN_RELE, LOW); // Activa el relé (bomba ON)
    Serial.println("Bomba ACTIVADA por comando remoto.");
  } else {
    digitalWrite(PIN_RELE, HIGH); // Desactiva el relé (bomba OFF)
    Serial.println("Bomba DESACTIVADA por comando remoto.");
  }
}

// --- Función para leer sensores y enviar datos a Adafruit IO ---
void readAndSendSensorData() {
  // Leer humedad del suelo
  int valorHumedad = analogRead(PIN_HUMEDAD_SUELO);
  Serial.print("Humedad del Suelo: ");
  Serial.println(valorHumedad);
  humedadSuelo->save(valorHumedad);

  // Leer temperatura y humedad ambiental
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  if (isnan(h) || isnan(t)) {
    Serial.println("Error al leer del sensor DHT!");
    return;
  }

  Serial.print("Temperatura: ");
  Serial.print(t);
  Serial.print(" *C, Humedad Ambiente: ");
  Serial.print(h);
  Serial.println(" %");

  temperaturaFeed->save(t);
  humedadAmbienteFeed->save(h);
}

// --- Lógica de riego automático ---
void automaticIrrigationLogic() {
  int currentHumedad = analogRead(PIN_HUMEDAD_SUELO);
  Serial.print("Humedad actual para auto-riego: ");
  Serial.println(currentHumedad);

  if (currentHumedad > UMBRAL_HUMEDAD_MIN) { // Recuerda: valores bajos = suelo húmedo para este sensor
    // Suelo seco, activar bomba
    digitalWrite(PIN_RELE, LOW); // Activa el relé (bomba ON)
    Serial.println("💧 Suelo seco detectado. Activando riego automático.");
    estadoBomba->save("ON"); // Actualizar el estado en el dashboard
    delay(5000); // Regar por 5 segundos (ajusta según tus necesidades)
    digitalWrite(PIN_RELE, HIGH); // Desactiva el relé (bomba OFF)
    Serial.println("✅ Riego automático completado.");
    estadoBomba->save("OFF"); // Actualizar el estado en el dashboard
    delay(300000); // Esperar 5 minutos antes de volver a chequear después de regar (evita riegos excesivos)
  }
  // Si el suelo no está seco, no hacemos nada y la bomba permanece apagada
}

Explicación del Código:

• Librerías: Se incluyen las librerías WiFi, AdafruitIO_WiFi y DHT. AdafruitIO_WiFi se utiliza para la conexión con Adafruit IO, WiFi para la conexión a la red inalámbrica y DHT para el sensor de temperatura y humedad.
• Configuración: Define las credenciales de tu red Wi-Fi y tu usuario/clave de Adafruit IO. Es crucial reemplazarlas con tus propios datos.
• Feeds: Se crean objetos AdafruitIO_Feed para cada uno de los canales de datos que configuramos en Adafruit IO.
• Pines: Se definen los pines GPIO del ESP32 a los que están conectados los sensores y el relé.
• setup(): Inicializa la comunicación serial, el sensor DHT, configura el pin del relé y establece la conexión con Adafruit IO. También suscribe el ESP32 al feed estado-bomba para recibir comandos desde el dashboard.
• loop(): La función principal que se ejecuta continuamente. Llama a io.run() para mantener la conexión con Adafruit IO y procesar mensajes. Cada sendInterval (60 segundos), lee los datos de los sensores y los envía a la nube. También ejecuta la lógica de riego automático.
• handleBombaMessage(): Esta función es un callback que se ejecuta cuando el ESP32 recibe un mensaje en el feed estado-bomba. Permite activar o desactivar la bomba de forma remota a través del dashboard.
• readAndSendSensorData(): Lee los valores del sensor de humedad del suelo (analógico) y del sensor DHT (temperatura y humedad ambiental) y los publica en los feeds correspondientes de Adafruit IO.
• automaticIrrigationLogic(): Compara la lectura actual del sensor de humedad del suelo con un umbral predefinido. Si la humedad es baja (valor alto del sensor capacitivo indica sequedad), activa la bomba por un tiempo determinado y luego la desactiva. Luego espera un tiempo antes de volver a comprobar para evitar riegos excesivos.

✅ Puesta en Marcha y Pruebas

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

1. Conexión Física Final: Asegúrate de que todas las conexiones estén bien hechas según el diagrama.
2. Carga el Código: Conecta tu ESP32 al ordenador, selecciona la placa y el puerto COM correcto en el IDE de Arduino y carga el código.
3. Monitor Serie: Abre el Monitor Serie en el IDE de Arduino. Deberías ver los mensajes de conexión a Wi-Fi y Adafruit IO, y luego las lecturas de los sensores.
4. Verifica en Adafruit IO: Accede a tu dashboard de Adafruit IO. Deberías empezar a ver los datos de humedad del suelo, temperatura y humedad ambiental actualizándose en tiempo real.

5. Prueba el Riego Manual: Utiliza el Toggle Block de estado-bomba en tu dashboard de Adafruit IO. Deberías escuchar el clic del relé y ver cómo la bomba se activa/desactiva. Observa cómo el estado se actualiza también en el Monitor Serie.
6. Prueba el Riego Automático: Si tu suelo está seco (o simulas esa condición), el sistema debería activar la bomba automáticamente según la lógica definida. Observa los mensajes en el Monitor Serie y el cambio en el estado-bomba del dashboard.

📈 Mejoras y Posibles Extensiones

Este proyecto es una base sólida, pero puedes expandirlo y mejorarlo de muchas maneras:

1. Más Sensores y Actuadores:

• Sensor de Nivel de Agua: Para saber cuándo rellenar el depósito de agua de riego.
• Sensor de Luz/LDR: Para monitorear la intensidad de luz y controlar luces de crecimiento.
• Sensor de pH del Suelo: Crucial para la salud de muchas plantas.
• Ventiladores/Extractores: Controla la ventilación del invernadero para regular la temperatura y humedad.
• Servo Motor: Para abrir/cerrar ventanas o persianas del invernadero.

2. Alertas y Notificaciones:

• Configura alertas en Adafruit IO (o con servicios como IFTTT) para recibir notificaciones por correo electrónico, SMS o push en tu teléfono si los valores de los sensores superan ciertos umbrales (ej. "Suelo muy seco", "Temperatura alta").

3. Lógica de Control Avanzada:

• Implementa un control PID para mantener la temperatura o humedad dentro de un rango más preciso.
• Programa horarios de riego o iluminación basados en la hora del día o la estación.
• Ajusta la duración del riego automáticamente según la lectura de humedad para ser más eficiente.

4. Batería y Energía Solar:

• Para invernaderos remotos sin acceso a la red eléctrica, considera alimentar el ESP32 y los sensores con una batería recargable y un panel solar.

5. Interfaz de Usuario Personalizada:

• Desarrolla tu propia aplicación web o móvil para una interfaz más personalizada y con más funcionalidades que un dashboard de Adafruit IO.

❓ Preguntas Frecuentes (FAQ)

conclusiones

Has llegado al final de este tutorial y ahora tienes un sistema de gestión de invernaderos inteligente completamente funcional. Has aprendido a integrar hardware (ESP32, sensores, actuadores) con una plataforma IoT en la nube para monitorear y controlar tu entorno de cultivo de forma remota. Este conocimiento no solo te ayudará a mantener tus plantas sanas, sino que también te abre las puertas a innumerables proyectos en el emocionante mundo del Internet de las Cosas.

¡Experimenta, ajusta y mejora tu invernadero inteligente! La automatización es una herramienta poderosa para hacer tu vida más fácil y tus cultivos más productivos.