rbAmp
ES
Tienda

Proyecto · · 13 min de lectura

Varios circuitos desde una sola Raspberry Pi: un bus multimódulo rbAmp en Python

Dos o tres módulos rbAmp en el bus I²C de una Raspberry Pi, fijados juntos con un único broadcast: potencia por circuito y un total coherente, en Python sencillo.

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:

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

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

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

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

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)

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.

Python
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

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 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_id permiten 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.

Lea a continuación