rbAmp
RU
Магазин

Проект · · 13 мин чтения

Несколько цепей от одного Raspberry Pi: многомодульная шина rbAmp на Python

Два или три модуля rbAmp на шине I²C Raspberry Pi, связанные одним широковещательным защёлкиванием: мощность по каждой цепи и согласованный общий итог, на простом Python.

Что вы соберёте

  • По каждой цепи напряжение / ток / активная мощность с каждого модуля, считываемые 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 — отличаются только адресом:

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
  • Питайте каждый модуль от 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:

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

(Проверено запуском на mock-бэкенде библиотеки rbAmp для Python на CPython 3.12 — rbamp 1.3.0 + smbus2 0.6.1. Используется широковещательное защёлкивание RbAmpFleet из v1.3+, а не последовательное защёлкивание по модулям. check_sync() сообщает о каждом модуле, пропустившем широковещательный сигнал, так что неверно подключённый или не настроенный модуль виден сразу.)

Что вы увидите

Построчные данные в реальном времени с накопительным итогом и синхронизированная строка энергии каждые 30 с:

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

Что делает скрипт

RbAmpFleet ведёт учёт парка; три функции управляют процессом — enrol_fleet() при запуске, затем print_live() и roll_gc_energy() — каждая со своим ритмом.

enrol_fleet() — поднять модули

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)

Поднимает каждый модуль по его явному адресу (без сканирования шины, поэтому в руководстве видны адреса), проверяет и только затем задаёт пресет CT (без лишней записи во флеш) и добавляет модуль в парк. Модуль, не прошедший begin(), помечается и пропускается — остальные работают, так что одно плохое соединение не срывает весь запуск.

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

Обходит парк и считывает живые V / I / P каждого модуля для вывода, суммируя мощность модулей в живой итог по всему щиту. Эти живые считывания не нужно синхронизировать — они для показаний.

roll_gc_energy() — согласованная часть

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

Поэтому итог и надёжен. 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.

Читать дальше