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 :
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 :
"""
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 :
[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
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.
print_live() — par module + total courant
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
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_iddiffé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.