Sistema IoT de Monitoreo de Colmenas para Apicultura Inteligente con ESP32

🐝 Introducción a la Apicultura Inteligente con IoT

La apicultura es una actividad milenaria, pero, al igual que muchas otras, puede beneficiarse enormemente de la tecnología moderna. El monitoreo manual de colmenas consume tiempo, es intrusivo para las abejas y a menudo se limita a inspecciones periódicas. Aquí es donde el Internet de las Cosas (IoT) entra en juego, permitiéndonos supervisar el estado de nuestras colmenas de forma remota y continua.

Un sistema IoT de monitoreo de colmenas nos ofrece datos en tiempo real sobre parámetros cruciales como la temperatura interna, la humedad y el peso. Esta información es vital para detectar problemas a tiempo, como la presencia de enfermedades, escasez de alimentos, enjambrazones inminentes o la necesidad de cosechar la miel. Al optimizar la gestión de las colmenas, no solo mejoramos la producción, sino que también contribuimos a la salud y bienestar de las colonias de abejas, cruciales para nuestro ecosistema.

Este tutorial te proporcionará las herramientas y conocimientos necesarios para construir tu propio sistema de monitoreo inteligente, utilizando el versátil microcontrolador ESP32 y una serie de sensores económicos y fáciles de integrar.

¿Por qué monitorear colmenas con IoT? 📊

La monitorización remota de colmenas ofrece múltiples ventajas:

• Prevención de enfermedades: Cambios bruscos en temperatura o humedad pueden indicar problemas de salud.
• Gestión de recursos: Saber el peso de la colmena ayuda a determinar la cantidad de miel almacenada y si necesitan alimentación suplementaria.
• Detección de enjambrazón: Una pérdida repentina de peso o un aumento de actividad pueden preceder a un enjambrazón.
• Optimización de la cosecha: Conocer el peso de la colmena permite cosechar en el momento óptimo.
• Reducción del estrés en las abejas: Menos inspecciones físicas significan menos interrupciones para la colonia.
• Alertas tempranas: Recibe notificaciones automáticas ante eventos anómalos.

---

🛠️ Materiales Necesarios

Para construir este proyecto, necesitarás los siguientes componentes. La mayoría de ellos son fácilmente accesibles y económicos.

Componente	Cantidad	Descripción	Enlace Sugerido (Ejemplo)
---	---	---	---
ESP32 DevKitC	1	Microcontrolador con Wi-Fi y Bluetooth integrado.	Ver en Amazon
Sensor de Temperatura y Humedad DHT22	1	Mide temperatura y humedad con buena precisión.	Ver en Amazon
---	---	---	---
Sensor de Peso (Celda de Carga HX711)	1	Celda de carga de 50kg o 100kg junto con el módulo HX711 para lectura.	Ver en Amazon
Celda de Carga	4	Celdas de carga individuales para el peso de la colmena. Se recomiendan de 50kg a 100kg cada una.	Ver en Amazon
---	---	---	---
Cable Jumper Macho-Hembra	1 pack	Para realizar las conexiones entre los componentes y el protoboard.	Ver en Amazon
Protoboard	1	Para ensamblar el circuito temporalmente.	Ver en Amazon
---	---	---	---
Cables eléctricos	Varios	Para conexiones más permanentes o largas.
Fuente de Alimentación de 5V	1	Para alimentar el ESP32 y los sensores. Puede ser un cargador USB.	Ver en Amazon
---	---	---	---
Resistencias (10k Ohm)	1	Opcional, para el DHT22 si no trae pull-up interno.	Ver en Amazon
Caja Estanca (IP65/IP67)	1	Para proteger la electrónica de las inclemencias del tiempo.	Ver en Amazon
---	---	---	---
Plataforma IoT (ej. Thingspeak, Blynk)	Cuenta	Para la visualización y almacenamiento de datos.	Thingspeak.com

---

⚙️ Diseño del Sistema y Arquitectura

Nuestro sistema se basará en una arquitectura sencilla pero robusta. El ESP32 será el cerebro, leyendo los datos de los sensores y enviándolos a una plataforma en la nube a través de Wi-Fi.

Diagrama de Bloques del Sistema

El flujo de datos será el siguiente:

1. Sensores: El DHT22 mide temperatura y humedad. Las celdas de carga, conectadas al módulo HX711, miden el peso.
2. ESP32: Recopila las lecturas de ambos sensores.
3. Conectividad: El ESP32 utiliza su módulo Wi-Fi para conectarse a una red local.
4. Nube IoT: Los datos son enviados periódicamente (ej. cada 15 minutos) a una plataforma IoT como ThingSpeak.
5. Visualización y Análisis: La plataforma IoT almacena los datos y los presenta en gráficos intuitivos, permitiendo al apicultor monitorear la colmena desde cualquier lugar a través de una aplicación web o móvil.

Ubicación Física de los Componentes

Para el sensor de temperatura y humedad, lo ideal es colocarlo dentro de la colmena, pero protegido de las abejas para evitar que lo cubran con propóleo o lo dañen. Una pequeña jaula ventilada o un compartimento separado pero con acceso al aire interno es lo más adecuado.

Las celdas de carga deben colocarse estratégicamente debajo de la base de la colmena. Se suelen usar cuatro celdas, una en cada esquina, conectadas a una placa sumadora para obtener una lectura total del peso. Es crucial que la colmena esté nivelada y que las celdas de carga soporten el peso máximo esperado de la colmena llena.

El ESP32 y el módulo HX711, junto con las conexiones, deben ir en una caja estanca fuera de la colmena, protegidos de la lluvia, el sol directo y la humedad. Esta caja debe permitir una buena recepción de la señal Wi-Fi.

---

🔌 Conexiones Eléctricas (Wiring)

Ahora vamos a conectar los componentes al ESP32. Presta atención a los pines y asegúrate de hacer las conexiones correctamente para evitar daños.

Conexión del Sensor DHT22

El DHT22 tiene 3 o 4 pines, dependiendo del módulo. Si tiene 4 pines, uno no se usa. Si tiene 3, son VCC, GND y Data.

• VCC (5V): Conecta al pin 3.3V del ESP32.
• GND: Conecta a GND del ESP32.
• DATA: Conecta al pin GPIO23 del ESP32. (Puedes usar otro GPIO, pero recuerda ajustarlo en el código).

Conexión del Módulo HX711 y Celdas de Carga

Las celdas de carga suelen tener 4 cables: Rojo (Excitation+), Negro (Excitation-), Blanco (Signal-) y Verde (Signal+). Debes conectar las 4 celdas de carga en una configuración de puente de Wheatstone para sumarlas, usando una placa sumadora o soldando los cables directamente. Para este tutorial, asumiremos que tienes una placa sumadora para 4 celdas o que estás usando una única celda de carga grande.

El módulo HX711 tiene 6 pines:

• VCC: Conecta al pin 5V del ESP32.
• GND: Conecta a GND del ESP32.
• DT (Data): Conecta al pin GPIO18 del ESP32.
• SCK (Clock): Conecta al pin GPIO19 del ESP32.
• E+ / E-: Conectan a la salida de excitación de la celda de carga.
• A+ / A-: Conectan a la salida de señal de la celda de carga.

Diagrama de Conexiones (Fritzing-like)

---

💻 Programación del ESP32 con Arduino IDE

Ahora que tenemos el hardware montado, es hora de programar el ESP32. Usaremos el entorno de desarrollo de Arduino IDE por su simplicidad y amplia comunidad.

1. Preparación del Arduino IDE

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

Luego, necesitas añadir el soporte para ESP32:

• Ve a Archivo > Preferencias.
• En URLs Adicionales de Gestores de Tarjetas, añade: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
• Ve a Herramientas > Placa > Gestor de Tarjetas....
• Busca "esp32" e instala la ESP32 by Espressif Systems.

2. Instalación de Librerías

Necesitarás las siguientes librerías. Ve a Herramientas > Gestionar Librerías... y busca e instala:

• DHT sensor library por Adafruit
• Adafruit Unified Sensor por Adafruit (requerida por la librería DHT)
• HX711 por Bogde
• WiFiClientSecure (generalmente viene preinstalada con el ESP32 core)

3. Código Fuente del ESP32

Este código leerá los sensores y enviará los datos a ThingSpeak. ThingSpeak es una plataforma IoT gratuita que permite almacenar y visualizar datos de sensores. Necesitarás crear una cuenta y un canal para este proyecto.

#include <WiFi.h>
#include <HTTPClient.h>
#include "DHT.h"
#include "HX711.h"

// Credenciales de tu red Wi-Fi
const char* ssid = "TU_SSID";
const char* password = "TU_PASSWORD";

// Configuración de ThingSpeak
const char* thingSpeakHost = "api.thingspeak.com";
const int thingSpeakPort = 80;
const char* apiKey = "TU_THINGSPEAK_API_KEY"; // API Key de escritura de tu canal
const int channelID = ID_CANAL_THINGSPEAK; // ID de tu canal ThingSpeak

// Pines para el sensor DHT22
#define DHTPIN 23       // Pin GPIO donde está conectado el sensor DHT22
#define DHTTYPE DHT22   // Tipo de sensor (DHT11, DHT22, DHT21)
DHT dht(DHTPIN, DHTTYPE);

// Pines para el módulo HX711
#define LOADCELL_DOUT_PIN 18 // DT
#define LOADCELL_SCK_PIN 19  // SCK
HX711 scale;

// Valor de calibración del sensor de peso
// Este valor se obtiene experimentalmente. Consulta la sección de calibración.
float calibration_factor = -400.0; // AJUSTAR ESTE VALOR

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

  Serial.println("Conectando a WiFi...");
  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());

  dht.begin();

  Serial.println("Iniciando sensor de peso HX711...");
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  scale.set_scale(calibration_factor); // Establece el factor de calibración
  scale.tare();                        // Pone el sensor a cero (tarar)
  Serial.println("Sensor de peso inicializado y tarado.");
  Serial.print("Lectura inicial (tarada): ");
  Serial.print(scale.get_units(5), 1);
  Serial.println(" kg");
}

void loop() {
  delay(5000); // Esperar 5 segundos entre lecturas locales (antes de enviar)

  // Leer sensor DHT22
  float h = dht.readHumidity();
  float t = dht.readTemperature(); // Leer temperatura en Celsius

  // Comprobar si hay errores al leer el DHT22
  if (isnan(h) || isnan(t)) {
    Serial.println("Error al leer del sensor DHT!");
    // Podemos continuar y enviar solo el peso si el DHT falla
    h = 0.0; // O un valor que indique error, o no enviar
    t = 0.0; // Lo mismo
  } else {
    Serial.print("Humedad: ");
    Serial.print(h);
    Serial.print(" %	Temperatura: ");
    Serial.print(t);
    Serial.print(" *C ");
  }

  // Leer sensor de peso HX711
  float weight = scale.get_units(10); // Lee el peso, promediando 10 lecturas
  if (weight < 0) { // A veces, la primera lectura puede ser negativa
      weight = 0.0; // Asegurarse de que no sea negativo si no hay peso
  }
  Serial.print("Peso: ");
  Serial.print(weight, 2); // 2 decimales
  Serial.println(" kg");

  // Enviar datos a ThingSpeak
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    String url = "http://";
    url += thingSpeakHost;
    url += "/update?api_key=";
    url += apiKey;
    url += "&field1="; // Campo 1 para Temperatura
    url += String(t);
    url += "&field2="; // Campo 2 para Humedad
    url += String(h);
    url += "&field3="; // Campo 3 para Peso
    url += String(weight);

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

    http.begin(url);
    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 no conectado, reintentando...");
    WiFi.begin(ssid, password);
    int retryCount = 0;
    while (WiFi.status() != WL_CONNECTED && retryCount < 20) {
        delay(500);
        Serial.print(".");
        retryCount++;
    }
    if (WiFi.status() == WL_CONNECTED) {
        Serial.println("\nWiFi reconectado.");
    } else {
        Serial.println("\nNo se pudo reconectar a WiFi.");
    }
  }

  // Intervalo de envío de datos a ThingSpeak (ej. cada 15 minutos = 900000 ms)
  // Ajusta este valor según la frecuencia de actualización que desees.
  delay(900000); // 15 minutos
}

4. Calibración del Sensor de Peso (HX711)

La calibración del HX711 es crucial para obtener lecturas de peso precisas. El calibration_factor es único para cada celda de carga y configuración.

Pasos para calibrar:

1. Carga el código: Sube el código anterior a tu ESP32. Asegúrate de tener los pines correctos configurados.
2. Abre el Monitor Serie: Conecta tu ESP32 al ordenador y abre el Monitor Serie en el Arduino IDE (velocidad 115200 baudios).
3. Tarar el sensor: Asegúrate de que no haya peso sobre las celdas de carga y llama a scale.tare(); en el setup(). Esto pone el valor actual a cero.
4. Coloca un peso conocido: Pon un objeto de peso conocido (ej. 1 kg, 5 kg) sobre las celdas de carga.
5. Obtén lecturas: Observa las lecturas del Monitor Serie. El valor que verás será el raw data sin el factor de calibración.
6. Calcula el factor de calibración: Ajusta calibration_factor en el código. Si tu sensor lee 1000 unidades para un objeto de 1 kg, y deseas que lea 1 kg, tu factor podría ser 1000 / 1 kg = 1000. Si el sensor da un valor negativo, invierte el signo del factor. Experimenta con diferentes valores hasta que las lecturas sean precisas.
   • 💡 Consejo: Usa el sketch de ejemplo "HX711_calibration.ino" de la librería HX711 para un proceso de calibración guiado.
7. Actualiza el código: Una vez que encuentres un calibration_factor que funcione bien, actualiza la línea float calibration_factor = -400.0; con tu valor.

---

☁️ Configuración de ThingSpeak

ThingSpeak es una plataforma IoT gratuita de MathWorks que te permite recopilar, visualizar y analizar datos de sensores en la nube. Es ideal para este proyecto.

1. Crear una Cuenta

Ve a https://thingspeak.com/ y crea una cuenta gratuita. Necesitarás una cuenta de MathWorks (la misma que para MATLAB, si ya tienes una).

2. Crear un Nuevo Canal

Una vez logueado:

• Haz clic en Channels > My Channels.
• Haz clic en New Channel.
• Rellena los siguientes campos:
  • Name: Monitoreo de Colmena
  • Description: Sistema de monitoreo de temperatura, humedad y peso de colmenas.
  • Field 1: Temperatura (°C) (Marca la casilla Enable)
  • Field 2: Humedad (%) (Marca la casilla Enable)
  • Field 3: Peso (kg) (Marca la casilla Enable)
• Haz clic en Save Channel.

3. Obtener la API Key de Escritura

• Después de crear el canal, ve a la pestaña API Keys de tu canal.
• Copia la Write API Key. Esta es la clave que deberás pegar en tu código del ESP32 (TU_THINGSPEAK_API_KEY).
• También toma nota del Channel ID (aparece en la URL de tu canal o en la pestaña Channel Settings). Esto también lo necesitarás en el código (ID_CANAL_THINGSPEAK).

Una vez que el ESP32 esté enviando datos, podrás ver los gráficos en la pestaña Private View de tu canal en ThingSpeak. Los datos se actualizarán con la frecuencia que hayas configurado en el delay() final del loop().

---

📦 Montaje Final y Protección

Con la electrónica y el software funcionando, el último paso es montar todo de forma duradera y protegerlo de los elementos y las abejas.

1. Preparación de la Caja Estanca

• Consigue una caja estanca (IP65 o IP67 es ideal) que sea lo suficientemente grande para albergar el ESP32, el módulo HX711 y las conexiones de cables.
• Taladra orificios pequeños y sellados (con pasacables o silicona) para los cables que irán a los sensores y a la fuente de alimentación.
• Monta el ESP32 y el HX711 dentro de la caja, preferiblemente sobre un pequeño protoboard permanente o una PCB perforada para evitar que las vibraciones o movimientos suelten las conexiones.

2. Instalación de las Celdas de Carga

• Diseña o adquiere una plataforma base donde se asentará la colmena. Esta plataforma deberá incorporar las 4 celdas de carga.
• Asegúrate de que las celdas de carga estén niveladas y que la colmena se distribuya uniformemente sobre ellas. Cualquier torsión o carga desigual afectará la precisión.
• Protege las celdas de carga y sus cables del agua y la suciedad. Puedes usar silicona o fundas protectoras.

3. Posicionamiento del Sensor DHT22

• Coloca el DHT22 dentro de la colmena en un área donde no estorbe a las abejas ni sea cubierto. Un compartimento pequeño y perforado que permita el flujo de aire pero proteja el sensor es lo ideal.
• Asegúrate de que los cables del DHT22 estén bien protegidos y sellados al salir de la colmena hacia la caja estanca.

4. Alimentación del Sistema

• Puedes usar un cargador USB estándar de 5V para alimentar el ESP32. Si tu ubicación tiene acceso a la red eléctrica, usa un adaptador de corriente adecuado.
• Para ubicaciones remotas sin electricidad, considera una solución con panel solar y batería. Esto requerirá un módulo de carga solar y una batería de litio (18650) o plomo-ácido, junto con un convertidor DC-DC para suministrar 5V al ESP32.

---

✅ Mantenimiento y Consideraciones Adicionales

Un sistema IoT, aunque robusto, requiere cierto mantenimiento y atención para funcionar de manera óptima a largo plazo.

Mantenimiento Periódico

• Limpieza de sensores: Ocasionalmente, revisa el DHT22 para asegurarte de que no esté obstruido por propóleo o suciedad.
• Verificación de conexiones: Inspecciona visualmente los cables y conexiones para asegurarte de que no haya corrosión, desgaste o desprendimiento.
• Estado de la batería (si aplica): Si usas alimentación por batería/panel solar, monitorea el rendimiento de la batería.
• Calibración del peso: Las celdas de carga pueden desviarse ligeramente con el tiempo. Es recomendable recalibrarlas anualmente o si notas lecturas inconsistentes.

Mejora de la Precisión del Peso

• Importante: El peso de la colmena fluctúa por la actividad de las abejas (salida/entrada) y las condiciones climáticas (humedad del aire). Para una medición más precisa de la miel, considera realizar la lectura en momentos de baja actividad o promediar los datos.
• Un factor de calibración dinámico o una función de filtrado en el código pueden ayudar a suavizar las lecturas.

Ampliación del Sistema

Este sistema es una base excelente y puede expandirse con otras funcionalidades:

• Detección de sonidos: Añade un micrófono para detectar el ruido de la colmena, lo que podría indicar la presencia de una reina, enjambrazón o problemas.
• Monitoreo de entrada/salida: Sensores IR o cámaras pequeñas para contar las abejas que entran y salen.
• GPS: Para rastrear colmenas en movimiento o prevenir robos.
• Notificaciones: Configura alertas en ThingSpeak o mediante servicios como IFTTT para recibir notificaciones por correo electrónico o SMS ante umbrales críticos (ej. peso bajo, temperatura alta).

¿Cómo puedo configurar alertas en ThingSpeak?

En tu canal de ThingSpeak, ve a la pestaña `Apps` y luego a `ThingSpeak React`. Puedes configurar un `React` para activar una acción cuando un campo del canal cumpla una condición (ej. "Si el campo 3 (Peso) es menor que X"). Luego, puedes configurar `ThingSpeak TalkBack` o `ThingSpeak Notifications` para enviar correos electrónicos o incluso twittear si se cumple la condición. También puedes integrar con servicios externos como IFTTT para más opciones de notificación.

---

🎯 Conclusión

Has construido con éxito un sistema IoT de monitoreo de colmenas. Esta herramienta no solo te ahorrará tiempo y esfuerzo, sino que también te proporcionará una visión profunda del estado de tus colonias de abejas, permitiéndote tomar decisiones más informadas y proactivas. La apicultura inteligente es un paso hacia una gestión más eficiente y sostenible, contribuyendo a la salud de nuestras abejas y al futuro de nuestro medio ambiente. ¡Felicitaciones por tu proyecto!