07 · Intégrations DIY
Comment transmettre les mesures rbamp aux systèmes de domotique auto-hébergés populaires depuis un hôte Python. Pour chaque plateforme : un script Python minimal et la configuration correspondante côté plateforme.
Les intégrations cloud et commerciales (AWS IoT, Azure, GCP, InfluxDB Cloud) sont traitées dans 08 · Intégrations cloud.
| Plateforme | Transport | Découverte automatique | Client MQTT Python |
|---|---|---|---|
| Home Assistant | MQTT | oui (découverte MQTT HA) | paho-mqtt (CPython) / umqtt.simple (uPy) |
| Node-RED | MQTT (ou HTTP) | flux manuel | comme ci-dessus |
| OpenHAB | MQTT (ou REST) | .things manuel |
comme ci-dessus |
| Domoticz | MQTT (auto) ou HTTP | oui (extension MQTT) | paho-mqtt ou requests |
| InfluxDB OSS + Grafana | Protocole de ligne HTTP | non | requests (CPython) / urequests (uPy) |
Les scripts prêts à l'emploi pour Home Assistant se trouvent dans examples_cpython/09_ha_autodiscovery.py (CPython, démon sensible à SIGTERM) et examples_upy/10_ha_autodiscovery.py (MicroPython).
Home Assistant — découverte automatique MQTT
La découverte MQTT de HA crée automatiquement l'appareil et ses capteurs dès que votre script Python publie les sujets de configuration. Aucune modification YAML dans HA n'est nécessaire.
Version CPython (via paho-mqtt)
Installez d'abord le client : pip install paho-mqtt.
import time, json
from smbus2 import SMBus
import paho.mqtt.client as mqtt_client
from rbamp import RbAmp, RbAmpSensorClass, RbAmpStaleError
DEVICE_ID = "rbamp_main"
DEVICE_NAME = "Mains rbAmp"
mqtt = mqtt_client.Client(mqtt_client.CallbackAPIVersion.VERSION2, DEVICE_ID)
mqtt.connect("192.168.1.10", 1883, keepalive=60)
mqtt.loop_start()
def publish_discovery_sensor(key, friendly, unit, device_class, state_class):
payload = {
"name": f"{DEVICE_NAME} {friendly}",
"unique_id": f"{DEVICE_ID}_{key}",
"state_topic": f"rbamp/{DEVICE_ID}/state",
"value_template": f"{{{{ value_json.{key} }}}}",
"state_class": state_class,
"device": {
"identifiers": [DEVICE_ID],
"name": DEVICE_NAME,
"manufacturer": "rbAmp",
"model": "UI*",
},
}
if unit: payload["unit_of_measurement"] = unit
if device_class: payload["device_class"] = device_class
topic = f"homeassistant/sensor/{DEVICE_ID}/{key}/config"
mqtt.publish(topic, json.dumps(payload), qos=1, retain=True)
def publish_discovery_all():
publish_discovery_sensor("voltage", "Voltage", "V", "voltage", "measurement")
publish_discovery_sensor("current", "Current", "A", "current", "measurement")
publish_discovery_sensor("power", "Power", "W", "power", "measurement")
publish_discovery_sensor("energy", "Energy", "Wh", "energy", "total_increasing")
publish_discovery_sensor("frequency", "Frequency", "Hz", "frequency", "measurement")
publish_discovery_sensor("power_factor", "Power Factor", None, "power_factor", "measurement")
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model(3)
publish_discovery_all()
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
continue
state = {
"voltage": round(dev.voltage, 1),
"current": round(dev.read_current(0), 3),
"power": round(snap.avg_p[0], 1),
"energy": round(dev.energy.wh(0), 3),
"frequency": round(dev.frequency, 1),
"power_factor": round(dev.read_power_factor(0), 3),
}
mqtt.publish(f"rbamp/{DEVICE_ID}/state", json.dumps(state), qos=0)
Version MicroPython (via umqtt.simple)
import time, ujson
from machine import I2C, Pin
from umqtt.simple import MQTTClient
from rbamp import RbAmp, RbAmpSensorClass, RbAmpStaleError
DEVICE_ID = b"rbamp_main"
def publish_discovery(mqtt, key, friendly, unit, dc, sc):
payload = {
"name": f"Mains rbAmp {friendly}",
"unique_id": f"rbamp_main_{key}",
"state_topic": f"rbamp/rbamp_main/state",
"value_template": "{{ value_json." + key + " }}",
"state_class": sc,
"device": {
"identifiers": ["rbamp_main"],
"name": "Mains rbAmp",
"manufacturer": "rbAmp",
"model": "UI*",
},
}
if unit: payload["unit_of_measurement"] = unit
if dc: payload["device_class"] = dc
topic = b"homeassistant/sensor/rbamp_main/" + key.encode() + b"/config"
mqtt.publish(topic, ujson.dumps(payload).encode(),
qos=1, retain=True)
mqtt = MQTTClient(DEVICE_ID, b"192.168.1.10", port=1883, keepalive=60)
mqtt.connect()
for key, friendly, unit, dc, sc in [
("voltage", "Voltage", "V", "voltage", "measurement"),
("current", "Current", "A", "current", "measurement"),
("power", "Power", "W", "power", "measurement"),
("energy", "Energy", "Wh", "energy", "total_increasing"),
("frequency", "Frequency", "Hz", "frequency", "measurement"),
("power_factor", "Power Factor", None, "power_factor", "measurement"),
]:
publish_discovery(mqtt, key, friendly, unit, dc, sc)
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)
with RbAmp(i2c, 0x50) as dev:
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model(3)
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
continue
state = {
"voltage": round(dev.voltage, 1),
"current": round(dev.read_current(0), 3),
"power": round(snap.avg_p[0], 1),
"energy": round(dev.energy.wh(0), 3),
"frequency": round(dev.frequency, 1),
"power_factor": round(dev.read_power_factor(0), 3),
}
mqtt.publish(b"rbamp/rbamp_main/state",
ujson.dumps(state).encode(), qos=0)
mqtt.ping() # keepalive, since umqtt.simple is sync with no background task
dev.energy.wh(0) est conservé en mémoire : il repart de 0 après un redémarrage du script ou du module, et HA s'en accommode parce que le capteur est total_increasing. Pour conserver un total absolu, enregistrez vous-même dev.energy.wh(0) et réintégrez-le au démarrage. Sur les modules BASIC, l'export n'est pas comptabilisé. Sur un module STD, la valeur est l'énergie nette (l'export se soustrait) : elle baisse pendant l'export, et Home Assistant lirait cette baisse d'un capteur total_increasing comme une remise à zéro du compteur. Avec l'export sur un module STD, publiez la valeur nette avec state_class: total, ou publiez l'import et l'export issus de read_std_energy() comme deux capteurs total_increasing. Les premières valeurs apparaissent après la première période de 60 secondes.
Résultat dans HA
Peu après la première publication, HA crée automatiquement un appareil nommé « Mains rbAmp » avec 6 capteurs (Tension, Courant, Puissance, Énergie, Fréquence, Facteur de puissance). Le capteur Énergie porte state_class: total_increasing et le device_class correct, de sorte que le tableau de bord Énergie de HA l'accepte comme source de consommation.
Pour retirer plus tard l'appareil de HA, publiez une charge utile vide sur homeassistant/sensor/.../config (l'indicateur retained efface l'entrée).
UI3 multi-canaux
Répétez publish_discovery_sensor() avec des clés suffixées pour les voies 1 et 2 :
publish_discovery_sensor("current_1", "Current 1", "A", "current", "measurement")
publish_discovery_sensor("power_1", "Power 1", "W", "power", "measurement")
publish_discovery_sensor("energy_1", "Energy 1", "Wh", "energy", "total_increasing")
# ...same for _2
Complétez ensuite le JSON d'état avec les champs "current_1", "power_1", "energy_1", renseignés depuis dev.read_current(1) / snap.avg_p[1] / dev.energy.wh(1) (ou depuis dev.current[1] / dev.power[1] via la propriété _ChannelProxy si vous préférez).
Sur MicroPython, la variante asynchrone — le paquet mqtt_as au lieu de umqtt.simple — fournit un keepalive et une reconnexion intégrés sans mqtt.ping() manuel. Voir aussi le scénario 10 dans 06 · Exemples (diffusion asynchrone).
Node-RED
Abonnez-vous au sujet MQTT du publieur Python dans un flux :
[
{
"id": "rbamp_in",
"type": "mqtt in",
"topic": "rbamp/rbamp_main/state",
"qos": "0",
"datatype": "json"
},
{
"id": "rbamp_chart",
"type": "ui_chart",
"label": "Mains Power",
"chartType": "line",
"ymin": "0",
"ymax": "5000"
},
{
"id": "extract_power",
"type": "function",
"func": "msg.payload = msg.payload.power; return msg;"
}
]
Reliez rbamp_in → extract_power → rbamp_chart et vous obtenez un graphique de puissance en temps réel. Faites de même pour l'énergie / la tension / le PF.
Si Node-RED tourne sur le même Pi que le broker MQTT, définissez l'hôte sur localhost. Pour des brokers distants, utilisez 192.168.X.Y:1883 plus des identifiants si le broker exige une authentification.
Le script Python est le même que dans la section Home Assistant ci-dessus ; la charge utile JSON est partagée, seul le consommateur diffère.
OpenHAB
OpenHAB 4.x + liaison MQTT :
# things/rbamp.things
Bridge mqtt:broker:local "MQTT Broker" [ host="192.168.1.10", port=1883 ] {
Thing topic rbamp_main "rbAmp Main" {
Channels:
Type number : voltage "Voltage" [ stateTopic="rbamp/rbamp_main/state", transformationPattern="JSONPATH:$.voltage" ]
Type number : current "Current" [ stateTopic="rbamp/rbamp_main/state", transformationPattern="JSONPATH:$.current" ]
Type number : power "Power" [ stateTopic="rbamp/rbamp_main/state", transformationPattern="JSONPATH:$.power" ]
Type number : energy "Energy" [ stateTopic="rbamp/rbamp_main/state", transformationPattern="JSONPATH:$.energy" ]
}
}
# items/rbamp.items
Number:ElectricPotential rbAmp_Voltage "Voltage [%.1f V]" { channel="mqtt:topic:local:rbamp_main:voltage" }
Number:ElectricCurrent rbAmp_Current "Current [%.3f A]" { channel="mqtt:topic:local:rbamp_main:current" }
Number:Power rbAmp_Power "Power [%.1f W]" { channel="mqtt:topic:local:rbamp_main:power" }
Number:Energy rbAmp_Energy "Energy [%.3f Wh]" { channel="mqtt:topic:local:rbamp_main:energy" }
Le script Python est le même que dans la section Home Assistant ci-dessus. La charge utile JSON est partagée, seul le consommateur diffère.
Domoticz
Le plugin de découverte automatique MQTT de Domoticz comprend les mêmes sujets de découverte homeassistant/.... Activez le plugin dans les réglages de Domoticz, et le script Python de la section HA ci-dessus commencera à enregistrer l'appareil dans Domoticz automatiquement, comme il le fait dans HA.
L'alternative est l'API HTTP native de Domoticz via requests :
CPython
import requests
from rbamp import RbAmp, RbAmpStaleError
def publish_to_domoticz(idx, power, e_wh):
"""Domoticz svalue format for a kWh meter: 'POWER;ENERGY_WH'."""
try:
r = requests.get(
"http://192.168.1.20:8080/json.htm",
params={
"type": "command",
"param": "udevice",
"idx": idx,
"svalue": f"{power:.1f};{e_wh:.0f}",
},
timeout=5,
)
if r.status_code != 200:
print(f"domoticz HTTP {r.status_code}")
except requests.RequestException as e:
print("domoticz request failed:", e)
# In your 60-second loop:
publish_to_domoticz(123, snap.avg_p[0], dev.energy.wh(0)) # 123 = your idx
MicroPython
import urequests as requests
def publish_to_domoticz(idx, power, e_wh):
url = ("http://192.168.1.20:8080/json.htm"
"?type=command¶m=udevice"
"&idx={}&svalue={:.1f};{:.0f}").format(idx, power, e_wh)
try:
r = requests.get(url)
if r.status_code != 200:
print("domoticz HTTP", r.status_code)
r.close() # MicroPython requires explicit close to free socket
except OSError as e:
print("domoticz request failed:", e)
Créez un appareil dans l'interface Domoticz de type General → kWh (compteur incrémental), récupérez son idx et codez-le en dur dans le script.
InfluxDB OSS + Grafana
Écrire des points au format line-protocol vers InfluxDB directement depuis l'hôte Python.
CPython (via requests)
import time, requests
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpSensorClass, RbAmpStaleError
INFLUX_HOST = "192.168.1.30:8086"
INFLUX_ORG = "homelab"
INFLUX_BKT = "energy"
INFLUX_TOKEN = "your-token-here"
def push_influx(u, p, e_wh):
url = (f"http://{INFLUX_HOST}/api/v2/write"
f"?org={INFLUX_ORG}&bucket={INFLUX_BKT}&precision=s")
body = f"rbamp,device=main voltage={u:.1f},power={p:.1f},energy={e_wh:.3f}"
try:
r = requests.post(url, data=body, headers={
"Authorization": f"Token {INFLUX_TOKEN}",
"Content-Type": "text/plain",
}, timeout=5)
if r.status_code != 204:
print(f"influx HTTP {r.status_code}: {r.text}")
except requests.RequestException as e:
print("influx request failed:", e)
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model(3)
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
continue
push_influx(dev.voltage, snap.avg_p[0], dev.energy.wh(0))
MicroPython (via urequests)
import urequests as requests
import time
INFLUX_URL = "http://192.168.1.30:8086/api/v2/write?org=homelab&bucket=energy&precision=s"
INFLUX_TOKEN = "your-token-here"
def push_influx(u, p, e_wh):
body = "rbamp,device=main voltage={:.1f},power={:.1f},energy={:.3f}".format(u, p, e_wh)
try:
r = requests.post(INFLUX_URL, data=body, headers={
"Authorization": "Token " + INFLUX_TOKEN,
"Content-Type": "text/plain",
})
if r.status_code != 204:
print("influx HTTP", r.status_code)
r.close()
except OSError as e:
print("influx request failed:", e)
Dans Grafana, ajoutez une source de données InfluxDB, puis un panneau avec une requête Flux :
from(bucket: "energy")
|> range(start: -24h)
|> filter(fn: (r) => r._measurement == "rbamp" and r.device == "main")
|> filter(fn: (r) => r._field == "power")
Pour un déploiement de longue durée, poussez aussi les compteurs de diagnostic vers une mesure distincte :
# On MicroPython, build the backend yourself and pass it to RbAmp:
# backend = MachineI2CBackend(i2c, retry_attempts=5); dev = RbAmp(backend, 0x50)
diag_body = (
"rbamp_diag,device=main "
f"sanity_reject={dev.sanity_reject_count},"
f"retry_exhaust={backend.retry_exhaustion_count},"
f"retry_total={backend.retry_count_total}"
)
# ...push to InfluxDB...
(Sous CPython il n'y a pas de compteurs de nouvelles tentatives — SMBusBackend n'a pas de couche de nouvelles tentatives. Ne remontez que sanity_reject_count.)
Vous obtenez ainsi un graphique de santé du bus à côté des données d'énergie.
Multi-plateforme — diffusion depuis un seul hôte Python
Si vous avez besoin à la fois de l'auto-découverte HA, d'InfluxDB et de Node-RED, publiez l'état JSON une seule fois sur MQTT et laissez chaque consommateur s'abonner à rbamp/+/state. L'hôte Python ne parle qu'au broker MQTT — le broker diffuse lui-même aux abonnés. N'envoyez pas directement depuis Python vers N endpoints HTTP : cela couple l'hôte à des consommateurs précis.
Pour un flux à très haut débit (10 Hz RT via dev.power[0]), exécutez un script auxiliaire Python sur le Pi qui héberge le broker — abonnez-vous au sujet rapide, sous-échantillonnez et republiez sur les sujets lents. L'hôte Python principal (celui qui exécute rbamp) doit rester concentré sur les appels dev.read_*, sans surcharge HTTP.
Variante asyncio (CPython)
Pour CPython avec asyncio, vous pouvez combiner la lecture et la publication multi-cibles en une seule tâche :
import asyncio, json
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpSensorClass
async def publish_mqtt(client, snap, dev): ... # paho-mqtt async wrapper
async def push_influx(snap, dev): ... # aiohttp instead of requests
async def push_webhook(snap, dev): ... # aiohttp as well
async def main():
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model(3)
async for snap in dev.stream_period(interval_s=60.0):
await asyncio.gather(
publish_mqtt(mqtt_client, snap, dev),
push_influx(snap, dev),
push_webhook(snap, dev),
)
asyncio.run(main())
dev.stream_period() est le générateur asynchrone du paquet — voir 09 · Référence API, section « Comptabilité par période ».
Liens
-
06 · Exemples — les scripts de base sur lesquels reposent ces intégrations (y compris le scénario 10 « diffusion asynchrone »)
-
08 · Intégrations cloud — AWS IoT / Azure / GCP / InfluxDB Cloud / webhook générique
-
10 · Dépannage — schémas de déconnexion MQTT, gestion des signaux, budget de tas TLS
Sources et problèmes : rb-amp/rbamp-python · cette page dans le dépôt : docs/07_diy_integrations.md (v1.6.1)