Sistema IoT para el Monitoreo Remoto de Cultivos Verticales con ESP32 y Grafana

🚀 Introducción al Monitoreo Inteligente de Cultivos Verticales

El futuro de la agricultura urbana y sostenible está en los cultivos verticales. Maximizar la eficiencia y el rendimiento en estos entornos controlados requiere una monitorización precisa y constante de variables clave como la temperatura, la humedad ambiental y la intensidad de la luz. En este tutorial, te guiaremos paso a paso en la creación de un sistema de Internet de las Cosas (IoT) que te permitirá vigilar tus cultivos verticales desde cualquier lugar, garantizando las condiciones óptimas para su crecimiento.

Utilizaremos el potente microcontrolador ESP32, conocido por su capacidad Wi-Fi y Bluetooth, una serie de sensores comunes y la plataforma de visualización de datos Grafana para crear un dashboard interactivo y útil. ¡Prepárate para llevar tu jardinería vertical al siguiente nivel tecnológico! 🌿📊

¿Por qué monitorear cultivos verticales con IoT? 🤔

Los cultivos verticales ofrecen grandes ventajas, pero también plantean desafíos únicos. Mantener un ambiente ideal es crucial para prevenir enfermedades, optimizar el uso de recursos y asegurar una alta producción. Un sistema IoT te permite:

• Optimizar condiciones: Ajusta el riego, la luz y la ventilación basándose en datos reales.
• Prevenir problemas: Detecta anomalías como picos de temperatura o baja humedad antes de que afecten tus plantas.
• Ahorrar tiempo: Accede a la información desde tu teléfono o computadora sin necesidad de estar físicamente presente.
• Tomar decisiones basadas en datos: Analiza tendencias y mejora tus estrategias de cultivo.

---

🛠️ Materiales Necesarios

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

Componente	Descripción	Cantidad	Costo Estimado (USD)
---	---	---	---
ESP32 DevKitC	Placa de desarrollo con Wi-Fi y Bluetooth.	1	8 - 15
Sensor DHT11/DHT22	Mide temperatura y humedad ambiental. (DHT22 es más preciso).	1	3 - 8
---	---	---	---
Sensor LDR (Fotorresistencia)	Mide la intensidad de la luz.	1	1 - 2
Resistencia de 10kΩ	Necesaria para el sensor LDR.	1	< 1
---	---	---	---
Protoboard	Para realizar las conexiones de forma temporal.	1	2 - 5
Cables Jumper M-M y M-H	Para conectar los componentes.	Varias	2 - 5
---	---	---	---
Cable Micro USB	Para alimentar el ESP32 y programarlo.	1	1 - 3
Fuente de alimentación 5V	Opcional, si no usas el puerto USB de la PC.	1	5 - 10
---	---	---	---
PC con Arduino IDE	Para programar el ESP32.	1	-
Acceso a Internet	Para el ESP32 y la configuración de Grafana.	1	-

---

🔌 Diagrama de Conexiones

Realizar las conexiones correctamente es el primer paso crítico. Aquí te presentamos un esquema detallado.

Conexión del Sensor DHT11/DHT22

El sensor DHT tiene 3 pines (o 4 si es el modelo con VCC, Data, NC, GND). Usaremos los pines VCC, Data y GND.

• VCC del DHT al pin 3.3V del ESP32.
• GND del DHT al pin GND del ESP32.
• Data del DHT a un pin digital del ESP32 (por ejemplo, GPIO 4).

Conexión del Sensor LDR

El LDR es una resistencia variable. Para medir su valor, crearemos un divisor de voltaje junto con una resistencia fija.

• Un extremo del LDR al pin 3.3V del ESP32.
• El otro extremo del LDR a un extremo de la resistencia de 10kΩ.
• El otro extremo de la resistencia de 10kΩ al pin GND del ESP32.
• El punto de unión entre el LDR y la resistencia de 10kΩ a un pin analógico del ESP32 (por ejemplo, GPIO 34).

---

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

Antes de programar el ESP32, necesitas configurar el Arduino IDE para que sea compatible con la placa. Si ya lo tienes configurado, puedes saltar este paso.

1. Instalar el soporte de ESP32

Dirígete a Archivo > Preferencias en Arduino IDE. 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

Cierra las preferencias.

2. Instalar la placa ESP32

Ve a Herramientas > Placa > Gestor de Tarjetas... Busca "ESP32" e instala el paquete esp32 by Espressif Systems.

3. Seleccionar la placa

Una vez instalado, en Herramientas > Placa, selecciona ESP32 Dev Module (o tu modelo específico de ESP32).

4. Instalar librerías

Necesitarás las librerías para el sensor DHT y para la comunicación Wi-Fi. Ve a Programa > Incluir Librería > Gestionar Librerías... y busca e instala:

• DHT sensor library by Adafruit
• Adafruit Unified Sensor by Adafruit

---

📝 Código del ESP32: Lectura de Sensores y Envío de Datos

Ahora vamos a programar el ESP32 para que lea los datos de los sensores y los envíe a un servicio en la nube. Para este tutorial, usaremos un servidor MQTT como intermediario, que luego Grafana podrá consumir a través de un backend adecuado (como InfluxDB).

Aquí tienes el código base. Asegúrate de reemplazar SSID, PASSWORD, MQTT_SERVER y MQTT_PORT con tus propios datos.

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>
#include <Adafruit_Sensor.h>

// --- Configuración WiFi ---
const char* ssid = "TU_SSID"; // Tu nombre de red WiFi
const char* password = "TU_PASSWORD"; // Tu contraseña de red WiFi

// --- Configuración MQTT ---
const char* mqtt_server = "broker.hivemq.com"; // Puedes usar un broker público o tu propio servidor Mosquitto
const int mqtt_port = 1883;
const char* mqtt_user = ""; // Si tu broker requiere usuario/contraseña
const char* mqtt_password = ""; // Si tu broker requiere usuario/contraseña
const char* clientID = "ESP32CultivoVerticalClient"; // ID único para tu ESP32

// --- Configuración de Sensores ---
#define DHTPIN 4     // Pin digital donde está conectado el sensor DHT
#define DHTTYPE DHT22 // O DHT11, según tu sensor
#define LDR_PIN 34   // Pin analógico donde está conectado el LDR

DHT dht(DHTPIN, DHTTYPE);

WiFiClient espClient;
PubSubClient client(espClient);

long lastMsg = 0;
char msg[50];
int value = 0;

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());
}

void reconnect_mqtt() {
  while (!client.connected()) {
    Serial.print("Intentando conexión MQTT...");
    // Intenta conectar
    if (client.connect(clientID, mqtt_user, mqtt_password)) {
      Serial.println("conectado");
      // Suscribirse a algún tema si es necesario
      // client.subscribe("cultivo/comandos");
    } else {
      Serial.print("falló, rc=");
      Serial.print(client.state());
      Serial.println(" reintentando en 5 segundos");
      // Espera 5 segundos antes de reintentar
      delay(5000);
    }
  }
}

void callback(char* topic, byte* payload, unsigned int length) {
  // Función para manejar mensajes MQTT entrantes, si te suscribes a algún tema
  Serial.print("Mensaje recibido [ ");
  Serial.print(topic);
  Serial.print(" ]: ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

void setup() {
  Serial.begin(115200);
  dht.begin();
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

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

  long now = millis();
  if (now - lastMsg > 30000) { // Envía datos cada 30 segundos
    lastMsg = now;

    // Lectura del sensor DHT
    float h = dht.readHumidity();
    float t = dht.readTemperature();

    // Comprobar si hay errores al leer el DHT
    if (isnan(h) || isnan(t)) {
      Serial.println("Error al leer del sensor DHT!");
    } else {
      Serial.print("Humedad: ");
      Serial.print(h);
      Serial.print(" %	 Temperatura: ");
      Serial.print(t);
      Serial.println(" *C");

      // Publicar temperatura
      dtostrf(t, 4, 2, msg);
      Serial.print("Publicando temperatura: ");
      Serial.println(msg);
      client.publish("cultivo/temperatura", msg);

      // Publicar humedad
      dtostrf(h, 4, 2, msg);
      Serial.print("Publicando humedad: ");
      Serial.println(msg);
      client.publish("cultivo/humedad", msg);
    }

    // Lectura del sensor LDR
    int ldrValue = analogRead(LDR_PIN);
    Serial.print("Valor LDR: ");
    Serial.println(ldrValue);
    dtostrf(ldrValue, 4, 0, msg);
    client.publish("cultivo/luz", msg);
    Serial.print("Publicando luz: ");
    Serial.println(msg);
  }
}

Explicación del Código 📖

1. Librerías: Incluimos WiFi.h para la conectividad inalámbrica, PubSubClient.h para MQTT y DHT.h y Adafruit_Sensor.h para el sensor de temperatura y humedad.
2. Configuración: Define tu SSID, contraseña de WiFi, dirección del broker MQTT y pines de los sensores.
3. setup_wifi(): Conecta el ESP32 a tu red WiFi.
4. reconnect_mqtt(): Establece y mantiene la conexión con el broker MQTT. Si se pierde la conexión, intenta reconectar automáticamente.
5. loop(): Es la función principal que se ejecuta repetidamente.
   • Verifica y reconecta MQTT si es necesario.
   • Lee la temperatura y humedad del sensor DHT. Maneja posibles errores de lectura.
   • Lee el valor analógico del LDR, que representa la intensidad de la luz.
   • Publica estos valores en temas MQTT específicos (cultivo/temperatura, cultivo/humedad, cultivo/luz). El dtostrf convierte el float a char array para la publicación.
   • El if (now - lastMsg > 30000) asegura que los datos se envíen cada 30 segundos, evitando una saturación excesiva de datos.

---

☁️ Configuración del Broker MQTT (HiveMQ o Mosquitto)

Para recibir los datos del ESP32, necesitas un broker MQTT. Hay varias opciones:

Opción 1: Broker Público (para pruebas rápidas)

Puedes usar brokers públicos como broker.hivemq.com o mqtt.eclipseprojects.io. Son útiles para probar, pero no se recomiendan para proyectos productivos debido a la falta de seguridad y privacidad.

Opción 2: Tu propio Mosquitto (recomendado para producción)

Instalar Mosquitto en una Raspberry Pi o en un servidor VPS te da control total. Aquí tienes un ejemplo rápido de instalación en sistemas basados en Debian:

sudo apt update
sudo apt install mosquitto mosquitto-clients
sudo systemctl enable mosquitto
sudo systemctl start mosquitto

Luego, puedes configurar usuarios y contraseñas para mayor seguridad, pero eso está fuera del alcance de este tutorial.

---

📊 Almacenamiento y Visualización de Datos con InfluxDB y Grafana

Para almacenar y visualizar nuestros datos de manera efectiva, utilizaremos la combinación de InfluxDB (base de datos de series temporales) y Grafana (plataforma de visualización).

1. Instalación de InfluxDB

InfluxDB es una base de datos optimizada para datos de series temporales, ideal para almacenar lecturas de sensores.

En Linux (ej. Ubuntu/Debian):

wget -qO- https://repos.influxdata.com/influxdb.key | sudo gpg --dearmor | sudo tee /etc/apt/keyrings/influxdata.gpg > /dev/null
echo "deb [signed-by=/etc/apt/keyrings/influxdata.gpg] https://repos.influxdata.com/debian stable main" | sudo tee /etc/apt/sources.list.d/influxdata.list
sudo apt update
sudo apt install influxdb
sudo systemctl enable --now influxdb

Después de la instalación, puedes crear una base de datos y un usuario. Para InfluxDB 1.x, puedes usar la CLI:

influx
CREATE DATABASE cultivo_vertical
CREATE USER admin WITH PASSWORD 'tu_password_segura' WITH ALL PRIVILEGES

2. Instalación de Telegraf (MQTT a InfluxDB)

Telegraf es un agente para recolectar, procesar, agregar y escribir métricas. Lo usaremos para suscribirnos a los temas MQTT y enviar los datos a InfluxDB.

En Linux (ej. Ubuntu/Debian):

sudo apt install telegraf

Ahora, necesitamos configurar Telegraf. Edita el archivo de configuración: sudo nano /etc/telegraf/telegraf.conf

Descomenta y configura las secciones [[inputs.mqtt_consumer]] y [[outputs.influxdb]].

Ejemplo de configuración para [[inputs.mqtt_consumer]]:

[[inputs.mqtt_consumer]]
  servers = ["tcp://localhost:1883"] # O la IP de tu broker MQTT
  topics = [
    "cultivo/temperatura",
    "cultivo/humedad",
    "cultivo/luz"
  ]
  data_format = "value"
  data_type = "FLOAT"
  name_override = "cultivo_data"

  # Si tu broker requiere autenticación:
  # username = "tu_usuario_mqtt"
  # password = "tu_password_mqtt"

Ejemplo de configuración para [[outputs.influxdb]]:

[[outputs.influxdb]]
  urls = ["http://localhost:8086"]
  database = "cultivo_vertical"
  # Si tu InfluxDB requiere autenticación:
  # username = "admin"
  # password = "tu_password_segura"

Reinicia Telegraf para aplicar los cambios:

sudo systemctl restart telegraf

3. Instalación de Grafana

Grafana es una herramienta de código abierto para la visualización y análisis de métricas. Es perfecta para crear dashboards interactivos con los datos de nuestros sensores.

En Linux (ej. Ubuntu/Debian):

sudo apt-get install -y apt-transport-https software-properties-common wget
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install grafana
sudo systemctl enable --now grafana-server

Grafana se ejecutará en el puerto 3000 por defecto. Abre tu navegador y ve a http://localhost:3000 (reemplaza localhost con la IP de tu servidor si es necesario). Las credenciales predeterminadas son admin/admin (se te pedirá cambiarlas).

4. Configuración del Dashboard en Grafana ✨

Una vez que Grafana esté funcionando, sigue estos pasos para crear tu dashboard:

1. Añadir Fuente de Datos:

   • Haz clic en el icono de engranaje (Configuración) en el menú lateral.
   • Selecciona Data Sources > Add data source.
   • Elige InfluxDB.
   • Configura:
     • Name: Cultivo Vertical DB (o el que prefieras)
     • URL: http://localhost:8086 (o la IP de tu servidor InfluxDB)
     • Database: cultivo_vertical
     • User: admin (si creaste uno)
     • Password: tu_password_segura (si creaste uno)
   • Haz clic en Save & Test.

2. Crear un Nuevo Dashboard:

   • Haz clic en el icono + en el menú lateral > Dashboard.
   • Haz clic en Add new panel.

3. Configurar Paneles (Gráficos):

   • En la pestaña Query, selecciona Cultivo Vertical DB como tu fuente de datos.
   • Para Temperatura:
     • FROM default.cultivo_data (o el name_override que usaste en Telegraf)
     • SELECT mean("value")
     • WHERE "_field" = 'cultivo_temperatura'
     • GROUP BY time($__interval)
     • En Visualization, elige Graph.
     • En Panel options (a la derecha), puedes personalizar el título (e.g., "Temperatura Actual"), unidades (°C), etc.
   • Para Humedad: Repite el proceso, cambiando WHERE "_field" = 'cultivo_humedad'.
   • Para Luz: Repite el proceso, cambiando WHERE "_field" = 'cultivo_luz'.
     • Considera que los valores LDR son brutos; podrías necesitar una calibración o transformación para que sean más significativos (ej. "Oscuro", "Poca luz", "Mucha luz").

4. Ajustar Rango de Tiempo y Guardar:

   • Usa el selector de tiempo en la parte superior derecha para definir el rango de datos a mostrar (ej. Last 6 hours).
   • Haz clic en el icono de disquete (Guardar) en la parte superior del dashboard para guardarlo. Dale un nombre, ej. "Monitoreo Cultivo Vertical".

---

📈 Optimización y Mejoras Futuras

Este tutorial te ha proporcionado una base sólida para el monitoreo de tus cultivos verticales. Sin embargo, hay muchas maneras de expandir y mejorar este sistema:

• Actuadores: Integra relés para controlar bombas de riego, ventiladores o luces LED basándose en umbrales definidos en Grafana o directamente en el ESP32.
• Sensores adicionales: Añade sensores de nivel de agua en depósitos, pH, conductividad eléctrica (EC) para soluciones nutritivas, o un sensor de CO2.
• Alertas: Configura alertas en Grafana para recibir notificaciones (email, Telegram, etc.) cuando un valor del sensor exceda ciertos límites.
• Batería y Paneles Solares: Haz el sistema autónomo con energía solar si tu cultivo vertical está en el exterior o en un lugar sin acceso fácil a la red eléctrica.
• OTA (Over-The-Air) Updates: Habilita las actualizaciones de firmware inalámbricas para el ESP32, facilitando el mantenimiento y las mejoras del código sin necesidad de cables.
• Contenedores (Docker): Para una configuración más limpia y portátil de InfluxDB, Telegraf y Grafana, considera usar Docker Compose.

¿Cómo configurar alertas en Grafana? (Ejemplo básico)

1. En tu panel de temperatura, haz clic en Edit.
2. Ve a la pestaña Alert.
3. Haz clic en Create Alert.
4. Define las condiciones (ej. WHEN avg() OF query(A, 5m, now) IS ABOVE 30).
5. Configura un Notification Channel (ej. Email) en Alerting > Notification Channels en la configuración de Grafana, y luego selecciónalo aquí.
6. Guarda la alerta y el dashboard.

Consideraciones de Energía 🔋

El ESP32 es relativamente eficiente, pero el uso continuo de Wi-Fi consume energía. Para aplicaciones de bajo consumo, considera:

• Modo Deep Sleep: El ESP32 puede entrar en un modo de muy bajo consumo y despertar periódicamente para tomar lecturas y enviar datos.
• Frecuencia de muestreo: Reduce la frecuencia con la que envías datos si no necesitas actualizaciones en tiempo real cada pocos segundos.

---

✅ Conclusión

¡Felicidades! Has construido un sistema de monitoreo IoT robusto y profesional para tus cultivos verticales. Ahora tienes la capacidad de:</n

• Leer temperatura, humedad y luz ambiente con sensores.
• Enviar estos datos de forma inalámbrica a un broker MQTT.
• Almacenar y procesar los datos con Telegraf e InfluxDB.
• Visualizar tus datos en un dashboard interactivo de Grafana.

Este proyecto es un excelente punto de partida para adentrarte en el mundo de la agricultura inteligente y el IoT, y te proporcionará información valiosa para optimizar el crecimiento de tus plantas. ¡Experimenta, aprende y haz crecer tus conocimientos junto con tus cultivos! 🧑‍🌾 🌱