rbAmp
DE
Shop

Projekt · · 13 Min. Lesezeit

Mehrere Stromkreise von einem Raspberry Pi: ein Mehrmodul-rbAmp-Bus in Python

Zwei oder drei rbAmp-Module auf dem I²C-Bus eines Raspberry Pi, mit einem Broadcast gemeinsam gelatcht: Leistung pro Stromkreis und eine kohärente Gesamtsumme, in einfachem Python.

Was Sie bauen werden

  • Pro Stromkreis Spannung / Strom / Wirkleistung von jedem Modul, vom Pi ausgelesen.
  • Eine kohärente Gesamtwirkleistung — die Summe der Module, alle auf demselben Moment gelatcht, nicht drei zu drei verschiedenen Zeitpunkten genommene Messwerte (warum das wichtig ist).

  • Alles auf einem I²C-Bus, ein Pi, in einfachem Python.

Stückliste

Position Menge Hinweise
rbAmp BASIC SCT-UI1 3 eine pro Stromkreis · Produkt
SCT-013-CT 3 eine pro Modul, Nennwert pro Stromkreis · Produkt
Raspberry Pi 1 jedes Modell mit der 40-poligen I²C-Leiste
Steckbrücken — der gemeinsame I²C-Bus

Den gemeinsamen Bus verdrahten

Alle Module sitzen auf denselben Pi-I²C-Pins — sie unterscheiden sich nur durch die Adresse:

Text
Raspberry Pi          module A (0x50)   module B (0x51)   module C (0x52)
------------          ---------------   ---------------   ---------------
SDA (GPIO2) ────┬────── SDA ────┬────── SDA ────┬────── SDA
SCL (GPIO3) ────┼────── SCL ────┼────── SCL ────┼────── SCL
5V          ────┼────── VCC     ├────── VCC     ├────── VCC
GND         ────┴────── GND ────┴────── GND ────┴────── GND
                        │                │                │
                     CT on circuit A   CT on B          CT on C
  • Versorgen Sie jedes Modul mit 5 V (die 5-V-Pins des Pi); der Bus arbeitet mit 3.3-V-Logik (warum?). Jedes Modul hat Pull-ups an Bord — bei zwei oder drei Modulen an einem Bus bis 15 cm lassen Sie sie an jedem Modul aktiv; ab vier Modulen oder bei einem längeren Bus folgen Sie der Hardware-Dokumentation des Moduls.

  • CTs legen sich um ihre Leiter — auf der Stromseite berührungslos. Für Arbeiten im Inneren eines Elektroverteilers sollten Sie eine qualifizierte Elektrofachkraft hinzuziehen.

Jedem Modul eine Adresse geben

Module werden mit 0x50 ausgeliefert; weisen Sie dem zweiten und dritten eine eindeutige Adresse zu (0x51, 0x52), bevor sie sich einen Bus teilen. In der aktuellen Firmware ist dies ein gewöhnlicher Produktionsbetrieb — kein Spezialmodus, keine Spezialwerkzeuge: vorbereiten, scharf schalten, bestätigen; das Modul startet an seiner neuen Adresse neu. Tun Sie dies jeweils nur an einem Modul, bei abgeklemmtem anderen, damit es keinen Konflikt gibt — die Funktionen prepare_address_change() / commit_address_change() der Bibliothek erledigen das.

Synchronisieren, dann lesen

Statt drei Module nacheinander auszulesen (jedes in einem leicht anderen Moment erfasst), senden Sie einen Broadcast „jetzt latchen“ an den gesamten Bus — jedes Modul friert sein Fenster im selben Moment ein. Dann lesen Sie den eingefrorenen Schnappschuss jedes Moduls nacheinander aus. Die Lesevorgänge erfolgen zwar sequenziell, aber alle Werte gehören zum selben Moment, daher ist das Summieren ehrlich. Es ist das Kohärenzprinzip für Drehstrom, hier in Python.

Das Skript

Setzen Sie FLEET_ADDRS und MY_CT für Ihre Module und führen Sie python tp2_multimodule_pi_monitor.py aus:

Python
"""
T-P2 — Multi-module Raspberry Pi bus (per-circuit + coherent whole-panel total).

Three rbAmp UI1 modules share the Pi's one I2C bus, each measuring its own
circuit's mains. The v1.3+ General-Call broadcast latches all three period
accumulators on the same instant so the summed Wh total is honest -- every
module integrates the same wall-clock window, no per-module drift.

Wiring (Raspberry Pi, hardware I2C, three modules in parallel on the same bus):
    Every rbAmp:  SDA -> GPIO2  (Pi pin 3)
                  SCL -> GPIO3  (Pi pin 5)
                  GND -> any GND pin
                  VCC -> 5V     (Pi pin 2 or 4)
                       ^ rbAmp needs 5V for its analog front-end. Only the
                         I2C logic level is 3.3V (handled internally).
    Optional external 4.7 kOhm pull-ups on SDA and SCL to 3.3V. The Pi has
    on-board 1.8 kOhm pull-ups which are usually enough for two or three
    modules on a short bus; add external pull-ups if you see NACKs on longer
    runs or with more devices.

Unique addresses: modules ship at 0x50. To make three of them coexist on
one bus, provision the extras once with the address-change flow
(`prepare_address_change` -> `commit_address_change`). That is a separate
one-time step; this tutorial assumes the three addresses are already
0x50 / 0x51 / 0x52.

Enable I2C once on the Pi (same as T-P1):
    sudo raspi-config    # Interface Options -> I2C -> Enable

The stock 100 kHz Broadcom I2C kernel driver is clean; no
`dtparam=i2c_arm_baudrate` override needed.

Install:
    pip install rbamp smbus2

Run:
    python tp2_multimodule_pi_monitor.py
    # or with a custom fleet:
    #   python tp2_multimodule_pi_monitor.py --addr 0x50 --addr 0x51 --addr 0x52

Accuracy: per clamp rating — the class and the sensor's own tolerance are both in the accuracy table on the BASIC page.
Ctrl-C to stop.
"""

import argparse
import time

from smbus2 import SMBus

from rbamp import (
    RbAmp,
    RbAmpFleet,
    RbAmpError,
    RbAmpStaleError,
    RbAmpSensorClass,
)

# ---- configuration --------------------------------------------------------
FLEET_ADDRS = [0x50, 0x51, 0x52]   # provisioned addresses of the 3 modules
MY_CT       = 3                    # SCT-013-030 for every module (edit per-mod if needed)

LIVE_S      = 1.0    # refresh per-module live V/I/P each second
ENERGY_S    = 30.0   # broadcast a GC latch + roll total Wh every 30 s
GC_GROUP    = 0      # 0 = all-call (every GC-enabled module latches)


def ensure_ct_preset(dev, ct_code):
    """Verify-then-set: rewrite CT preset only if it actually differs. See T-P1."""
    try:
        applied = dev.read_ct_model_ch(0)
    except RbAmpError:
        applied = -1
    if applied == ct_code:
        return False
    dev.set_sensor_class(RbAmpSensorClass.SCT_013)
    dev.set_ct_model_ch(0, ct_code)
    return True


def enrol_fleet(bus, addrs, ct_code):
    """Bring up N modules at explicit addresses (no bus scan). Any module that
    fails begin() is reported and skipped -- the fleet keeps the rest."""
    fleet = RbAmpFleet(bus)
    for a in addrs:
        try:
            dev = RbAmp(bus, addr=a)
            dev.begin()
        except RbAmpError as e:
            print(f"[0x{a:02X}] enrol FAILED: {type(e).__name__} -- {e}")
            continue
        rewrote = ensure_ct_preset(dev, ct_code)
        note = "CT rewritten" if rewrote else "CT already set"
        print(f"[0x{a:02X}] enrolled  fw=0x{dev.firmware_version:02X}  "
              f"topology={dev.topology_name}  ch={dev.channels}  ({note})")
        fleet.add(dev)
    return fleet


def print_live(fleet):
    """One live row: per-module V / I / P plus a fleet total P line."""
    total_p = 0.0
    parts = []
    for m in fleet:
        try:
            v = m.voltage
            i = m.current[0]
            p = m.power[0]
        except RbAmpError:
            parts.append(f"[0x{m.address:02X}]  --- V   --- A   ---- W")
            continue
        total_p += p
        parts.append(f"[0x{m.address:02X}] {v:6.1f}V {i:5.2f}A {p:6.0f}W")
    total_wh = fleet.total_energy_wh()
    print("  ".join(parts) + f"  |  totP={total_p:7.0f}W  totE={total_wh:9.4f}Wh")


def roll_gc_energy(fleet):
    """One GC-synchronised period window across the whole fleet.

      1. gc_latch() broadcasts the 5-byte GC frame `A5 27 group tick_lo tick_hi`
         at I2C general-call address 0x00. Every GC-enabled module with a
         matching group latches its period accumulator on the same clock edge.
      2. Sleep the settle window (inside gc_latch).
      3. check_sync() reads REG_GC_TICK per module; any stale/NACK -> missed.
      4. Per in-sync module, read_period_snapshot(settle_ms=0, skip_latch=True)
         reads the already-latched values -- no per-module latch, no settle.
    """
    tick = fleet.gc_latch(group=GC_GROUP)          # auto-increments internal counter
    sync = fleet.check_sync(expected_tick=tick)

    missed = [s for s in sync if not s.in_sync]
    if missed:
        for s in missed:
            print(f"  * [0x{s.addr:02X}] MISSED gc tick "
                  f"(got=0x{s.gc_tick:04X} expected=0x{tick:04X} reachable={s.reachable})")

    for m, s in zip(fleet, sync):
        if not s.in_sync:
            continue
        try:
            snap = m.read_period_snapshot(settle_ms=0, skip_latch=True)
        except RbAmpStaleError:
            print(f"  * [0x{m.address:02X}] period STALE (in_sync but slave says stale)")
            continue
        except RbAmpError as e:
            print(f"  * [0x{m.address:02X}] period skipped: {type(e).__name__} -- {e}")
            continue
        print(f"  * [0x{m.address:02X}] avg_P={snap.avg_p[0]:6.1f}W  "
              f"dt={snap.master_dt_ms:5d}ms  E={m.energy.wh(0):8.4f}Wh")

    print(f"  * tick=0x{tick:04X}  in_sync={sum(1 for s in sync if s.in_sync)}/{len(sync)}  "
          f"fleet totE={fleet.total_energy_wh():.4f}Wh")


def run(bus, addrs=None, ct_code=MY_CT,
        live_s=LIVE_S, energy_s=ENERGY_S, max_iters=None):
    if addrs is None:
        addrs = FLEET_ADDRS
    fleet = enrol_fleet(bus, addrs, ct_code)
    if len(fleet) == 0:
        print("no modules enrolled -- check wiring and addresses; exiting")
        return
    enabled = fleet.enable_gc_all(group=GC_GROUP)
    print(f"GC latch enabled on {enabled}/{len(fleet)} module(s), group={GC_GROUP}")
    print("Accuracy: per clamp rating — see the BASIC page. Ctrl-C to stop.\n")

    next_live_t   = time.monotonic()
    next_energy_t = next_live_t + energy_s
    iters = 0

    while True:
        now = time.monotonic()
        if now >= next_live_t:
            next_live_t = now + live_s
            print_live(fleet)
        if now >= next_energy_t:
            next_energy_t = now + energy_s
            roll_gc_energy(fleet)

        iters += 1
        if max_iters is not None and iters >= max_iters:
            return fleet

        sleep_for = min(next_live_t, next_energy_t) - time.monotonic()
        if sleep_for > 0:
            time.sleep(sleep_for)


def main():
    ap = argparse.ArgumentParser(
        description="Multi-module Raspberry Pi rbAmp bus with fleet GC-latch energy sync."
    )
    ap.add_argument("--bus",  type=int, default=1,
                    help="I2C bus number (Raspberry Pi default: 1)")
    ap.add_argument("--addr", type=lambda s: int(s, 0), action="append",
                    default=None,
                    help="rbAmp address (repeatable; default: 0x50 0x51 0x52)")
    ap.add_argument("--ct",   type=int, default=MY_CT,
                    help="CT model code (1=SCT-013-005, 2=-010, 3=-030, "
                         "4=-050, 6=-020)")
    args = ap.parse_args()

    addrs = args.addr if args.addr else FLEET_ADDRS

    with SMBus(args.bus) as bus:
        run(bus, addrs=addrs, ct_code=args.ct)


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\nstopped.")

(Lauffähig gegen das Mock-Backend der rbAmp-Python-Bibliothek auf CPython 3.12 geprüft — rbamp 1.3.0 + smbus2 0.6.1. Verwendet den v1.3+-RbAmpFleet-Broadcast-Latch, nicht das sequenzielle Latchen pro Modul. check_sync() meldet jedes Modul, das den Broadcast verpasst hat, sodass ein falsch verdrahtetes oder nicht eingerichtetes Modul offensichtlich wird.)

Was Sie sehen werden

Live-Zeilen pro Sekunde mit laufender Summe, und alle 30 s eine synchronisierte Energiezeile:

Text
[0x50] enrolled  fw=0x04  topology=SINGLE  ch=1  (CT already set)
[0x51] enrolled  fw=0x04  topology=SINGLE  ch=1  (CT already set)
[0x52] enrolled  fw=0x04  topology=SINGLE  ch=1  (CT already set)
GC latch enabled on 3/3 module(s), group=0

[0x50]  230.5V  3.52A    812W  [0x51]  230.5V  1.93A    445W  [0x52]  230.5V  5.37A   1237W  |  totP=   2494W  totE=   0.0000Wh
  * [0x50] avg_P= 795.8W  dt= 3253ms  E=  0.7191Wh
  * [0x51] avg_P= 436.1W  dt= 3203ms  E=  0.3880Wh
  * [0x52] avg_P=1212.3W  dt= 3152ms  E=  1.0614Wh
  * tick=0x0001  in_sync=3/3  fleet totE=2.1685Wh

Was das Skript macht

RbAmpFleet übernimmt die Verwaltung des Verbunds; drei Funktionen führen das Programm aus — enrol_fleet() beim Start, dann print_live() und roll_gc_energy() in ihren eigenen Takten.

enrol_fleet() — die Module hochfahren

Python
fleet = RbAmpFleet(bus)
for a in [0x50, 0x51, 0x52]:
    dev = RbAmp(bus, addr=a); dev.begin()
    ensure_ct_preset(dev, MY_CT)
    fleet.add(dev)

Bringt jedes Modul an seiner ausdrücklichen Adresse hoch (kein Bus-Scan, sodass Sie die Adressen im Tutorial sehen), prüft und setzt dann seine CT-Voreinstellung (kein unnötiger Flash-Schreibvorgang) und fügt es dem Verbund hinzu. Ein Modul, bei dem begin() fehlschlägt, wird gemeldet und übersprungen — der Verbund behält die übrigen, sodass eine fehlerhafte Verbindung nicht den gesamten Lauf zum Scheitern bringt.

Python
for m in fleet:
    v = m.voltage; i = m.current[0]; p = m.power[0]
    total_p += p

Durchläuft den Verbund und liest für jedes Modul die Live-Werte V / I / P zur Anzeige aus; die Leistung der einzelnen Module wird zu einer Live-Gesamtsumme des gesamten Verteilers addiert. Diese Live-Lesungen müssen nicht synchronisiert sein — sie dienen der Anzeige.

roll_gc_energy() — der kohärente Teil

Python
tick = fleet.gc_latch(group=0)                 # ONE broadcast latches every module together
sync = fleet.check_sync(expected_tick=tick)    # did each accept the tick?
for m, s in zip(fleet, sync):
    if not s.in_sync:                          # dropped / GC-disabled / wrong group
        continue
    snap = m.read_period_snapshot(settle_ms=0, skip_latch=True)   # read the frozen window

Deshalb ist die Summe vertrauenswürdig. gc_latch() sendet einen General-Call-Frame an die Adresse 0x00 — jedes aktivierte Modul friert sein Periodenfenster im selben Moment ein. check_sync() liest dann das REG_GC_TICK jedes Moduls und markiert jedes, das den Broadcast verpasst hat (gibt eine MISSED gc tick-Zeile aus und überspringt dieses Modul für das Fenster — die gesunden laufen weiter). Dann liest read_period_snapshot(skip_latch=True) jedes bereits eingefrorene Fenster ohne erneutes Latchen, und fleet.total_energy_wh() summiert den Verbund. Da alle Module gemeinsam gelatcht haben, ist die summierte Wh kohärent — nicht drei Messungen zu drei verschiedenen Momenten. Genau diese check_sync-Zustandszeile würden Sie in einer echten Installation instrumentieren.

Passen Sie es an Ihre Bedürfnisse an

  • Weitere Stromkreise — Module auf dem Bus ergänzen und jedem eine Adresse zuweisen; sie treten dem Verbund bei. Achten Sie bei wachsender Anzahl auf die Regeln zu Buslast und Pull-up-Widerständen.

  • Den Verteiler protokollieren — eine Zeile pro Modul und Intervall in CSV oder SQLite (der Logger-Aufbau).

  • Bereitstellen — den Wert pro Stromkreis sowie die Gesamtsumme als Flask-Endpunkt bereitstellen oder über MQTT veröffentlichen — lokal, ohne Cloud.
  • Aktionen pro Stromkreis — ein Relais pro Modul auslösen, sobald es seinen eigenen Grenzwert überschreitet (der Relaisaufbau).
  • Unabhängige Verbünde — unterschiedliche group_ids lassen nicht zusammenhängende Gruppen in ihrem eigenen Takt latchen, alles auf einem Bus.

Wie es weitergeht

  • Handeln — ein GPIO-Relais auslösen, sobald ein Stromkreis eine Stromgrenze überschreitet.
  • Protokollieren — periodische Energie pro Stromkreis in CSV oder SQLite.
  • Lieber Home Assistant? Derselbe Mehrmodul-Bus ist der gesamte Verteiler an einem ESP32 mit ESPHome.

Als Nächstes lesen