O que vai construir
- Tensão / corrente / potência ativa por circuito de cada módulo, lidas pelo Pi.
-
Uma potência ativa total coerente — a soma dos módulos, todos com latch no mesmo instante, e não três leituras tiradas em três momentos diferentes (porque é que isso importa).
-
Tudo num barramento I²C, um Pi, em Python simples.
Lista de materiais
| Item | Qtd. | Notas |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 3 | uma por circuito · produto |
| TC SCT-013 | 3 | uma por módulo, classificação por circuito · produto |
| Raspberry Pi | 1 | qualquer modelo com o cabeçalho I²C de 40 pinos |
| Fios de ligação (jumper) | — | o barramento I²C partilhado |
Ligue o barramento partilhado
Todos os módulos assentam nos mesmos pinos I²C do Pi — diferem apenas no endereço:
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 (os pinos de 5 V do Pi); o barramento é lógica de 3.3 V (porquê?). Cada módulo tem pull-ups integradas — com dois ou três módulos num barramento até 15 cm, deixe-as ativas em todos os módulos; a partir de quatro módulos, ou num barramento mais longo, siga o guia de hardware do módulo.
-
As pinças TC envolvem à volta dos seus condutores — não invasivas do lado da corrente. Para trabalhos dentro de um quadro elétrico, chame um eletricista qualificado.
Dê um endereço a cada módulo
Os módulos saem de fábrica com 0x50, por isso atribua ao segundo e ao terceiro um endereço único (0x51, 0x52) antes de partilharem um barramento. Na firmware atual isto é uma operação de produção normal — sem modo especial nem ferramentas: prepare, arme, confirme; o módulo reinicia no novo endereço. Faça-o um módulo de cada vez, com os outros desligados, para não haver colisão — as funções prepare_address_change() / commit_address_change() da biblioteca tratam disso.
Sincronize e depois leia
Em vez de ler três módulos um a seguir ao outro (cada um apanhado num instante ligeiramente diferente), envia um "latch já" broadcast para o barramento inteiro — cada módulo congela a sua janela no mesmo instante. Depois lê o instantâneo congelado de cada módulo, por turnos. As leituras são sequenciais, mas os valores pertencem todos ao mesmo momento, por isso somá-los é honesto. É o princípio de coerência trifásica, aqui em Python.
O script
Defina FLEET_ADDRS e MY_CT para os seus módulos e execute 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 em execução contra o backend simulado da biblioteca Python rbAmp em CPython 3.12 — rbamp 1.3.0 + smbus2 0.6.1. Usa o latch broadcast RbAmpFleet da v1.3+, não latch sequencial por módulo. check_sync() reporta qualquer módulo que não recebeu o broadcast, para que um módulo mal ligado ou não provisionado seja óbvio.)
O que verá
Linhas por segundo com total acumulado, e uma linha de energia sincronizada a 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
O que o script faz
RbAmpFleet trata da contabilidade da frota; três funções fazem o trabalho — enrol_fleet() no arranque, depois print_live() e roll_gc_energy() nas suas próprias cadências.
enrol_fleet() — colocar os módulos em funcionamento
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)
Inicia cada módulo no seu endereço explícito (sem varrimento do barramento, para ver os endereços no tutorial), verifica-e-define a sua predefinição de TC (sem escrita desnecessária na flash) e acrescenta-o à frota. Um módulo que falha begin() é reportado e ignorado — a frota mantém o resto, por isso uma ligação má não afunda a execução inteira.
print_live() — por módulo + total corrente
for m in fleet:
v = m.voltage; i = m.current[0]; p = m.power[0]
total_p += p
Percorre a frota e lê a V / I / P de cada módulo para apresentação, somando a potência de cada módulo num total do quadro inteiro. Estas leituras em tempo real não precisam de estar sincronizadas — são para o visor.
roll_gc_energy() — a parte coerente
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 isto que o total é fiável. gc_latch() envia uma trama General-Call ao endereço 0x00 — cada módulo ativo congela a sua janela de período no mesmo instante. check_sync() lê depois o REG_GC_TICK de cada módulo e assinala os que falharam o broadcast (imprime uma linha MISSED gc tick e salta esse módulo na janela — os saudáveis continuam a avançar). Depois read_period_snapshot(skip_latch=True) lê cada janela já congelada sem voltar a fazer latch, e fleet.total_energy_wh() soma a frota. Como todos os módulos fizeram latch em conjunto, os Wh somados são coerentes — não três leituras tiradas em três momentos diferentes. Essa linha de saúde do check_sync é exatamente o que instrumentaria numa instalação real.
Personalize-o
-
Mais circuitos — acrescente módulos ao barramento e atribua a cada um um endereço; entram na frota. Atenção às regras de carga do barramento e das pull-ups à medida que o número cresce.
-
Registe o quadro — uma linha por módulo e por intervalo em CSV ou SQLite (a construção de registo).
- Sirva-o — exponha o total por circuito e o global como endpoint Flask ou publique por MQTT — localmente, sem nuvem.
- Ações por circuito — dispare um relé por módulo acima do seu próprio limite (a construção com relé).
- Frotas independentes —
group_ids diferentes permitem a grupos não relacionados fazer latch na sua própria cadência, todos num só barramento.
O que se segue
- Atue sobre ela — dispare um relé GPIO quando um circuito ultrapassa um limite de corrente.
- Registe — energia periódica por circuito em CSV ou SQLite.
- Prefere o Home Assistant? O mesmo barramento multimódulo é o quadro inteiro num ESP32 com ESPHome.