Monitoreo Inteligente de Consumo Eléctrico con ESP32 y Visualización en Dashboard IoT

💡 Introducción al Monitoreo de Consumo Eléctrico Inteligente

En la era de la conciencia energética y la sostenibilidad, monitorear el consumo eléctrico de nuestros hogares o negocios se ha vuelto crucial. Saber cuánta energía consumimos y cuándo la consumimos nos permite identificar picos de uso, detectar electrodomésticos "vampiro" y tomar decisiones informadas para ahorrar energía y reducir nuestra huella de carbono. Los sistemas de monitoreo inteligente, basados en el Internet de las Cosas (IoT), ofrecen una solución eficaz y accesible para este propósito.

Este tutorial te proporcionará las herramientas y el conocimiento para construir tu propio sistema de monitoreo de consumo eléctrico utilizando el potente microcontrolador ESP32. Visualizaremos los datos en tiempo real en un dashboard IoT, lo que te permitirá tener un control sin precedentes sobre tu energía.

🎯 Objetivos del Tutorial

Al finalizar este tutorial, serás capaz de:

• Entender los principios básicos del monitoreo de corriente alterna.
• Interconectar un sensor de corriente no invasivo (CT) con un ESP32.
• Programar el ESP32 para medir el consumo eléctrico (corriente, potencia).
• Enviar los datos de consumo a una plataforma IoT en la nube.
• Crear un dashboard personalizado para visualizar los datos en tiempo real.
• Interpretar los patrones de consumo energético.

🛠️ Materiales Necesarios

Para llevar a cabo este proyecto, necesitarás los siguientes componentes:

🔌 Fundamentos del Monitoreo de Corriente Alterna con Sensores CT

Los Transformadores de Corriente (CTs, por sus siglas en inglés Current Transformers) como el SCT-013-000 son dispositivos que permiten medir la corriente alterna que fluye a través de un conductor sin la necesidad de cortar el cable o interrumpir el circuito. Funcionan por inducción electromagnética:

1. El cable por el que fluye la corriente que queremos medir pasa a través del orificio del CT.
2. La corriente en ese cable (primario) induce una corriente proporcional en el devanado secundario del CT.
3. El CT tiene una relación de transformación (ej. 100A:50mA), lo que significa que 100A en el primario generarán 50mA en el secundario.
4. Al conectar una resistencia de carga conocida al secundario del CT, podemos convertir esa corriente inducida en un voltaje que puede ser medido por el ESP32.

Adaptación de Señal para el ESP32

El ESP32, como la mayoría de los microcontroladores, solo puede leer voltajes positivos (0V a 3.3V o 0V a 5V, dependiendo del modelo y la configuración del ADC). Sin embargo, la señal de un CT es una onda sinusoidal de corriente alterna (AC), lo que significa que su voltaje varía entre valores positivos y negativos.

Para que el ESP32 pueda leer esta señal, necesitamos dos cosas:

1. Resistencia de Carga (Burden Resistor): Convierte la corriente del CT en un voltaje.
2. Divisor de Voltaje con Sesgo DC (DC Bias): Desplaza la onda AC para que sea completamente positiva, centrando la señal alrededor de la mitad de la tensión de referencia del ADC del ESP32 (ej. 1.65V si la referencia es 3.3V).

🔩 Montaje del Hardware

Sigue estos pasos para conectar el sensor CT a tu ESP32:

1. Preparar el Circuito de Adaptación

1. En tu protoboard, crea el divisor de voltaje: Conecta dos resistores de 10 kOhm en serie entre el pin de 3.3V del ESP32 y GND. El punto medio de estos dos resistores será nuestro sesgo DC de 1.65V (asumiendo 3.3V de alimentación).
2. Conecta un condensador electrolítico de 10 uF (o cerámico) en paralelo con los dos resistores de 10 kOhm, desde el punto medio a GND. Esto ayudará a filtrar el ruido.

2. Conectar el Sensor CT (SCT-013-000)

1. El SCT-013-000 tiene un conector jack de 3.5mm. Puedes cortar el conector y pelar los cables, o usar un adaptador.
2. Conecta un extremo de la resistencia de carga (33 Ohm) a una de las salidas del sensor CT.
3. Conecta el otro extremo de la resistencia de carga al punto medio del divisor de voltaje (donde se unen los dos resistores de 10 kOhm y el condensador).
4. Conecta la otra salida del sensor CT directamente al punto medio del divisor de voltaje también. (Sí, ambas salidas del CT van al punto medio del divisor de voltaje a través de la resistencia de carga).

3. Conectar al ESP32

1. Conecta la señal del punto medio de la resistencia de carga (el punto que está conectado también al punto medio del divisor de voltaje) a un pin ADC del ESP32. Por ejemplo, el pin GPIO36 (ADC1_CH0) suele ser una buena opción.
2. Conecta el pin 3V3 del ESP32 a la línea positiva del divisor de voltaje (donde se conecta el primer resistor de 10k).
3. Conecta el pin GND del ESP32 a la línea negativa del divisor de voltaje y al GND del condensador.

Una vez que hayas montado el circuito en la protoboard, puedes usar la pinza del sensor SCT-013-000 para rodear uno de los cables de fase del circuito o electrodoméstico que deseas monitorear. Asegúrate de que solo un cable (fase o neutro, pero no ambos) pase por el centro del CT para una lectura correcta.

💻 Programación del ESP32 con Arduino IDE

Utilizaremos el entorno de desarrollo Arduino IDE por su facilidad de uso y la gran cantidad de librerías disponibles.

1. Configuración del Arduino IDE

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

1. Añadir soporte para ESP32:
   • Ve a Archivo > Preferencias.
   • En URLs adicionales para Gestores de Tarjetas, añade: 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 el paquete esp32 by Espressif Systems.
2. Seleccionar placa ESP32:
   • Ve a Herramientas > Placa y selecciona ESP32 Dev Module (o tu modelo específico de ESP32).
3. Instalar librerías: Necesitaremos la librería EmonLib para procesar las lecturas del CT y una librería para el protocolo de comunicación IoT (ej. PubSubClient para MQTT).
   • Ve a Programa > Incluir Librería > Gestionar Librerías....
   • Busca "EmonLib" e instala la librería EmonLib by OpenEnergyMonitor.
   • Busca "PubSubClient" e instala la librería PubSubClient by Nick O'Leary.

2. Código Fuente del ESP32

Este código leerá el sensor CT, calculará la potencia y enviará los datos a un broker MQTT. Para este ejemplo, usaremos un broker público o uno que tú mismo configures.

#include <WiFi.h>
#include <PubSubClient.h>
#include "EmonLib.h"

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

// --- Configuración MQTT ---
const char* mqtt_server = "broker.hivemq.com"; // Puedes usar otro broker público o privado
const int mqtt_port = 1883;
const char* mqtt_user = ""; // Si tu broker requiere usuario/contraseña, ponlos aquí
const char* mqtt_password = "";
const char* mqtt_client_id = "ESP32PowerMonitor";
const char* mqtt_topic_power = "casa/energia/potencia";
const char* mqtt_topic_current = "casa/energia/corriente";

WiFiClient espClient;
PubSubClient client(espClient);

EnergyMonitor emon;

// Pin ADC del ESP32 donde está conectado el sensor CT
const int CT_PIN = 36; // GPIO36 (ADC1_CH0)

// --- Calibración del Sensor CT ---
// Corriente nominal del CT / Corriente máxima que mide el ADC (ej. 100A / 0.050A = 2000)
// Para SCT-013-000 (100A/50mA) y Resistor de carga 33 Ohm -> 100A / ((3.3V / 33 Ohm) / 1.414) / 50mA 
// Un valor inicial de 60.606 para 33 Ohm de burden y 3.3V ADC. Ajustar empíricamente.
const double CT_CALIBRATION = 60.606; // Este valor puede requerir ajuste fino

// Voltaje de referencia de la red eléctrica (RMS)
const double AC_VOLTAGE_RMS = 230.0; // Cambiar a 120.0 si estás en América

// Intervalo de lectura y envío de datos (en milisegundos)
const long interval = 5000; // Cada 5 segundos
unsigned long previousMillis = 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.print("Dirección IP: ");
  Serial.println(WiFi.localIP());
}

void reconnect_mqtt() {
  while (!client.connected()) {
    Serial.print("Intentando conexión MQTT...");
    if (client.connect(mqtt_client_id, mqtt_user, mqtt_password)) {
      Serial.println("conectado");
    } else {
      Serial.print("falló, rc=");
      Serial.print(client.state());
      Serial.println(" reintentando en 5 segundos");
      delay(5000);
    }
  }
}

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

  // Inicializar EmonLib
  // El tercer parámetro es el número de muestras (por defecto 1480, ajusta si es necesario)
  // Se usa para calcular el promedio. Más muestras = más preciso, pero más lento.
  emon.current(CT_PIN, CT_CALIBRATION); 
}

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

  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;

    // Leer el sensor CT y calcular RMS de corriente
    double Irms = emon.calcIrms(1480); // 1480 es el número de muestras a tomar

    // Calcular la potencia aparente (Watts = Voltaje_RMS * Corriente_RMS)
    // Para potencia real se necesita sensor de voltaje para calcular el factor de potencia
    double apparentPower = Irms * AC_VOLTAGE_RMS;

    Serial.print("Corriente (A): ");
    Serial.print(Irms);
    Serial.print(" | Potencia (W): ");
    Serial.println(apparentPower);

    // Publicar los datos en MQTT
    char msg_power[10];
    dtostrf(apparentPower, 4, 2, msg_power); // Convertir double a string con 2 decimales
    client.publish(mqtt_topic_power, msg_power);
    Serial.print("MQTT Publicado (Potencia): ");
    Serial.println(msg_power);

    char msg_current[10];
    dtostrf(Irms, 4, 2, msg_current);
    client.publish(mqtt_topic_current, msg_current);
    Serial.print("MQTT Publicado (Corriente): ");
    Serial.println(msg_current);
  }
}

☁️ Configuración de la Plataforma IoT (ej. ThingsBoard)

Para visualizar los datos, necesitamos una plataforma IoT. ThingsBoard es una excelente opción de código abierto que ofrece dashboards potentes y personalizables. Otra opción podría ser Ubidots o Blynk, pero ThingsBoard es muy robusto para este tipo de aplicación.

1. Crear una Cuenta en ThingsBoard

Ve a ThingsBoard Cloud y crea una cuenta si no tienes una. También puedes instalar ThingsBoard en tu propio servidor.

2. Crear un Dispositivo

1. En el panel de ThingsBoard, ve a Devices > + (Agregar nuevo dispositivo).
2. Asígnale un Name (ej. "MonitorElectricidadCocina").
3. Haz clic en Add.
4. Una vez creado, haz clic en el dispositivo y ve a la pestaña Manage credentials. Aquí encontrarás el Access Token. Copia este token, lo necesitarás para tu código MQTT del ESP32.

3. Configurar el Broker MQTT de ThingsBoard

El broker MQTT de ThingsBoard Cloud es mqtt.thingsboard.cloud en el puerto 1883 (o 8883 para SSL/TLS). Asegúrate de actualizar la variable mqtt_server en tu código ESP32:

const char* mqtt_server = "mqtt.thingsboard.cloud";

4. Crear un Dashboard

1. Ve a Dashboards > + (Agregar nuevo dashboard).
2. Dale un Name (ej. "Monitoreo Eléctrico Casa").
3. Haz clic en el dashboard para abrirlo.
4. Haz clic en el icono de + en la esquina inferior derecha para Add new widget.
   • Widget para Corriente: Selecciona Analog Gauge o Timeseries Chart. Elige la fuente de datos (tu dispositivo), y selecciona la telemetría current. Personaliza el título, las unidades (A), y los rangos.
   • Widget para Potencia: Repite el proceso, seleccionando la telemetría power. Personaliza el título, las unidades (W), y los rangos.
   • Puedes añadir otros widgets como Historical Data Table para ver los datos históricos.

    char jsonBuffer[50];
    sprintf(jsonBuffer, "{\"current\":%.2f, \"power\":%.2f}", Irms, apparentPower);
    client.publish("v1/devices/me/telemetry", jsonBuffer);
    Serial.print("MQTT Publicado (JSON): ");
    Serial.println(jsonBuffer);

✅ Puesta en Marcha y Verificación

1. Cargar el código: Conecta tu ESP32 al ordenador. Selecciona el puerto COM correcto en Herramientas > Puerto. Luego, haz clic en Subir en el Arduino IDE para cargar el código.
2. Monitor Serie: Abre el Monitor Serie (Herramientas > Monitor Serie) para ver los mensajes de depuración (conexión WiFi, MQTT y lecturas de corriente/potencia).
3. Conectar el CT: Una vez que el ESP32 esté funcionando, cierra la pinza del sensor SCT-013-000 alrededor del cable de fase (normalmente el de color marrón o negro) del circuito o electrodoméstico que quieres monitorear.
4. Visualizar en ThingsBoard: Abre tu dashboard en ThingsBoard. Deberías empezar a ver los datos de corriente y potencia actualizándose en tiempo real en los widgets que configuraste.

📊 Análisis de Datos y Optimización

Una vez que tengas los datos fluyendo a tu dashboard, el verdadero trabajo comienza: entender y optimizar tu consumo.

• Identifica picos: Observa cuándo y por qué se producen los picos de consumo. ¿Coinciden con el uso de ciertos electrodomésticos?
• Consumo base: Determina tu consumo mínimo cuando la casa está vacía o de noche. Esto te ayudará a identificar aparatos que consumen energía constantemente (modo standby).
• Compara consumos: Si monitoreas varios circuitos, puedes comparar el consumo de diferentes áreas o aparatos.
• Impacto de cambios: Prueba a apagar ciertos dispositivos o a usar electrodomésticos eficientes y observa cómo afecta a tus lecturas.

🚀 Posibles Mejoras y Expansión del Proyecto

Este proyecto es una base sólida, pero hay muchas formas de expandirlo:

• Medición de Potencia Real: Integra un sensor de voltaje y un módulo como el PZEM-004T para medir voltaje, corriente, potencia real y factor de potencia.
• Múltiples Circuitos: Utiliza varios sensores CT y ESP32s, o un ESP32 con múltiples entradas ADC, para monitorear varios circuitos simultáneamente.
• Almacenamiento Local: Añade una tarjeta SD para almacenar datos localmente si la conexión a internet falla.
• Alertas y Notificaciones: Configura reglas en ThingsBoard (o en la plataforma IoT que uses) para enviar notificaciones (SMS, email, Telegram) si el consumo supera un umbral o cae por debajo de un nivel esperado.
• Integración con Automatización Domótica: Conecta este sistema a plataformas como Home Assistant o OpenHAB para activar acciones (ej. apagar luces no esenciales si el consumo es muy alto).
• Análisis Avanzado: Exporta los datos a herramientas como Excel, Google Sheets o Python para análisis más detallados y generación de informes.

📚 Recursos Adicionales

• Documentación de EmonLib
• Guía de Inicio Rápido de ThingsBoard
• Hoja de datos del SCT-013-000
• Tutoriales de ESP32

Conclusión ✨

Has construido un sistema de monitoreo de consumo eléctrico inteligente con ESP32, un sensor CT y un dashboard IoT. Ahora tienes una poderosa herramienta para entender y optimizar tu consumo energético, lo que no solo te ayudará a ahorrar dinero, sino también a contribuir a un futuro más sostenible. Experimenta con diferentes configuraciones, explora las mejoras sugeridas y ¡haz que tu hogar sea más inteligente y eficiente!