rbAmp
FR
Boutique
Docs
Mis à jour le · Modifier sur GitHub (Edit on GitHub)

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)
Remarque

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.

Python
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)

Python
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
À propos de la valeur d'énergie.

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 :

Python
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).

Remarque

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 :

JSON
[
  {
    "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 :

Text
# 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" ]
    }
}
Text
# 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

Python
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

Python
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)

Python
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)

Python
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 :

Text
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 :

Python
# 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 :

Python
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 ».


  • 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)