rbAmp
FR
Boutique

Projet · · lecture de 13 min

Plusieurs circuits sur un seul Raspberry Pi : un bus multimodule rbAmp en Python

Deux ou trois modules rbAmp sur le bus I²C d'un Raspberry Pi, verrouillés ensemble par une seule diffusion : puissance par circuit et total cohérent, en Python simple.

Ce que vous allez construire

  • Par circuit : tension / courant / puissance active de chaque module, lus par le Pi.
  • Une puissance active totale cohérente — la somme des modules, tous verrouillés au même instant, et non trois lectures prises à trois moments différents (pourquoi c'est important).

  • Tout sur un seul bus I²C, un seul Pi, en Python simple.

Nomenclature

Élément Qté Remarques
rbAmp BASIC SCT-UI1 3 une par circuit · produit
TC SCT-013 3 un par module, calibre par circuit · produit
Raspberry Pi 1 tout modèle doté de l'en-tête I²C 40 broches
Fils de liaison — le bus I²C partagé

Câblez le bus partagé

Tous les modules sont sur les mêmes broches I²C du Pi — ils ne diffèrent que par leur adresse :

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
  • Alimentez chaque module en 5 V (les broches 5 V du Pi) ; le bus est en logique 3.3 V (pourquoi ?). Chaque module embarque des tirages — avec deux ou trois modules sur un bus de jusqu'à 15 cm, laissez-les actifs sur chaque module ; à partir de quatre modules, ou sur un bus plus long, suivez la documentation matérielle du module.

  • Les TC se placent autour de leurs conducteurs — non invasif côté courant. Pour toute intervention dans un tableau électrique, faites appel à un électricien qualifié.

Donnez une adresse à chaque module

Les modules sortent d'usine à 0x50 ; attribuez donc à la deuxième et à la troisième une adresse unique (0x51, 0x52) avant qu'elles partagent un bus. Sur le micrologiciel actuel, c'est une opération de production ordinaire — ni mode spécial ni outillage : préparer, armer, valider ; le module redémarre à sa nouvelle adresse. Faites-le un module à la fois, les autres débranchés, pour éviter tout conflit — les fonctions prepare_address_change() / commit_address_change() de la bibliothèque s'en chargent.

Synchronisez, puis lisez

Au lieu de lire trois modules l'un après l'autre (chacun pris à un instant légèrement différent), vous envoyez une diffusion « verrouiller maintenant » à tout le bus — chaque module fige sa fenêtre au même instant. Vous lisez ensuite l'instantané figé de chaque module, tour à tour. Les lectures sont séquentielles, mais les valeurs appartiennent toutes au même moment, donc les additionner est honnête. C'est le principe de cohérence triphasée, ici en Python.

Le script

Définissez FLEET_ADDRS et MY_CT pour vos modules puis lancez 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.")

(Exécution vérifiée avec le backend de simulation de la bibliothèque Python rbAmp sur CPython 3.12 — rbamp 1.3.0 + smbus2 0.6.1. Utilise le verrouillage de diffusion RbAmpFleet de la v1.3+, et non le verrouillage séquentiel module par module. check_sync() signale tout module ayant manqué la diffusion, pour qu'un module mal câblé ou non provisionné soit évident.)

Ce que vous verrez

Lignes en direct chaque seconde avec un total cumulé, et une ligne d'énergie synchronisée toutes les 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

Ce que fait le script

RbAmpFleet gère la comptabilité du parc ; trois fonctions font le travail — enrol_fleet() au démarrage, puis print_live() et roll_gc_energy() sur leurs propres cadences.

enrol_fleet() — mettre les modules en service

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)

Met en service chaque module à son adresse explicite (sans balayage du bus, pour que vous voyiez les adresses dans le tutoriel), vérifie puis règle son préréglage de TC (sans écriture inutile en flash) et l'ajoute au parc. Un module qui échoue à begin() est signalé et ignoré — le parc garde les autres, donc une mauvaise connexion ne fait pas échouer toute l'exécution.

Python
for m in fleet:
    v = m.voltage; i = m.current[0]; p = m.power[0]
    total_p += p

Parcourt le parc et lit le V / I / P en direct de chaque module pour l'affichage, en additionnant la puissance de chaque module en un total en direct de tout le tableau. Ces lectures en direct n'ont pas besoin d'être synchronisées — elles servent à l'affichage.

roll_gc_energy() — la partie cohérente

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

C'est pourquoi le total est fiable. gc_latch() diffuse une trame General-Call à l'adresse 0x00 — chaque module activé fige sa fenêtre de période au même instant. check_sync() lit ensuite le REG_GC_TICK de chaque module et signale ceux qui ont manqué la diffusion (affiche une ligne MISSED gc tick et ignore ce module pour la fenêtre — les modules sains continuent). Puis read_period_snapshot(skip_latch=True) lit chaque fenêtre déjà figée sans reverrouiller, et fleet.total_energy_wh() additionne le parc. Comme chaque module a été verrouillé ensemble, les Wh additionnés sont cohérents — pas trois lectures prises à trois moments différents. Cette ligne de santé check_sync est exactement ce que l'on instrumenterait dans une installation réelle.

Adaptez-le à votre installation

  • Davantage de circuits — ajoutez des modules sur le bus, attribuez à chacun une adresse ; ils rejoignent le parc. Surveillez les règles de charge du bus et de tirage (pull-up) à mesure que le nombre augmente.

  • Journalisez le tableau — une ligne par module et par intervalle en CSV ou SQLite (le montage d'enregistrement).

  • Servez-le — exposez le total par circuit et global comme point d'accès Flask ou publiez-le via MQTT — en local, sans cloud.
  • Actions par circuit — déclenchez un relais par module au-delà de sa propre limite (le montage à relais).
  • Parcs indépendants — des group_id différents permettent à des groupes sans rapport de se verrouiller à leur propre cadence, le tout sur un seul bus.

Pour aller plus loin

  • Agissez — déclenchez un relais GPIO quand un circuit franchit une limite de courant.
  • Journalisez-le — énergie périodique par circuit en CSV ou SQLite.
  • Vous préférez Home Assistant ? Le même bus multimodule est le tableau complet sur un ESP32 avec ESPHome.

À lire ensuite