rbAmp
DE
Shop
Docs
Aktualisiert · Auf GitHub bearbeiten [Edit on GitHub]

07 · DIY-Integrationen

Wie Sie rbamp-Messwerte aus einem Python-Host in gängige selbst gehostete Automatisierungssysteme einspeisen. Für jede Plattform: ein minimales Python-Skript plus die passende Konfiguration auf Plattformseite.

Cloud- / kommerzielle Integrationen (AWS IoT, Azure, GCP, InfluxDB Cloud) werden in 08 · Cloud-Integrationen behandelt.

Plattform Transport Auto-Discovery Python-MQTT-Client
Home Assistant MQTT ja (HA MQTT-Discovery) paho-mqtt (CPython) / umqtt.simple (uPy)
Node-RED MQTT (oder HTTP) manueller Ablauf wie oben
OpenHAB MQTT (oder REST) manuelle .things wie oben
Domoticz MQTT (automatisch) oder HTTP ja (MQTT-Plugin) paho-mqtt oder requests
InfluxDB OSS + Grafana HTTP-Line-Protokoll nein requests (CPython) / urequests (uPy)
Hinweis

Fertige Skripte für Home Assistant liegen in examples_cpython/09_ha_autodiscovery.py (CPython, SIGTERM-fähiger Dienst) und examples_upy/10_ha_autodiscovery.py (MicroPython).


Home Assistant — MQTT-Auto-Discovery

Die HA-MQTT-Erkennung legt Gerät und Sensoren automatisch an, sobald Ihr Python-Skript die Konfigurations-Topics veröffentlicht. In HA sind keine YAML-Änderungen nötig.

CPython-Version (über paho-mqtt)

Installieren Sie zuerst den 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)

MicroPython-Version (über 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
Zum Energiewert.

dev.energy.wh(0) wird im Speicher geführt: Nach einem Neustart des Skripts oder des Geräts startet es bei 0, und Home Assistant kommt damit zurecht, weil der Sensor total_increasing ist. Wenn Sie eine absolute Summe selbst führen wollen, speichern Sie dev.energy.wh(0) persistent und addieren Sie den Wert beim Start wieder hinzu. Auf BASIC-Modulen wird Export nicht gezählt. Auf einem STD-Modul ist der Wert Nettoenergie (Export wird abgezogen), er sinkt also während des Exports: Home Assistant würde einen Rückgang eines total_increasing-Sensors als Zählerreset deuten. Bei Export auf einem STD-Modul veröffentlichen Sie den Nettowert mit state_class: total oder veröffentlichen Import und Export aus read_std_energy() als zwei total_increasing-Sensoren. Die ersten Werte erscheinen nach der ersten 60-Sekunden-Periode.

Ergebnis in HA

Wenige Sekunden nach der ersten Veröffentlichung legt HA automatisch ein Gerät namens „Mains rbAmp“ mit 6 Sensoren an (Spannung, Strom, Leistung, Energie, Frequenz, Leistungsfaktor). Der Energiesensor trägt state_class: total_increasing und die korrekte device_class, sodass das Energie-Dashboard [Energy Dashboard] von HA ihn als Verbrauchsquelle akzeptiert.

Um das Gerät später aus HA zu entfernen, veröffentlichen Sie eine leere Nutzlast auf homeassistant/sensor/.../config (das Retained-Flag löscht den Eintrag).

Mehrkanal-UI3

publish_discovery_sensor() mit angehängten Schlüsseln für die Kanäle 1 und 2 wiederholen:

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

Ergänzen Sie dann den Zustands-JSON um die Felder "current_1", "power_1", "energy_1", befüllt aus dev.read_current(1) / snap.avg_p[1] / dev.energy.wh(1) (oder aus dev.current[1] / dev.power[1] über die Eigenschaft _ChannelProxy, falls Sie das bevorzugen).

Hinweis

Auf MicroPython bietet das asynchrone Pendant — das Paket mqtt_as statt umqtt.simple — ein integriertes Keepalive und Reconnect ohne manuelles mqtt.ping(). Siehe auch Szenario 10 in 06 · Beispiele (asynchrones Streaming).


Node-RED

Abonnieren Sie das MQTT-Topic des Python-Publishers in einem Flow:

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;"
  }
]

Verbinden Sie rbamp_in → extract_power → rbamp_chart, dann erhalten Sie ein Echtzeit-Leistungsdiagramm. Verfahren Sie ebenso für Energie / Spannung / PF.

Läuft Node-RED auf demselben Pi wie der MQTT-Broker, setzen Sie den Host auf localhost. Für entfernte Broker verwenden Sie 192.168.X.Y:1883 plus Zugangsdaten, falls der Broker eine Anmeldung verlangt.

Das Python-Skript ist dasselbe wie im Abschnitt zu Home Assistant oben; die JSON-Nutzlast wird geteilt, nur der Empfänger ist ein anderer.


OpenHAB

OpenHAB 4.x + MQTT-Binding:

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

Die Python-Seite ist dasselbe Skript wie im Home-Assistant-Abschnitt oben. Die JSON-Nutzlast ist dieselbe, nur der Verbraucher ist ein anderer.


Domoticz

Das MQTT-Auto-Discovery-Plugin in Domoticz versteht dieselben homeassistant/...-Discovery-Topics. Aktivieren Sie das Plugin in den Domoticz-Einstellungen; dann registriert das Python-Skript aus dem HA-Abschnitt oben das Gerät automatisch in Domoticz, genau wie in HA.

Die Alternative ist die native HTTP-API von Domoticz über 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)

Legen Sie in der Domoticz-Oberfläche ein Gerät vom Typ General → kWh (inkrementeller Zähler) an, übernehmen Sie seine idx und tragen Sie sie fest in das Skript ein.


InfluxDB OSS + Grafana

Line-Protocol-Punkte direkt vom Python-Host in InfluxDB schreiben.

CPython (über 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 (über 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)

Fügen Sie in Grafana eine InfluxDB-Datenquelle hinzu und dann ein Panel mit einer Flux-Abfrage:

Text
from(bucket: "energy")
  |> range(start: -24h)
  |> filter(fn: (r) => r._measurement == "rbamp" and r.device == "main")
  |> filter(fn: (r) => r._field == "power")

Für einen langlaufenden Dauerbetrieb schreiben Sie die Diagnosezähler zusätzlich in eine eigene Messreihe:

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

(Unter CPython gibt es keine Wiederholungszähler — SMBusBackend hat keine Wiederholungsschicht. Übertragen Sie nur sanity_reject_count.)

Damit erhalten Sie neben den Energiedaten auch eine Übersicht über die Buskonditionen.


Mehrere Plattformen — Verteilung von einem einzigen Python-Host

Wenn Sie HA-Auto-Discovery, InfluxDB und Node-RED gleichzeitig brauchen, veröffentlichen Sie den Zustands-JSON einmal per MQTT und lassen jeden Verbraucher rbamp/+/state abonnieren. Der Python-Host spricht nur mit dem MQTT-Broker — der Broker verteilt an die Abonnenten selbst. Pushen Sie nicht direkt aus Python an N HTTP-Endpunkte: das würde den Host an bestimmte Verbraucher koppeln.

Bei einem Stream mit sehr hoher Rate (10 Hz RT über dev.power[0]) betreiben Sie auf dem Pi, der den Broker hostet, ein Begleitskript in Python — es abonniert das schnelle Topic, dezimiert und veröffentlicht erneut auf den langsamen Topics. Der Haupt-Host in Python (der rbamp ausführt) sollte sich auf dev.read_*-Aufrufe ohne HTTP-Overhead konzentrieren.

Asyncio-Variante (CPython)

Bei CPython mit asyncio können Sie das Lesen und die Veröffentlichung an mehrere Ziele in einer einzigen Task kombinieren:

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() ist der asynchrone Generator des Pakets — siehe 09 · API-Referenz, Abschnitt „Periodenbuchhaltung“.


  • 06 · Beispiele — die Basisskripte, auf denen diese Integrationen aufbauen (einschließlich Szenario 10 „asynchrones Streaming“)

  • 08 · Cloud-Integrationen — AWS IoT / Azure / GCP / InfluxDB Cloud / generischer Webhook

  • 10 · Fehlerbehebung — MQTT-Verbindungsabbruch-Muster, Signalbehandlung, TLS-Heap-Budget


Quelle & Issues: rb-amp/rbamp-python · diese Seite im Repo: docs/07_diy_integrations.md (v1.6.1)