rbAmp
PT
Loja

Projeto · · 13 min de leitura

Vários circuitos a partir de um único Raspberry Pi: um barramento rbAmp multimódulo em Python

Dois ou três módulos rbAmp no barramento I²C de um Raspberry Pi, travados em conjunto com uma única transmissão broadcast: potência por circuito e um total coerente, em Python simples.

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:

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
  • 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:

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.")

(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:

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

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

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)

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.

Python
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

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

É 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.

Leia a seguir