Lo que va a construir
- Por circuito: tensión / corriente / potencia real de cada módulo, leídas por la Pi.
-
Una potencia activa total coherente: la suma de los módulos, todos fijados en el mismo instante, no tres lecturas tomadas en tres momentos distintos (por qué importa).
-
Todo en un bus I²C, una Pi, en Python sencillo.
Lista de materiales
| Elemento | Cant. | Notas |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 3 | una por circuito · producto |
| CT SCT-013 | 3 | una por módulo, calibre por circuito · producto |
| Raspberry Pi | 1 | cualquier modelo con el cabezal I²C de 40 pines |
| Cables de puente | — | el bus I²C compartido |
Cablee el bus compartido
Todos los módulos están en los mismos pines I²C de la Pi: solo se diferencian por la dirección:
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
-
Alimente cada módulo a 5 V (los pines de 5 V de la Pi); el bus es lógica de 3.3 V (¿por qué?). Cada módulo tiene pull-ups integradas: con dos o tres módulos en un bus de hasta 15 cm, déjelas activas en todos los módulos; a partir de cuatro módulos, o en un bus más largo, siga el documento de hardware del módulo.
-
Las CT se colocan alrededor de sus conductores: no invasivas en el lado de corriente. Para trabajar dentro de un cuadro eléctrico, llame a un electricista cualificado.
Asigne una dirección a cada módulo
Los módulos salen de fábrica en 0x50, así que asigne al segundo y al tercero una dirección única (0x51, 0x52) antes de que compartan bus. En el firmware actual esto es una operación de producción normal, sin modo especial ni herramientas: prepare, arme, confirme; el módulo se reinicia en su nueva dirección. Hágalo un módulo cada vez, con los demás desconectados, para que no haya colisión: la función prepare_address_change() / commit_address_change() de la biblioteca se encarga.
Sincronice y luego lea
En lugar de leer tres módulos uno tras otro (cada uno captado en un momento ligeramente distinto), envía un «latch ahora» de difusión a todo el bus: cada módulo congela su ventana en el mismo instante. Después lee la instantánea congelada de cada módulo por turno. Las lecturas son secuenciales, pero los valores pertenecen todos al mismo momento, así que sumarlos es honesto. Es el principio de coherencia trifásica, aquí en Python.
El script
Configure FLEET_ADDRS y MY_CT para sus módulos y ejecute python tp2_multimodule_pi_monitor.py:
"""
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.")
(Verificado en ejecución con el backend simulado de la biblioteca Python de rbAmp en CPython 3.12: rbamp 1.3.0 + smbus2 0.6.1. Usa el latch de difusión RbAmpFleet de la v1.3+, no el latch secuencial por módulo. check_sync() informa de cualquier módulo que haya perdido la difusión, de modo que un módulo mal cableado o sin provisionar salta a la vista.)
Lo que verá
Filas de lectura en vivo por segundo con un total acumulado, y una línea de energía sincronizada cada 30 s:
[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
Qué hace el script
RbAmpFleet lleva la contabilidad de la flota; tres funciones dirigen el funcionamiento: enrol_fleet() al arrancar, y después print_live() y roll_gc_energy() con sus propias cadencias.
enrol_fleet(): pone en marcha los módulos
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)
Pone en marcha cada módulo en su dirección explícita (sin escaneo del bus, así que verá las direcciones en el tutorial), verifica y luego fija su preajuste de CT (sin escritura innecesaria en flash) y lo añade a la flota. Un módulo que falla en begin() se notifica y se omite: la flota sigue con el resto, así que una mala conexión no hunde toda la ejecución.
print_live(): por módulo más el total corriente
for m in fleet:
v = m.voltage; i = m.current[0]; p = m.power[0]
total_p += p
Recorre la flota y lee la V / I / P en vivo de cada módulo para mostrarla, sumando la potencia de cada módulo en un total en vivo de todo el cuadro. Estas lecturas en vivo no necesitan estar sincronizadas: son para la visualización.
roll_gc_energy(): la parte coherente
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
Por esto el total es fiable. gc_latch() difunde una trama General-Call a la dirección 0x00: cada módulo habilitado congela su ventana de periodo en el mismo instante. Después check_sync() lee el REG_GC_TICK de cada módulo y marca cualquiera que haya perdido la difusión (imprime una línea MISSED gc tick y omite ese módulo en la ventana; los sanos siguen acumulando). Luego read_period_snapshot(skip_latch=True) lee cada ventana ya congelada sin volver a fijarla, y fleet.total_energy_wh() suma la flota. Como todos los módulos se fijaron juntos, los Wh sumados son coherentes, no tres lecturas tomadas en tres momentos distintos. Esa línea de salud de check_sync es exactamente lo que instrumentaría en una instalación real.
Adáptelo a su instalación
-
Más circuitos: añada módulos al bus y asigne a cada uno una dirección; se unen a la flota. Tenga en cuenta las reglas de carga del bus y de resistencias pull-up a medida que aumenta el número.
-
Registre el cuadro: una fila por módulo y por intervalo en CSV o SQLite (la versión de registro).
- Sírvalo: exponga el valor por circuito y el total como endpoint de Flask o publíquelo por MQTT: en local, sin nube.
- Acciones por circuito: dispare un relé por módulo cuando supere su propio límite (la versión con relé).
- Flotas independientes: distintos
group_idpermiten que grupos sin relación se fijen con su propia cadencia, todos en un mismo bus.
Qué sigue
- Actúe: dispare un relé GPIO cuando un circuito supere un límite de corriente.
- Regístrelo: energía periódica por circuito en CSV o SQLite.
- ¿Prefiere Home Assistant? El mismo bus multimódulo es todo el cuadro en un ESP32 con ESPHome.