Guardian del Jardín: Monitoreo Inteligente de Cultivos con Sensores de Suelo y ESP32

🚀 Introducción al Monitoreo Inteligente de Cultivos con IoT

En la era actual, la tecnología del Internet de las Cosas (IoT) ha trascendido más allá de los hogares inteligentes, incursionando profundamente en el ámbito de la agricultura y la jardinería. El monitoreo inteligente de cultivos es una aplicación fascinante que permite a los entusiastas de la jardinería y a los agricultores urbanos mantener un control exhaustivo sobre las condiciones de sus plantas, optimizando su crecimiento y reduciendo el desperdicio de recursos como el agua. Imagina saber exactamente cuándo tus plantas necesitan agua, sin tener que adivinar o depender de una rutina fija. Este es el poder que te ofrece el IoT.

Tradicionalmente, el cuidado de las plantas se basa en la observación visual y la experiencia. Si bien esto funciona, a menudo resulta en un riego excesivo o insuficiente, lo que puede estresar a las plantas y afectar su desarrollo. Con un sistema de monitoreo inteligente, podemos obtener datos precisos y en tiempo real sobre las condiciones del suelo, como la humedad y la temperatura, permitiéndonos tomar decisiones informadas y proactivas.

Este tutorial te llevará de la mano a través del proceso de construcción de un Guardian del Jardín: un sistema de monitoreo inteligente de cultivos utilizando un microcontrolador ESP32 y sensores de suelo. Aprenderás a configurar el hardware, programar el ESP32 para leer los datos de los sensores y enviar esta información a una plataforma IoT en la nube para su visualización y análisis.

🎯 ¿Por Qué Monitorear el Suelo con IoT?

La importancia de monitorear el suelo no puede subestimarse. El suelo es el fundamento de la vida vegetal, y sus propiedades influyen directamente en la salud y el rendimiento de los cultivos. Aquí te presentamos algunas razones clave para implementar un sistema de monitoreo IoT:

• Eficiencia en el Riego: Evita el riego excesivo, que puede llevar a enfermedades fúngicas y al lavado de nutrientes, y el riego insuficiente, que causa estrés hídrico. El monitoreo preciso de la humedad del suelo asegura que tus plantas reciban la cantidad exacta de agua cuando la necesitan.
• Optimización de Nutrientes: Al entender la dinámica del suelo, puedes aplicar fertilizantes de manera más efectiva, reduciendo el desperdicio y la contaminación.
• Detección Temprana de Problemas: Las variaciones anómalas en la temperatura o humedad del suelo pueden ser indicadores tempranos de plagas, enfermedades o problemas de drenaje, permitiéndote actuar antes de que la situación empeore.
• Análisis de Datos Históricos: Las plataformas IoT te permiten almacenar datos a lo largo del tiempo. Este historial es invaluable para identificar patrones, comprender cómo las diferentes condiciones climáticas afectan tus plantas y mejorar tus prácticas de jardinería en futuras temporadas.
• Automatización Potencial: Una vez que tienes los datos, puedes integrar actuadores (como válvulas de riego) para automatizar el riego basándose en las necesidades reales de tus plantas, creando un sistema verdaderamente autónomo.

🛠️ Materiales Necesarios

Para construir tu Guardian del Jardín, necesitarás los siguientes componentes. Asegúrate de tenerlos a mano antes de comenzar con el ensamblaje.

🔌 Diagrama de Conexiones

La fase de conexión es crucial para el correcto funcionamiento de nuestro sistema. Presta mucha atención a cada pin para evitar errores que puedan dañar los componentes. Aquí te presento un esquema general para la conexión de los sensores al ESP32. Si utilizas el ADS1115, las conexiones se simplifican aún más para el ESP32.

Conexión Directa del Sensor de Humedad Capacitivo al ESP32

El sensor de humedad capacitivo usualmente tiene tres pines: VCC, GND y OUT (o A0). El pin OUT es una salida analógica que leeremos con el ADC del ESP32.

• Sensor VCC a ESP32 3V3 (o 5V si tu sensor lo soporta, verifica su datasheet).
• Sensor GND a ESP32 GND.
• Sensor OUT (A0) a ESP32 Pin GPIO34 (o cualquier otro pin ADC disponible, como GPIO35, GPIO32, GPIO33). Los pines GPIO 34, 35, 36 y 39 son solo de entrada analógica en el ESP32.

Conexión del Sensor de Temperatura NTC al ESP32

Un termistor NTC requiere un divisor de voltaje para leer su resistencia. Si usas un sensor DS18B20, este es digital y se conecta a un solo pin de datos con una resistencia pull-up.

Para un NTC (Termistor):

1. Conecta una Resistencia de 10k Ohmios entre ESP32 3V3 y el Pin GPIO36 (o cualquier otro pin ADC). Esta es la resistencia fija del divisor.
2. Conecta un extremo del NTC al ESP32 GND.
3. Conecta el otro extremo del NTC al mismo Pin GPIO36 donde conectaste la resistencia fija. La lectura analógica en GPIO36 te dará el voltaje en el punto medio del divisor, que varía con la resistencia del NTC (y, por tanto, con la temperatura).

Para un DS18B20 (Recomendado por su facilidad):

1. DS18B20 VCC a ESP32 3V3.
2. DS18B20 GND a ESP32 GND.
3. DS18B20 DATA a ESP32 Pin GPIO14 (o cualquier otro pin digital disponible).
4. Conecta una Resistencia Pull-up de 4.7k Ohmios entre DS18B20 DATA y ESP32 3V3.

Conexión del Módulo ADS1115 (Opcional, para Mayor Precisión/Más Entradas)

El ADS1115 se comunica a través de I2C, lo que simplifica las conexiones al ESP32 y ofrece una mayor resolución (16 bits) en comparación con el ADC interno del ESP32 (12 bits, pero con algunas no linealidades).

• ADS1115 VCC a ESP32 3V3.
• ADS1115 GND a ESP32 GND.
• ADS1115 SDA a ESP32 SDA (GPIO21).
• ADS1115 SCL a ESP32 SCL (GPIO22).
• Sensores OUT (A0) a las entradas analógicas del ADS1115 (A0, A1, A2, A3).

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

Antes de programar el ESP32, necesitas configurar tu entorno de desarrollo. Utilizaremos el IDE de Arduino debido a su popularidad y facilidad de uso con el ESP32.

1. Instalar el IDE de Arduino

Si aún no lo tienes, descarga e instala el IDE de Arduino desde la página oficial.

2. Añadir Soporte para ESP32

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

3. Instalar Librerías Necesarias

Dependiendo de los sensores que uses, necesitarás instalar las siguientes librerías a través del Gestor de Librerías ( Sketch > Incluir Librería > Gestionar Librerías...):

• Para DS18B20:
  • DallasTemperature
  • OneWire
• Para ADS1115:
  • Adafruit ADS1115
  • Adafruit Unified Sensor

☁️ Configuración de la Plataforma IoT (ThingSpeak)

Para visualizar los datos de nuestros sensores en tiempo real, utilizaremos ThingSpeak. Es una plataforma IoT gratuita y fácil de usar que te permite recopilar, almacenar y visualizar datos de sensores.

1. Crear una Cuenta en ThingSpeak

1. Ve a ThingSpeak.com.
2. Haz clic en Sign Up y crea una cuenta gratuita de MathWorks. Necesitarás una dirección de correo electrónico.

2. Crear un Nuevo Canal

1. Una vez iniciada la sesión, haz clic en New Channel.
2. Name: Ponle un nombre descriptivo, por ejemplo, Guardian del Jardin.
3. Description: Una breve descripción, como Monitoreo de humedad y temperatura del suelo.
4. Field 1: Marca y nómbralo Humedad del Suelo (%).
5. Field 2: Marca y nómbralo Temperatura del Suelo (C).
6. Puedes añadir más campos si planeas usar más sensores (ej: luz, pH).
7. Haz clic en Save Channel.

3. Obtener Claves API

1. Una vez creado el canal, ve a la pestaña API Keys.
2. Necesitarás la Write API Key. Cópiala y guárdala en un lugar seguro. La usaremos en nuestro código.

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

Aquí viene la parte emocionante: programar el ESP32 para que lea los sensores y envíe los datos a ThingSpeak. El código se divide en varias secciones: configuración de Wi-Fi, lectura de sensores y envío de datos.

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

// Librerías para DS18B20 (si lo usas)
#include <OneWire.h>
#include <DallasTemperature.h>

// Librerías para ADS1115 (si lo usas)
#include <Adafruit_ADS1X15.h>

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

// --- Configuración ThingSpeak ---
const char* thingSpeakHost = "api.thingspeak.com";
const String writeAPIKey = "TU_WRITE_API_KEY"; // Reemplaza con tu Write API Key de ThingSpeak
unsigned long lastSendTime = 0;
const long sendInterval = 60000; // Intervalo de envío en milisegundos (ej: 60000 = 1 minuto)

// --- Configuración de Pines y Sensores ---
// Sensor de Humedad Capacitivo (Conexión Directa al ESP32)
const int HUMEDAD_PIN = 34; // GPIO34 para lectura analógica
// Calibración para el sensor de humedad (valores a ajustar con pruebas)
const int AIR_VALUE = 4095; // Valor analógico cuando el sensor está en el aire (seco)
const int WATER_VALUE = 1600; // Valor analógico cuando el sensor está en el agua (húmedo)

// Sensor de Temperatura DS18B20 (si lo usas)
const int ONE_WIRE_BUS = 14;       // GPIO14 para el bus OneWire
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

// Módulo ADS1115 (si lo usas)
Adafruit_ADS1115 ads;  // Puedes especificar la dirección I2C si no es la por defecto 0x48: ads(0x49);
const int ADS_HUMEDAD_CHANNEL = 0; // Canal A0 del ADS1115 para humedad
// Calibración para el sensor de humedad con ADS1115 (valores a ajustar con pruebas)
const int ADS_AIR_VALUE = 26000; // Valor digital del ADS1115 en el aire (seco)
const int ADS_WATER_VALUE = 10000; // Valor digital del ADS1115 en el agua (húmedo)

void setup() {
  Serial.begin(115200);
  delay(100);

  // Inicializar DS18B20 (si lo usas)
  sensors.begin();

  // Inicializar ADS1115 (si lo usas)
  if (!ads.begin()) {
    Serial.println("Fallo al inicializar ADS. ¿Está conectado correctamente?");
    while (1);
  }
  // Puedes configurar el ganancia para el ADS1115 (PGA)
  // ads.setGain(GAIN_TWO); // +/- 2.048V, 1 bit = 0.0625mV (default)

  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() {
  if (millis() - lastSendTime > sendInterval) {
    float humidityPercentage = 0;
    float soilTemperatureC = 0;

    // --- Lectura del Sensor de Humedad (Directo ESP32) ---
    // int sensorValue = analogRead(HUMEDAD_PIN);
    // Serial.print("Humedad analógica (ESP32): ");
    // Serial.println(sensorValue);
    // humidityPercentage = map(sensorValue, AIR_VALUE, WATER_VALUE, 0, 100);
    // humidityPercentage = constrain(humidityPercentage, 0, 100);

    // --- Lectura del Sensor de Humedad (Con ADS1115) ---
    int16_t adc0; // Guardamos el valor en un entero de 16 bits
    adc0 = ads.readADC_SingleEnded(ADS_HUMEDAD_CHANNEL);
    Serial.print("Humedad analógica (ADS1115): ");
    Serial.println(adc0);
    humidityPercentage = map(adc0, ADS_AIR_VALUE, ADS_WATER_VALUE, 0, 100);
    humidityPercentage = constrain(humidityPercentage, 0, 100);

    // --- Lectura del Sensor de Temperatura (DS18B20) ---
    sensors.requestTemperatures(); // Envía el comando para leer temperaturas
    soilTemperatureC = sensors.getTempCByIndex(0); // Obtiene la temperatura en Celsius del primer sensor
    
    Serial.print("Humedad del suelo: ");
    Serial.print(humidityPercentage);
    Serial.println(" %");
    Serial.print("Temperatura del suelo: ");
    Serial.print(soilTemperatureC);
    Serial.println(" °C");

    // --- Envío de Datos a ThingSpeak ---
    if (WiFi.status() == WL_CONNECTED) {
      HTTPClient http;
      String thingSpeakURL = "http://" + String(thingSpeakHost) + "/update?api_key=" + writeAPIKey +
                             "&field1=" + String(humidityPercentage, 2) + // 2 decimales
                             "&field2=" + String(soilTemperatureC, 2); // 2 decimales

      Serial.print("Enviando a ThingSpeak: ");
      Serial.println(thingSpeakURL);

      http.begin(thingSpeakURL);
      int httpResponseCode = http.GET();

      if (httpResponseCode > 0) {
        Serial.print("Código de respuesta HTTP: ");
        Serial.println(httpResponseCode);
        String payload = http.getString();
        Serial.println(payload);
      } else {
        Serial.print("Error en la solicitud HTTP: ");
        Serial.println(httpResponseCode);
      }
      http.end();
    } else {
      Serial.println("WiFi desconectado. Reintentando conexión...");
      WiFi.begin(ssid, password);
      int maxRetries = 10; // Intentar reconectar 10 veces
      while (WiFi.status() != WL_CONNECTED && maxRetries > 0) {
        delay(500);
        Serial.print(".");
        maxRetries--;
      }
      if (WiFi.status() == WL_CONNECTED) {
        Serial.println("\nWiFi reconectado.");
      } else {
        Serial.println("\nNo se pudo reconectar al WiFi.");
      }
    }
    lastSendTime = millis();
  }
  delay(100); // Pequeño delay para no saturar el loop
}

Explicación del Código

1. Librerías: Incluimos las librerías necesarias para Wi-Fi, HTTPClient, OneWire, DallasTemperature y Adafruit ADS1115.
2. Configuración de WiFi y ThingSpeak: Define tu ssid, password y la writeAPIKey de ThingSpeak. El sendInterval controla cada cuánto tiempo se envían los datos (60 segundos en este ejemplo).
3. Configuración de Pines y Sensores: Define los pines a los que están conectados tus sensores. Se incluyen secciones comentadas para la lectura directa del ADC del ESP32 y la lectura a través del ADS1115. Descomenta la sección que corresponda a tu hardware.
4. Calibración del Sensor de Humedad: Los valores AIR_VALUE y WATER_VALUE son cruciales para convertir la lectura analógica del sensor a un porcentaje de humedad. Necesitarás ajustar estos valores mediante pruebas:
   • Coloca el sensor en el aire (seco) y anota la lectura analógica.
   • Introduce el sensor en un vaso de agua y anota la lectura analógica.
   • Estos serán tus valores AIR_VALUE y WATER_VALUE respectivamente. El map() se encarga de escalar estos valores a un rango de 0-100%.
5. Función setup(): Inicializa la comunicación serie, los sensores (DS18B20, ADS1115) y se conecta a la red Wi-Fi.
6. Función loop():
   • Verifica si ha pasado el sendInterval para enviar nuevos datos.
   • Lee los valores del sensor de humedad (directamente del ESP32 o vía ADS1115) y los convierte a porcentaje.
   • Lee la temperatura del sensor DS18B20.
   • Construye la URL para ThingSpeak con los datos de los campos 1 y 2.
   • Utiliza HTTPClient para enviar una solicitud GET a ThingSpeak. La plataforma ThingSpeak almacenará y visualizará estos datos.
   • Incluye lógica de reconexión Wi-Fi si la conexión se pierde.

🔄 Despliegue y Pruebas

Una vez que hayas cargado el código en tu ESP32, es hora de poner a prueba tu Guardian del Jardín.

1. Conectar y Alimentar

1. Desconecta el ESP32 del ordenador (si ya has terminado de cargar el código).
2. Conecta tu sistema a una fuente de alimentación de 5V (como un cargador de móvil) utilizando el cable Micro USB.
3. Coloca el sensor de humedad y el de temperatura en la tierra de tu planta o cultivo, asegurándote de que la parte electrónica del sensor de humedad esté fuera del suelo para evitar daños por la humedad. Idealmente, solo la sonda debería estar enterrada.

2. Monitorizar el Serial

Si el ESP32 está conectado a tu ordenador, abre el Monitor Serie en el IDE de Arduino (asegúrate de que la velocidad de baudios sea 115200). Deberías ver mensajes de conexión Wi-Fi, lecturas de sensores y el estado de los envíos a ThingSpeak.

3. Verificar ThingSpeak

1. Inicia sesión en tu cuenta de ThingSpeak.
2. Ve a tu canal Guardian del Jardin.
3. Haz clic en la pestaña Private View (o Public View si lo hiciste público).
4. Deberías empezar a ver gráficos con los datos de humedad y temperatura actualizándose cada minuto (o según tu sendInterval).

✨ Mejoras y Próximos Pasos

¡Felicidades! Has construido un sistema de monitoreo inteligente. Pero esto es solo el principio. Aquí hay algunas ideas para llevar tu Guardian del Jardín al siguiente nivel:

1. Integración con Riego Automático 💧

• Añade una electroválvula de 5V o 12V y un módulo relé para controlar el riego automáticamente. Cuando la humedad del suelo caiga por debajo de un umbral, el ESP32 puede activar la electroválvula para regar, y desactivarla cuando la humedad alcance un nivel óptimo.
• Considera una bomba de agua pequeña si no tienes acceso a una toma de agua presurizada.

2. Notificaciones y Alarmas 🔔

• Configura ThingSpeak para enviar notificaciones por correo electrónico o SMS cuando los valores de los sensores crucen umbrales específicos (ej: humedad muy baja, temperatura muy alta).
• Integra con plataformas como IFTTT (If This Then That) para enviar notificaciones a tu teléfono o incluso a servicios de mensajería como Telegram.

3. Más Sensores 🌿

• Sensor de Luz (LDR o BH1750): Monitorea la intensidad de luz para asegurar que tus plantas reciban la cantidad adecuada.
• Sensor de pH del Suelo: Crucial para muchos cultivos, ya que el pH afecta la disponibilidad de nutrientes.
• Sensor de NPK: Permite medir los niveles de Nitrógeno, Fósforo y Potasio, los macronutrientes esenciales.
• Sensor de Conductividad Eléctrica (EC): Mide la salinidad del suelo, importante para cultivos hidropónicos o para detectar problemas de exceso de fertilizantes.

4. Batería y Energía Solar ☀️

• Si tu sistema está en un lugar sin acceso a la corriente, considera alimentarlo con una batería LiPo y un módulo de carga solar.
• Optimiza el consumo de energía del ESP32 utilizando los modos Deep Sleep para prolongar la vida útil de la batería. El ESP32 puede despertar, tomar lecturas, enviar datos y volver a dormir.

5. Otra Plataforma IoT 📊

• Explora alternativas a ThingSpeak como Grafana (con InfluxDB), Ubidots, Adafruit IO o Home Assistant. Estas plataformas ofrecen mayor flexibilidad en la visualización, automatización y personalización de dashboards.

❓ Preguntas Frecuentes (FAQ)

conclusión 🌱

Has llegado al final de este tutorial y ahora posees el conocimiento y las herramientas para construir tu propio sistema de monitoreo inteligente de cultivos. El Guardian del Jardín no es solo un proyecto de electrónica; es una puerta de entrada a la agricultura de precisión a pequeña escala, que te permite cuidar tus plantas de manera más eficiente y efectiva. Al entender las necesidades de tus plantas a través de datos objetivos, no solo mejorarás su salud y rendimiento, sino que también contribuirás a un uso más sostenible de los recursos.

La versatilidad del ESP32 y la facilidad de uso de plataformas como ThingSpeak hacen que el IoT sea accesible para todos, desde el aficionado a la electrónica hasta el jardinero apasionado. Esperamos que este tutorial te inspire a explorar aún más las posibilidades del IoT en tu entorno, ya sea para expandir este proyecto con más sensores y automatización, o para idear nuevas soluciones inteligentes para otros aspectos de tu vida. ¡Feliz jardinería inteligente!