Guía de monitor de energía doméstica MQTT: datos del contador inteligente y pinzas CT en tus dashboards

Un monitor de energía doméstica con MQTT muestra lo que consume toda tu casa, segundo a segundo, y pone esa cifra a disposición de todos los dashboards y automatizaciones que utilices. En esta guía elegirás entre un lector del contador inteligente y pinzas CT, publicarás el consumo con un script de Python y lo guardarás y graficarás con Telegraf e InfluxDB. También verás qué cifras importan para el autoconsumo solar y cómo mantener los datos en privado.

Dos formas de medir toda la vivienda

Puedes medir en el contador de la compañía o en tu cuadro eléctrico. Ambas opciones funcionan bien; la elección adecuada depende de tu contador y de lo cómodo que te sientas con los trabajos eléctricos.

En los Países Bajos, Bélgica y Luxemburgo, la mayoría de los contadores inteligentes tienen un puerto P1 que emite un "telegrama" de texto cada segundo (DSMR 5) o cada diez segundos (DSMR 4). Es la fuente más fácil y precisa, porque las cifras son las mismas que factura tu compañía. En otros lugares, busca una interfaz de cliente equivalente o usa pinzas CT.

Cualquier trabajo dentro de un cuadro eléctrico debe hacerlo un electricista cualificado. Los sensores de pinza no cortan cables, pero al abrir el cuadro quedan expuestas partes con tensión.

Diseño de topics para un monitor de energía doméstica MQTT

Mantén un topic de telemetría por contador con un payload JSON compacto, además de un estado retenido:

connectmq/demo/<random-id>/energy/grid/telemetry      (JSON, every 1-10 s)
connectmq/demo/<random-id>/energy/grid/status         (online/offline, retained)

{
  "import_w": 1193,
  "export_w": 0,
  "net_w": 1193,
  "import_kwh_t1": 4182.517,
  "import_kwh_t2": 3970.204,
  "export_kwh_t1": 1520.110,
  "export_kwh_t2": 3184.623,
  "voltage_l1": 230.1,
  "ts": 1760605123
}

Publica net_w (importación menos exportación) como valor con signo. A las automatizaciones solares y de baterías les importa ese único número: un valor negativo significa que estás exportando.

Leer un contador inteligente P1 con Python

Conecta un cable P1 a USB a una Raspberry Pi o a cualquier máquina Linux. Los contadores DSMR 4 y 5 usan 115200 baudios, 8 bits de datos, sin paridad y 1 bit de parada. Cada telegrama empieza por /, termina con ! más un CRC y contiene líneas como 1-0:1.7.0(01.193*kW). Los códigos OBIS que necesitas:

Instala las dependencias:

pip install "paho-mqtt>=2.0" pyserial

import json
import re
import time
import uuid
import serial
import paho.mqtt.client as mqtt

PORT = "/dev/ttyUSB0"
PREFIX = f"connectmq/demo/{uuid.uuid4().hex[:8]}/energy/grid"
PUBLISH_EVERY = 5   # segundos; DSMR 5 envía un telegrama por segundo

LINE = re.compile(r"^(\d+-\d+:\d+\.\d+\.\d+)\((.*)\)$")
VALUE = re.compile(r"([\d.]+)\*")

FIELDS = {
    "1-0:1.8.1": ("import_kwh_t1", 1),
    "1-0:1.8.2": ("import_kwh_t2", 1),
    "1-0:2.8.1": ("export_kwh_t1", 1),
    "1-0:2.8.2": ("export_kwh_t2", 1),
    "1-0:1.7.0": ("import_w", 1000),   # kW -> W
    "1-0:2.7.0": ("export_w", 1000),
    "1-0:32.7.0": ("voltage_l1", 1),
}


def parse(telegram):
    out = {}
    for line in telegram.splitlines():
        m = LINE.match(line.strip())
        if not m or m.group(1) not in FIELDS:
            continue
        name, factor = FIELDS[m.group(1)]
        v = VALUE.search(m.group(2))
        if v:
            out[name] = round(float(v.group(1)) * factor, 3)
    if "import_w" in out and "export_w" in out:
        out["net_w"] = round(out["import_w"] - out["export_w"], 1)
    return out


mq = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=f"p1-{uuid.uuid4().hex[:6]}")
mq.will_set(f"{PREFIX}/status", "offline", qos=1, retain=True)
mq.connect("broker.connectmq.com", 1883, keepalive=60)
mq.loop_start()
mq.publish(f"{PREFIX}/status", "online", qos=1, retain=True)
print("Publishing to", PREFIX)

ser = serial.Serial(PORT, 115200, bytesize=8, parity="N", stopbits=1, timeout=12)
buf, last_pub = [], 0.0
while True:
    raw = ser.readline().decode("ascii", errors="ignore")
    if not raw:
        continue
    if raw.startswith("/"):
        buf = [raw]
    elif buf:
        buf.append(raw)
        if raw.startswith("!"):
            data = parse("".join(buf))
            buf = []
            if data and time.time() - last_pub >= PUBLISH_EVERY:
                data["ts"] = int(time.time())
                mq.publish(f"{PREFIX}/telemetry", json.dumps(data), qos=0, retain=True)
                last_pub = time.time()
                print(data)

El script limita el envío a un mensaje cada cinco segundos. Es más que suficiente para dashboards y queda muy por debajo del límite del servidor MQTT público gratuito de 10 mensajes por segundo por cliente. Para una versión de producción, añade la validación CRC16 de cada telegrama; los telegramas corruptos son raros, pero ocurren con cables largos.

¿Prefieres un lector P1 basado en ESP en lugar de una Raspberry Pi? Varios proyectos de firmware abierto publican los datos DSMR directamente en MQTT; apúntalos al mismo broker y a la misma estructura de topics.

La vía de las pinzas CT

Si no tienes un puerto del contador utilizable, un medidor CT trifásico como el Shelly Pro 3EM es la opción de menor esfuerzo. Una vez configurado, publica por MQTT la potencia por fase y los totales, y la guía de Shelly MQTT explica sus topics y ajustes TLS. Los montajes caseros con un ESP32 y pinzas SCT-013 también son populares, pero ten en cuenta que una pinza de corriente por sí sola no distingue importación de exportación; necesitas una referencia de tensión para calcular la potencia real y su sentido. Para aparatos individuales, los enchufes son más sencillos; consulta monitorización de energía con enchufes inteligentes MQTT.

Guardar y graficar con Telegraf e InfluxDB

El broker entrega valores en vivo, pero no guarda el histórico. La entrada mqtt_consumer de Telegraf se suscribe como cualquier otro cliente y escribe en InfluxDB, cuyos datos se pueden graficar con Grafana o con la propia interfaz de InfluxDB.

[[inputs.mqtt_consumer]]
  servers = ["tcp://broker.connectmq.com:1883"]
  topics = ["connectmq/demo/+/energy/+/telemetry"]
  client_id = "telegraf-energy-5527"
  qos = 0
  data_format = "json"
  name_override = "energy"
  json_time_key = "ts"
  json_time_format = "unix"
  [[inputs.mqtt_consumer.topic_parsing]]
    topic = "connectmq/demo/+/energy/+/telemetry"
    tags = "_/_/_/_/meter/_"

[[outputs.influxdb_v2]]
  urls = ["http://localhost:8086"]
  token = "YOUR_INFLUX_TOKEN"
  organization = "home"
  bucket = "energy"

El bloque topic_parsing convierte el nombre del contador del topic en una etiqueta, de modo que los contadores grid, solar y heatpump terminan en una única medición con la etiqueta meter. Gráficas útiles para empezar:

1. Potencia neta de las últimas 24 horas, con el cero resaltado para que la exportación sea evidente.
2. Importación y exportación diarias a partir de la diferencia diaria de los contadores de kWh.
3. Consumo base, la potencia neta más baja entre las 2 y las 5 de la madrugada, que revela los consumidores siempre encendidos.
4. Importación por tarifa, para comprobar que las cargas flexibles funcionan realmente en el periodo barato.

Los dashboards de Node-RED y Home Assistant funcionan igual de bien; cada uno simplemente se suscribe al topic de telemetría.

Actuar sobre las cifras

Un valor net_w en vivo en MQTT es más que una gráfica; es una entrada para la automatización. Merece la pena configurar pronto algunos patrones:

• Conmutación por excedentes. Cuando net_w se mantiene por debajo de un umbral negativo (estás exportando) durante unos minutos, enciende un termo, el lavavajillas o un cargador de vehículo eléctrico, y apágalo de nuevo con histéresis cuando vuelva la importación.
• Limitación de picos. Si la importación se acerca a lo que permite tu fusible principal o tu potencia contratada, retrasa las cargas flexibles en lugar de hacer saltar un interruptor o pagar un recargo por pico.
• Alertas de consumo base. Un consumo base nocturno que de repente se duplica suele indicar un aparato averiado, una bomba atascada o un calefactor que se quedó encendido.

Estas reglas funcionan bien en Node-RED, Home Assistant o un breve suscriptor en Python, todos conectados al broker como clientes normales y leyendo el mismo topic de telemetría.

Errores que conviene evitar

• Calcular la energía a partir de muestras de potencia. Integrar la potencia muestreada acumula deriva con el tiempo. Usa los contadores de kWh del contador para los totales diarios.
• Mezclar kW y W. DSMR informa la potencia en kW; convierte una sola vez, en el origen.
• Retener datos de alta frecuencia sin necesidad. Retener es útil para el último valor, pero no hace falta retener datos por segundo en topics separados.
• Desfase de relojes. Usa el campo de marca de tiempo del publicador (ts) como hora de medición para que los retrasos en la entrega no distorsionen las gráficas.
• Publicar a la vista de todos. El consumo segundo a segundo revela cuándo estás en casa o fuera. El servidor público es solo para pruebas y prototipos, no para datos de producción.

Pasar a un broker privado

Para un monitor de energía doméstica permanente, publica en un broker privado con TLS. Un broker MQTT gestionado como ConnectMQ significa no tener que mantener un broker en la Raspberry Pi y disponer de acceso remoto seguro desde el móvil sin abrir puertos en el router. Crea un broker en el portal de ConnectMQ y cambia los ajustes del cliente y de Telegraf:

mq = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="YOUR_CLIENT_ID")
mq.username_pw_set("YOUR_USERNAME", "YOUR_PASSWORD")
mq.tls_set()
mq.connect("broker.connectmq.com", 8883, keepalive=60)

  servers = ["ssl://broker.connectmq.com:8883"]
  username = "YOUR_USERNAME"
  password = "YOUR_PASSWORD"

Cada cliente (el lector P1 y Telegraf) necesita sus propias credenciales y su propio client ID. Para comparar con la producción, añade la monitorización de inversor solar, y para una visión más amplia de la automatización consciente de la energía, lee la guía de automatización IoT. Si estás decidiendo dónde alojar el broker, la guía de broker MQTT en la nube compara las opciones.

Observa la energía de tu hogar en vivo con ConnectMQ

ConnectMQ ofrece a tus lectores de contador, a Telegraf y a tus dashboards un único broker seguro con TLS, acceso por WebSocket para dashboards en el navegador y reglas de alerta por umbral, por ejemplo cuando la importación neta supera el margen de tu fusible principal. Crea un broker Serverless gratuito en app.connectmq.com, sin tarjeta de crédito.

Preguntas frecuentes

¿Tiene mi contador inteligente un puerto P1?

Los contadores de los Países Bajos, Bélgica y Luxemburgo suelen tenerlo, y en algunos países el operador de la red debe activar el puerto. Otras regiones usan interfaces de cliente distintas o ninguna, en cuyo caso las alternativas son las pinzas CT o un lector del LED de pulsos.

¿Con qué frecuencia debe publicar por MQTT un monitor de energía doméstica?

Lo habitual es cada 1 a 10 segundos. Las actualizaciones rápidas ayudan al control de excedentes solares, mientras que el histórico y los totales diarios funcionan bien con frecuencias menores porque proceden de los contadores de kWh.

¿Pueden las pinzas CT detectar la exportación solar?

Solo si el dispositivo también mide la tensión para calcular la potencia real y su signo. Las pinzas que solo miden corriente muestran cuánta corriente circula, pero no en qué sentido.

¿Es obligatorio usar InfluxDB?

No. Cualquier suscriptor puede guardar los datos, incluido el recorder de Home Assistant, un flujo de Node-RED que escriba en una base de datos o un sencillo script de Python que escriba archivos CSV.