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:
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:
"""
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:
[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
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.
print_live() — pro Modul + laufende Summe
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
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.