Что вы соберёте
- По каждой цепи напряжение / ток / активная мощность с каждого модуля, считываемые Pi.
-
Согласованная суммарная активная мощность — сумма модулей, все защёлкнуты в один и тот же момент, а не три показания, снятые в три разных момента (почему это важно).
-
Всё на одной шине I²C, один Pi, на простом Python.
Спецификация
| Позиция | Кол-во | Примечания |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 3 | по одному на цепь · продукт |
| Клещи SCT-013 CT | 3 | по одному на модуль, номинал по цепи · продукт |
| Raspberry Pi | 1 | любая модель с 40-контактным разъёмом I²C |
| Перемычки | — | общая шина I²C |
Проводка общей шины
Все модули стоят на тех же выводах I²C Pi — отличаются только адресом:
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
-
Питайте каждый модуль от 5 В (выводы 5 В Pi); шина — логика 3.3 В (почему?). На каждом модуле есть встроенные подтяжки — с двумя или тремя модулями на шине длиной до 15 см оставьте их включёнными на каждом модуле; от четырёх модулей или на более длинной шине следуйте документу по аппаратной части модуля.
-
Клещи CT охватывают свои проводники снаружи — со стороны тока установка бесконтактная. Работы внутри электрощита поручите квалифицированному электрику.
Назначьте каждому модулю адрес
Модули поставляются с адресом 0x50, поэтому второму и третьему назначьте уникальный адрес (0x51, 0x52) до того, как они начнут делить шину. На текущей прошивке это обычная производственная операция — без особого режима и инструментов: задать, взвести, зафиксировать; модуль перезагружается на новом адресе. Делайте это по одному модулю за раз, с отключёнными остальными, чтобы не было конфликта — за это отвечают prepare_address_change() / commit_address_change() библиотеки.
Синхронизируйте, затем читайте
Вместо того чтобы читать три модуля один за другим (каждый фиксируется в немного другой момент), вы посылаете один широковещательный «защёлкнуть сейчас» на всю шину — каждый модуль замораживает окно в один и тот же момент. Затем по очереди читаете замороженный снимок каждого модуля. Чтения последовательные, но значения относятся к одному моменту, так что их суммирование честно. Это принцип согласованности трёх фаз, здесь на Python.
Скрипт
Задайте FLEET_ADDRS и MY_CT для ваших модулей и запустите 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.")
(Проверено запуском на mock-бэкенде библиотеки rbAmp для Python на CPython 3.12 — rbamp 1.3.0 + smbus2 0.6.1. Используется широковещательное защёлкивание RbAmpFleet из v1.3+, а не последовательное защёлкивание по модулям. check_sync() сообщает о каждом модуле, пропустившем широковещательный сигнал, так что неверно подключённый или не настроенный модуль виден сразу.)
Что вы увидите
Построчные данные в реальном времени с накопительным итогом и синхронизированная строка энергии каждые 30 с:
[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
Что делает скрипт
RbAmpFleet ведёт учёт парка; три функции управляют процессом — enrol_fleet() при запуске, затем print_live() и roll_gc_energy() — каждая со своим ритмом.
enrol_fleet() — поднять модули
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)
Поднимает каждый модуль по его явному адресу (без сканирования шины, поэтому в руководстве видны адреса), проверяет и только затем задаёт пресет CT (без лишней записи во флеш) и добавляет модуль в парк. Модуль, не прошедший begin(), помечается и пропускается — остальные работают, так что одно плохое соединение не срывает весь запуск.
print_live() — по модулям + накопительный итог
for m in fleet:
v = m.voltage; i = m.current[0]; p = m.power[0]
total_p += p
Обходит парк и считывает живые V / I / P каждого модуля для вывода, суммируя мощность модулей в живой итог по всему щиту. Эти живые считывания не нужно синхронизировать — они для показаний.
roll_gc_energy() — согласованная часть
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
Поэтому итог и надёжен. gc_latch() отправляет один кадр General-Call на адрес 0x00 — каждый включённый модуль замораживает своё окно периода в тот же момент. Затем check_sync() читает REG_GC_TICK каждого модуля и отмечает те, что пропустили широковещательный сигнал (выводит строку MISSED gc tick и пропускает этот модуль в окне — здоровые продолжают). Затем read_period_snapshot(skip_latch=True) читает каждое уже замороженное окно без повторного защёлкивания, а fleet.total_energy_wh() суммирует парк. Поскольку все модули защёлкнулись вместе, суммарные Вт·ч согласованы — а не три показания, снятые в три разных момента. Именно эту строку состояния check_sync вы и стали бы выводить в реальной установке.
Адаптируйте под себя
-
Больше цепей — добавляйте модули на шину и назначайте каждому адрес; они войдут в парк. По мере роста числа следите за правилами нагрузки шины и подтягивающих резисторов.
-
Журналируйте панель — одна строка на модуль за интервал в CSV или SQLite (сборка журнала).
- Раздайте наружу — выведите мощность по каждой цепи и итог как конечную точку Flask или опубликуйте по MQTT — локально, без облака.
- Действия по цепям — отключайте реле каждого модуля при превышении его собственного предела (сборка с реле).
- Независимые парки — разные
group_idпозволяют несвязанным группам защёлкиваться по собственному ритму, все на одной шине.
Что дальше
- Действуйте по показаниям — отключайте GPIO-реле при пересечении предела тока.
- Журналируйте — периодическая энергия по каждой цепи в CSV или SQLite.
- Предпочитаете Home Assistant? Та же многомодульная шина — это весь щит на одном ESP32 с ESPHome.