Suivi de consommation d'énergie à la maison avec MQTT : compteur communicant et pinces CT vers vos tableaux de bord

Une installation de suivi de l'énergie de la maison avec MQTT montre ce que consomme l'ensemble du logement, seconde par seconde, et met cette valeur à disposition de tous vos tableaux de bord et automatisations de maison connectée. Dans ce guide, vous allez choisir entre un lecteur de compteur communicant et des pinces CT, publier la consommation avec un script Python, puis la stocker et l'afficher avec Telegraf et InfluxDB. Vous verrez aussi quelles valeurs comptent pour l'autoconsommation solaire et comment garder ces données privées.

Deux façons de mesurer toute la maison

Vous pouvez mesurer au niveau du compteur du fournisseur ou au niveau de votre tableau électrique. Les deux fonctionnent bien ; le bon choix dépend de votre compteur et de votre aisance avec les travaux électriques.

Aux Pays-Bas, en Belgique et au Luxembourg, la plupart des compteurs communicants disposent d'un port P1 qui diffuse un « télégramme » texte chaque seconde (DSMR 5) ou toutes les dix secondes (DSMR 4). C'est la source la plus simple et la plus précise, car ce sont les valeurs que votre fournisseur facture. Ailleurs, cherchez une interface client équivalente ou utilisez des pinces CT.

Toute intervention à l'intérieur d'un tableau électrique doit être réalisée par un électricien qualifié. Les capteurs à pince ne coupent aucun fil, mais ouvrir le tableau expose des parties sous tension.

Conception des topics pour un flux de suivi énergie maison MQTT

Prévoyez un topic de télémétrie par compteur avec un payload JSON compact, plus un statut retenu :

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
}

Publiez net_w (soutirage moins injection) sous forme de valeur signée. Les automatisations solaires et de batterie s'intéressent à ce seul nombre : une valeur négative signifie que vous injectez sur le réseau.

Lire un compteur communicant P1 avec Python

Branchez un câble P1 vers USB sur un Raspberry Pi ou n'importe quelle machine Linux. Les compteurs DSMR 4 et 5 utilisent 115200 bauds, 8 bits de données, sans parité, 1 bit d'arrêt. Chaque télégramme commence par /, se termine par ! suivi d'un CRC, et contient des lignes comme 1-0:1.7.0(01.193*kW). Les codes OBIS dont vous avez besoin :

Installez les dépendances :

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   # secondes ; DSMR 5 envoie un télégramme chaque seconde

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)

Le script limite l'envoi à un message toutes les cinq secondes. C'est largement suffisant pour des tableaux de bord et reste bien en dessous de la limite du serveur MQTT public gratuit, fixée à 10 messages par seconde et par client. Pour une version de production, ajoutez la validation CRC16 de chaque télégramme ; les télégrammes corrompus sont rares, mais ils arrivent avec des câbles longs.

Vous préférez un lecteur P1 à base d'ESP plutôt qu'un Raspberry Pi ? Plusieurs firmwares open source publient directement les données DSMR en MQTT ; pointez-les vers le même broker et la même organisation de topics.

L'option des pinces CT

Si vous n'avez pas de port compteur exploitable, un compteur CT triphasé comme le Shelly Pro 3EM est l'option la moins contraignante. Une fois configuré, il publie en MQTT la puissance par phase et les totaux, et le guide Shelly MQTT détaille ses topics et ses réglages TLS. Les montages DIY avec un ESP32 et des pinces SCT-013 sont aussi populaires, mais notez qu'une pince de courant seule ne peut pas distinguer le soutirage de l'injection ; il faut une référence de tension pour calculer la puissance active et son sens. Pour des appareils individuels, les prises sont plus simples ; consultez le suivi énergétique MQTT avec prises connectées.

Stocker et afficher avec Telegraf et InfluxDB

Le broker transmet les valeurs en direct mais ne conserve pas d'historique. L'entrée mqtt_consumer de Telegraf s'abonne comme n'importe quel autre client et écrit dans InfluxDB, que Grafana ou l'interface d'InfluxDB peuvent ensuite afficher.

[[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"

Le bloc topic_parsing transforme le nom du compteur présent dans le topic en tag, si bien que les compteurs grid, solar et heatpump se retrouvent dans une seule mesure avec un tag meter. Les graphiques utiles à construire en premier :

1. La puissance nette sur les dernières 24 heures, avec le zéro mis en évidence pour que l'injection saute aux yeux.
2. Le soutirage et l'injection quotidiens, calculés à partir de la différence des compteurs kWh sur chaque journée.
3. La consommation de base, soit la puissance nette la plus basse entre 2 h et 5 h du matin, qui révèle les appareils toujours allumés.
4. Le soutirage par tarif, pour vérifier que les charges flexibles fonctionnent bien pendant la période la moins chère.

Les tableaux de bord Node-RED et Home Assistant conviennent tout aussi bien ; chacun s'abonne simplement au topic de télémétrie. Jeedom et Domoticz savent aussi communiquer en MQTT.

Agir à partir des mesures

Une valeur net_w en direct sur MQTT est plus qu'un graphique : c'est une entrée pour l'automatisation. Quelques scénarios valent la peine d'être mis en place tôt :

• Pilotage du surplus. Lorsque net_w reste sous un seuil négatif (vous injectez) pendant quelques minutes, allumez un chauffe-eau, un lave-vaisselle ou une borne de recharge, puis coupez-les avec une hystérésis quand le soutirage reprend.
• Écrêtement des pointes. Si le soutirage approche de ce que permet votre disjoncteur principal ou votre tarif de puissance, différez les charges flexibles au lieu de faire disjoncter ou de payer un dépassement.
• Alertes sur la consommation de base. Une consommation de base nocturne qui double soudainement signale souvent un appareil défectueux, une pompe bloquée ou un radiateur resté allumé.

Ces règles fonctionnent bien dans Node-RED, Home Assistant ou un court abonné Python, chacun se connectant au broker comme un client ordinaire et lisant le même topic de télémétrie.

Pièges à éviter

• Calculer l'énergie à partir d'échantillons de puissance. Intégrer une puissance échantillonnée dérive avec le temps. Utilisez les compteurs kWh du compteur pour les totaux journaliers.
• Mélanger kW et W. DSMR exprime la puissance en kW ; convertissez une seule fois, à la source.
• Retenir inutilement des données à haute fréquence. Le retained message est utile pour la dernière valeur, mais il est inutile de retenir des données à la seconde sur des topics séparés.
• Décalage d'horloge. Utilisez le champ d'horodatage de l'émetteur (ts) comme heure de mesure, afin que les retards de livraison ne faussent pas les graphiques.
• Publier en clair sur un broker public. Une consommation à la seconde révèle quand vous êtes chez vous ou absent. Le serveur MQTT public gratuit est réservé aux expériences.

Passer à un broker privé

Pour un suivi énergétique permanent, publiez vers un broker privé avec TLS. Un broker MQTT managé comme ConnectMQ vous évite de maintenir un broker sur le Raspberry Pi et vous offre un accès distant sécurisé depuis votre téléphone sans ouvrir de ports sur votre box. Créez un broker dans le portail ConnectMQ, puis modifiez les réglages du client et 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"

Chaque client (le lecteur P1 et Telegraf) a besoin de ses propres identifiants et de son propre client ID. Pour comparer avec la production, ajoutez le suivi d'un onduleur solaire, et pour une vue d'ensemble de l'automatisation tenant compte de l'énergie, lisez le guide de l'automatisation IoT. Si vous hésitez sur l'hébergement du broker, le guide du broker MQTT cloud compare les options.

Suivez l'énergie de votre maison en direct sur ConnectMQ

ConnectMQ offre à vos lecteurs de compteur, à Telegraf et à vos tableaux de bord un broker unique et sécurisé avec TLS, un accès WebSocket pour les tableaux de bord dans le navigateur et des règles d'alerte sur seuil, par exemple lorsque le soutirage net dépasse la capacité de votre disjoncteur principal. Créez un broker Serverless gratuit sur app.connectmq.com, sans carte bancaire.

Questions fréquentes

Mon compteur communicant a-t-il un port P1 ?

Les compteurs des Pays-Bas, de Belgique et du Luxembourg en ont généralement un, et dans certains pays le port doit être activé par le gestionnaire de réseau. D'autres régions utilisent des interfaces client différentes, voire aucune ; dans ce cas, les pinces CT ou un lecteur de LED d'impulsions sont les alternatives.

À quelle fréquence un suivi énergétique domestique doit-il publier en MQTT ?

Toutes les 1 à 10 secondes est courant. Des mises à jour rapides aident au pilotage du surplus solaire, tandis que l'historique et les totaux journaliers se contentent de fréquences plus basses, car ils proviennent des compteurs kWh.

Les pinces CT peuvent-elles détecter l'injection solaire ?

Uniquement si l'appareil mesure aussi la tension pour calculer la puissance active et son signe. Les pinces qui ne mesurent que le courant indiquent combien de courant circule, mais pas dans quel sens.

InfluxDB est-il obligatoire ?

Non. N'importe quel abonné peut stocker les données, y compris l'enregistreur de Home Assistant, un flux Node-RED qui écrit dans une base de données ou un simple script Python qui écrit des fichiers CSV.