Was Sie bauen werden
- Live-Spannung, Strom, Wirkleistung und Leistungsfaktor, etwa einmal pro Sekunde im Terminal ausgegeben.
- Eine laufende Energie-(Wh)-Summe, auf dem Pi über Wanduhrzeit integriert.
- Alles auf dem I²C-Bus des Pi — vier Drähte — in reinem CPython.
- Kein WLAN-Dienst, keine Cloud, kein HA. Nur ein Skript, das Sie ausführen.
Stückliste
| Position | Menge | Hinweise |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 1 | Spannung + Strom + Wirkleistung auf dem Chip · Produkt |
| SCT-013-Stromwandler | 1 | Nennwert passend zu Ihrem Stromkreis · Produkt |
| Raspberry Pi | 1 | jedes Modell mit der 40-poligen I²C-Leiste |
| Steckbrücken | — | der I²C-Bus (SDA / SCL / 5V / GND) |
I²C aktivieren und die Bibliothek installieren
Schalten Sie am Pi die I²C-Schnittstelle einmal ein — sudo raspi-config → Interface Options → I2C → aktivieren (oder fügen Sie dtparam=i2c_arm=on zu /boot/firmware/config.txt hinzu und starten Sie neu). Installieren Sie dann das Paket:
pip install rbamp smbus2
(Der I²C-Kerneltreiber des Pi läuft standardmäßig mit 100 kHz und kommt mit dem Modul gut zurecht — hier gibt es keinen 50-kHz-Workaround; der gilt nur für den ESP-IDF-Treiber am ESP32.)
Verdrahten
Das rbAmp-Modul kommt an die I²C-Pins des Pi:
Raspberry Pi header rbAmp (0x50)
------------------- ------------
pin 3 SDA (GPIO2) ────────── SDA
pin 5 SCL (GPIO3) ────────── SCL
pin 2 5V ────────── VCC (rbAmp wants 5 V)
pin 6 GND ────────── GND
│
└── SCT-013 clamped around ONE mains conductor (arrow → load)
-
Der I²C-Bus des Pi arbeitet mit 3.3-V-Logik, und das rbAmp-Modul hat Pull-ups an Bord — für ein einzelnes Modul also keine zusätzlichen Pull-ups. Versorgen Sie das Modul mit 5 V (die 5-V-Pins des Pi); die Buslinien liegen auf 3.3 V. (Warum 5-V-Versorgung, aber ein 3.3-V-Bus?)
-
Die SCT-013-Zangen legen sich um einen isolierten Leiter — für die Stromseite schneiden oder abisolieren Sie nie einen stromführenden Draht. Die Wechselspannungsseite wird am Netz angeschlossen. Für Arbeiten im Inneren eines Elektroverteilers sollten Sie eine qualifizierte Elektrofachkraft hinzuziehen.
Das Skript
Speichern Sie sie, setzen Sie MY_CT (oder übergeben Sie --ct), passend zu Ihrer Zange, und führen Sie python tp1_standalone_pi_monitor.py aus:
"""
T-P1 — Standalone Raspberry Pi energy monitor (no network, no HA).
One rbAmp UI1 module on the Raspberry Pi hardware I2C bus. Prints live
mains Voltage / Current / Power / Power Factor to the terminal every
second, and every 30 s latches a period snapshot to roll a host-side
Energy (Wh) total. Nothing is invented on-device: Wh is integrated on
the host from average power x wall-clock dt, which is what makes the
total honest.
Wiring (Raspberry Pi, hardware I2C):
rbAmp SDA -> GPIO2 (Pi pin 3)
rbAmp SCL -> GPIO3 (Pi pin 5)
rbAmp GND -> any GND pin
rbAmp VCC -> 5V (Pi pin 2 or 4; 4.5-5.5 V -- below 4.5 V the ADC loses accuracy)
Enable I2C once on the Pi:
sudo raspi-config # Interface Options -> I2C -> Enable
# (equivalent to `dtparam=i2c_arm=on`)
The stock Raspberry Pi Broadcom I2C driver runs at 100 kHz and is
clean with rbAmp straight out of the box -- no `dtparam=i2c_arm_baudrate`
override is needed. (The 50 kHz workaround only applies to the ESP-IDF
i2c_master driver on ESP32.)
Install:
pip install rbamp smbus2
Run:
python tp1_standalone_pi_monitor.py
# or with a non-default bus / address / CT model:
# python tp1_standalone_pi_monitor.py --bus 1 --addr 0x50 --ct 3
Set MY_CT below (or pass --ct) to match YOUR clamp before first run.
The value persists to the module's flash, so this script only re-writes
it when it actually differs -- no flash wear on every power-up.
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,
RbAmpError,
RbAmpStaleError,
RbAmpSensorClass,
)
# ---- configuration --------------------------------------------------------
# CT model code (matches your clamp; persists to module flash):
# 1 = SCT-013-005 (5 A) 4 = SCT-013-050 (50 A)
# 2 = SCT-013-010 (10 A) 6 = SCT-013-020 (20 A)
# 3 = SCT-013-030 (30 A)
MY_CT = 3
LIVE_S = 1.0 # refresh V/I/P/PF each second
ENERGY_S = 30.0 # latch a period + roll Wh every 30 s
def ensure_ct_preset(dev, ct_code):
"""Verify-then-set: only rewrite the CT preset if the module isn't
already on it. set_sensor_class / set_ct_model_ch both persist to
flash, so this avoids a needless flash write every power-up.
"""
try:
applied = dev.read_ct_model_ch(0)
except RbAmpError:
applied = -1
if applied == ct_code:
print(f"CT model already SCT_013 code={ct_code}; skipping flash write")
return False
print(f"configuring CT model SCT_013 code={ct_code} (persists to flash)...")
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model_ch(0, ct_code)
return True
def read_live(dev, last, counters):
"""Read one live sample. A single transient hiccup keeps the previous
plausible reading so the terminal keeps ticking (mirrors the Arduino
T-A1 NaN-guard)."""
try:
v = dev.voltage
i = dev.current[0]
p = dev.power[0]
pf = dev.power_factor[0]
except RbAmpError as e:
counters["bad"] += 1
print(f"read skipped: {type(e).__name__} -- {e}")
return
last["V"], last["I"], last["P"], last["PF"] = v, i, p, pf
counters["ok"] += 1
print(
f"U={v:6.1f}V I={i:6.3f}A P={p:7.1f}W PF={pf:+.2f} "
f"E={dev.energy.wh(0):8.4f}Wh "
f"[ok={counters['ok']} bad={counters['bad']}]"
)
def roll_energy(dev):
"""Latch a metering period; the library rolls Wh from avg power x master
dt on a successful valid snapshot. A stale / not-ready period is reported
and skipped so the loop keeps running on the last live values."""
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
print(" * period STALE (skipped)")
return
except RbAmpError as e:
print(f" * period skipped: {type(e).__name__} -- {e}")
return
print(
f" * period ok: avg_P0={snap.avg_p[0]:6.2f}W "
f"dt={snap.master_dt_ms:5d}ms -> E={dev.energy.wh(0):.4f}Wh"
)
def run(bus, addr=0x50, ct_code=MY_CT,
live_s=LIVE_S, energy_s=ENERGY_S, max_iters=None):
"""Core loop; broken out so a test harness can swap in a mock bus."""
with RbAmp(bus, addr) as dev:
print(
f"rbAmp @ 0x{dev.address:02X} fw=0x{dev.firmware_version:02X} "
f"topology={dev.topology_name} channels={dev.channels} "
f"voltage_hw={'yes' if dev.has_voltage_hw else 'no'}"
)
ensure_ct_preset(dev, ct_code)
print("Accuracy: per clamp rating — see the BASIC page. Ctrl-C to stop.\n")
last = {"V": 0.0, "I": 0.0, "P": 0.0, "PF": 0.0}
counters = {"ok": 0, "bad": 0}
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
read_live(dev, last, counters)
if now >= next_energy_t:
next_energy_t = now + energy_s
roll_energy(dev)
iters += 1
if max_iters is not None and iters >= max_iters:
return counters
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="Standalone Raspberry Pi energy monitor for a single rbAmp UI1 module."
)
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), default=0x50,
help="rbAmp I2C address (default: 0x50)")
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 (default: 3 = 30 A)")
args = ap.parse_args()
with SMBus(args.bus) as bus:
run(bus, addr=args.addr, ct_code=args.ct)
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
print("\nstopped.")
(Lauffähig gegen das Test-Backend der rbAmp-Python-Bibliothek auf CPython 3.12 geprüft — rbamp 1.3.0 + smbus2 0.6.1. set_ct_model_ch() speichert im Flash, daher schreibt das Skript die CT-Voreinstellung nur neu, wenn sie sich tatsächlich unterscheidet — kein Flash-Verschleiß bei jedem Lauf. Der Kern run() ist ausgelagert, damit er leicht zu testen oder wiederzuverwenden ist.)
Was das Skript macht
Die gesamte rbAmp-Python-Bibliothek passt in ein paar with-Blöcke und eine Handvoll Lesevorgänge.
Die Kontextmanager
with SMBus(1) as bus:
with RbAmp(bus, 0x50) as dev:
...
SMBus(1) öffnet den I²C-Bus des Pi; RbAmp(bus, 0x50) bindet die Bibliothek an das Modul bei der Adresse 0x50. Beides sind Kontextmanager, daher werden Bus und Gerät automatisch aufgeräumt, wenn der Block verlassen wird (oder bei Strg-C) — die pythonische Version von „Bus öffnen, Modul prüfen“.
Die Live-Messungen
v = dev.voltage
i = dev.current[0]
p = dev.power[0]
pf = dev.power_factor[0]
Diese Eigenschaften liefern die echten Messwerte des Moduls: dev.power[0] ist echte Wirkleistung in Watt — der Mittelwert aus momentaner Spannung × Strom, nicht Strom × eine angenommene Spannung. (Die Methodenform dev.read_power(0) ist genau gleichwertig — nehmen Sie, was übersichtlicher liest.) Ein vorübergehender Lesefehler kann RbAmpError auslösen; das Skript fängt ihn ab und behält die letzten guten Werte, statt abzustürzen.
Energie — der Periodenschnappschuss
snap = dev.read_period_snapshot() # atomic LATCH: close the window, read avg power
print(dev.energy.wh(0)) # host-integrated watt-hours, honest over wall-clock time
read_period_snapshot() sendet dem Modul einen atomaren LATCH — „Messfenster jetzt schließen“ — und die Bibliothek rollt die Wattstunden-Summe auf dem Host aus average_power × elapsed_time fort. Der Pi besitzt das Integrationsintervall, daher gibt es keinen Gerätezähler, der driften könnte; dev.energy.wh(0) ist eine ehrliche laufende Summe. Ein veraltetes Fenster löst RbAmpStaleError aus, das das Skript einfach überspringt.
Was Sie sehen werden
Im Terminal eine Live-Anzeige, die der Last folgt — schalten Sie eine Lampe oder einen Wasserkocher ein und sehen Sie, wie die Watt springen:
rbAmp @ 0x50 fw=0x04 topology=SINGLE channels=1 voltage_hw=yes
CT model already SCT_013 code=3; skipping flash write
Accuracy: per clamp rating — see the BASIC page. Ctrl-C to stop.
U= 231.2V I= 4.874A P= 1123.5W PF=+1.00 E= 0.0000Wh [ok=1 bad=0]
U= 231.2V I= 4.874A P= 1123.5W PF=+1.00 E= 0.0000Wh [ok=2 bad=0]
* period ok: avg_P0=1119.40W dt= 50ms -> E=0.0622Wh
U= 231.2V I= 4.874A P= 1123.5W PF=+1.00 E= 0.0622Wh [ok=3 bad=0]
Wie genau ist es?
Bei einer SCT-013-Zange werden Klasse und eigene Toleranz der Zange pro Nennwert in der SCT-013-Genauigkeitstabelle veröffentlicht. Das Modul misst echte Wirkleistung mit kanalweiser Phasenkompensation — daher werden blindleistungsbehaftete und Lasten mit niedrigem Leistungsfaktor ehrlich angezeigt. Die Hintergründe zu den Zahlen: wie die CT-Energiemessung tatsächlich funktioniert.
Passen Sie es an Ihre Bedürfnisse an
-
In eine Datei oder SQLite protokollieren — der Pi hat ein echtes Dateisystem; hängen Sie jede Messung an CSV oder an eine Datenbank an (das ist der Logger-Aufbau).
-
Bereitstellen — der Pi ist vernetzt: Stellen Sie die Messwerte als kleinen Flask-Endpunkt bereit oder veröffentlichen Sie sie über MQTT an Ihren eigenen Broker — ganz ohne Cloud.
-
Eine Cron-Zusammenfassung — das Skript per Timer ausführen und sich täglich eine kWh-Summe per E-Mail schicken lassen.
- Ein Display ergänzen — ein kleines I²C-OLED auf demselben Bus für eine Anzeige ohne Bildschirm.
- Weitere Stromkreise — mehrere Module an den Bus setzen und summieren (das ist der Mehrmodul-Aufbau).
Nichts davon berührt die Messung — es ist das, was Sie mit den Werten tun, die die Lesevorgänge bereits liefern.
Wie es weitergeht
Dieses eine Modul im Terminal ist das Fundament. Von hier aus baut die Python-Reihe auf:
- Mehrere Stromkreise messen — mehrere rbAmp-Module an einem Bus, vom Pi gelesen und summiert.
- Handeln — ein GPIO-Relais auslösen, sobald ein Stromkreis einen Stromgrenzwert überschreitet.
- Protokollieren — periodische Energie in CSV oder SQLite.
(Lieber einen Mikrocontroller statt eines Pi? Dasselbe Modul läuft auf Arduino oder in Home Assistant über ESPHome.)