Что вы соберёте
- По каждой цепи напряжение / ток / реальная мощность с каждого модуля.
-
Согласованная суммарная активная мощность — сумма модулей, все защёлкнуты в один и тот же момент (а не три независимо отобранных показания, которые не сходятся — см. почему это важно).
-
Всё на одной шине I²C, одном Arduino — добавляйте цепи, добавляя модули, без нового микроконтроллера.
Спецификация
| Позиция | Кол-во | Примечания |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 3 | по одному на цепь · продукт |
| Клещи SCT-013 CT | 3 | по одному на модуль, номинал по цепи · продукт |
| Отладочная плата ESP32 (фреймворк Arduino) | 1 | проверенная компиляцией цель |
| Перемычки | — | общая шина I²C |
Проводка общей шины
Все модули стоят на одних SDA / SCL / питании / земле — отличаются только адресом:
Arduino module A (0x50) module B (0x51) module C (0x52)
------- --------------- --------------- ---------------
SDA ────────┬────── SDA ────┬────── SDA ────┬────── SDA
SCL ────────┼────── SCL ────┼────── SCL ────┼────── SCL
5V ────────┼────── VCC ├────── VCC ├────── VCC
GND ────────┴────── GND ────┴────── GND ────┴────── GND
│ │ │
CT on circuit A CT on circuit B CT on circuit C
-
Подтяжки: каждый модуль поставляется со встроенными подтяжками. С двумя или тремя модулями на шине длиной до 15 см оставьте их включёнными на каждом модуле — ничего резать не нужно. От четырёх модулей или на более длинной шине следуйте документу по аппаратной части модуля.
-
CT охватывают снаружи свои проводники — сторона тока бесконтактная. Питайте каждый модуль от номинального напряжения. Работы внутри электрощита поручите квалифицированному электрику.
Назначьте каждому модулю адрес
Модули поставляются с адресом 0x50, поэтому, прежде чем они смогут делить шину, назначьте второму и третьему уникальный адрес (0x51, 0x52). На текущей прошивке это обычная производственная операция — без особого режима и инструментов: вы задаёте новый адрес, взводите его и фиксируете; модуль перезагружается на новом адресе. Делайте это по одному модулю за раз, с отключёнными остальными, чтобы не возник конфликт адресов — помощник RbAmpFleet::provision() (или одиночные prepareAddressChange() / commitAddressChange()) выполняет двухфазную фиксацию. Ни перемычки, ни кнопки, ни особого режима — только один модуль на шине, пока вы его назначаете.
Синхронизируйте, затем читайте
Вот что делает итог надёжным. Вместо того чтобы читать три модуля один за другим (каждый фиксируется в немного другой момент), вы посылаете один широковещательный «защёлкнуть сейчас» на всю шину — каждый модуль замораживает окно измерения в один и тот же момент. Затем вы по очереди читаете замороженный снимок каждого модуля. Чтения последовательные, но значения относятся к одному моменту, так что их суммирование честно. Это тот же принцип согласованности, что и в трёхфазной сборке, только здесь на Arduino C++.
Скетч
Три модуля UI1 по адресам 0x50 / 0x51 / 0x52, один ESP32 (фреймворк Arduino) на 50 кГц. Помощник RbAmpFleet сканирует шину, один раз переводит каждый модуль на широковещательную защёлку, затем каждое энергетическое окно запускает одну защёлку General-Call и читает замороженный снимок каждого модуля:
/**
* MultiModuleBus.ino — three rbAmp modules on one I2C bus: per-module power +
* a coherent fleet total, synchronised by the v1.3 General-Call latch.
*
* Three UI1 modules, each metering one independent mains circuit, share a single
* two-wire bus behind one ESP32 at 0x50 / 0x51 / 0x52. Every energy window the
* host fires ONE General-Call broadcast latch, so all three latch their period on
* the same instant (coherent energy). Live V/I/P is read sequentially; the
* broadcast is only for period/energy coherence. Requires v1.3+ firmware.
*
* Board: ESP32 (Arduino framework) -- esp32:esp32:esp32
* Bus: I2C @ 50 kHz (Wire.setClock(50000)) on ESP32-Arduino; non-ESP32 = 100 kHz.
*
* Wiring: SDA->GPIO21, SCL->GPIO22 (all modules); rbAmp VCC->5 V; common GND;
* ~4.7 kOhm pull-ups on SDA/SCL to 3.3 V (host logic level).
*
* ADDRESSING (do this ONCE, before running this sketch): a factory module answers
* at 0x50. Bring modules up ONE AT A TIME and give each a unique address with the
* production-OK two-phase commit (RbAmpFleet::provision(), or a single module's
* prepareAddressChange()/commitAddressChange() — see example 05_AddressChange).
* Assign 0x51 and 0x52; leave the first at 0x50. No jumper, no button, no special
* mode — just one module on the bus at a time while you assign it.
*
* Accuracy: per clamp rating — the class and the sensor's own tolerance are both in the accuracy table on the BASIC page.
*/
#include
#include
/* ---- configuration -------------------------------------------------------- */
static const uint8_t SDA_PIN = 21;
static const uint8_t SCL_PIN = 22;
static const uint32_t I2C_HZ = 50000; /* ESP32-Arduino: 50 kHz */
static const uint8_t GC_GROUP = 0x00; /* 0x00 = all-call (latch every module) */
static const uint32_t LIVE_MS = 1000; /* per-module V/I/P refresh */
static const uint32_t WINDOW_MS = 30000; /* coherent energy window (GC latch) */
/* ---- state ---------------------------------------------------------------- */
static RbAmpFleet fleet(Wire);
static size_t g_count = 0;
static uint16_t g_tick = 0;
static uint32_t next_live_ms = 0;
static uint32_t next_window_ms = 0;
/* ---- live per-module V/I/P + running total active power ------------------- */
static void showLive() {
Serial.println(F("-- live --"));
float p_total = 0.0f;
for (size_t i = 0; i < g_count; ++i) {
RbAmp* dev = fleet.get(i);
if (!dev) continue;
float v = dev->readVoltage();
float a = dev->readCurrent(0);
float p = dev->readPower(0);
if (!isnan(p)) p_total += p;
Serial.print(F(" 0x"));
Serial.print(dev->address(), HEX);
Serial.print(F(" "));
Serial.print(isnan(v) ? 0.0f : v, 1); Serial.print(F(" V "));
Serial.print(isnan(a) ? 0.0f : a, 3); Serial.print(F(" A "));
Serial.print(isnan(p) ? 0.0f : p, 1); Serial.println(F(" W"));
}
Serial.print(F(" TOTAL active power = "));
Serial.print(p_total, 1);
Serial.println(F(" W"));
}
/* ---- coherent energy window: one GC latch -> read each -> aggregate ------- */
static void rollEnergyWindow() {
g_tick++;
/* One broadcast latches every GC-enabled module on the same instant. */
fleet.gcLatch(GC_GROUP, g_tick, /*settle_ms=*/50);
/* Verify each module accepted this tick (fleet sync / missed-frame skew). */
RbAmpFleetSync sync[RBAMP_FLEET_MAX_MODULES];
size_t missed = 0;
fleet.checkSync(g_tick, sync, RBAMP_FLEET_MAX_MODULES, missed);
Serial.print(F("== window tick "));
Serial.print(g_tick);
Serial.print(F(": "));
Serial.print(g_count - missed);
Serial.print(F("/"));
Serial.print(g_count);
Serial.println(F(" in sync =="));
/* Read the already-latched period on each module (skip_latch=true), which
* rolls that module's host-integrated Wh accumulator. */
for (size_t i = 0; i < g_count; ++i) {
RbAmp* dev = fleet.get(i);
if (!dev) continue;
RbAmpPeriodSnapshot snap;
bool ok = dev->readPeriodSnapshot(snap, /*settle_ms=*/0, /*skip_latch=*/true);
Serial.print(F(" 0x"));
Serial.print(dev->address(), HEX);
if (!sync[i].in_sync) {
Serial.print(F(" [missed tick, gc_tick="));
Serial.print(sync[i].gc_tick);
Serial.print(sync[i].reachable ? F("]") : F(", unreachable]"));
}
if (!ok) {
Serial.print(F(" period skipped: "));
Serial.println(RbAmp::errorString(dev->lastError()));
continue;
}
Serial.print(F(" avg_P="));
Serial.print(snap.avg_p[0], 1);
Serial.print(F(" W Wh="));
Serial.println(dev->energy().wh(0), 3);
}
float p_total = 0.0f;
double wh_total = 0.0;
fleet.totalPower(p_total);
fleet.totalEnergyWh(wh_total);
Serial.print(F(" FLEET total P="));
Serial.print(p_total, 1);
Serial.print(F(" W total Wh="));
Serial.println(wh_total, 3);
}
/* ---- lifecycle ------------------------------------------------------------ */
void setup() {
Serial.begin(115200);
while (!Serial && millis() < 2000) {}
Wire.begin(SDA_PIN, SCL_PIN);
Wire.setClock(I2C_HZ);
/* Discover every rbAmp on the bus (PRODUCT_ID confirmed). */
size_t added = 0;
if (!fleet.scan(/*match_product=*/true, added)) {
Serial.println(F("scan failed - bus may be compromised (stuck SDA?)"));
return;
}
g_count = fleet.count();
Serial.print(F("fleet: "));
Serial.print(g_count);
Serial.println(F(" module(s)"));
if (g_count == 0) {
Serial.println(F("no modules - check wiring + that each has a unique address"));
return;
}
/* Opt the whole fleet into GC latch (persisted + reset; one-time, ~1 s each). */
size_t gc_ok = 0;
fleet.enableGcAll(GC_GROUP, gc_ok);
Serial.print(F("GC latch enabled on "));
Serial.print(gc_ok);
Serial.print(F("/"));
Serial.print(g_count);
Serial.println(F(" module(s)"));
uint32_t now = millis();
next_live_ms = now;
next_window_ms = now + WINDOW_MS;
}
void loop() {
if (g_count == 0) { delay(1000); return; }
uint32_t now = millis();
if (static_cast(now - next_live_ms) >= 0) {
next_live_ms = now + LIVE_MS;
showLive();
}
if (static_cast(now - next_window_ms) >= 0) {
next_window_ms = now + WINDOW_MS;
rollEnergyWindow();
}
delay(5);
}
(Проверено компиляцией на ESP32 через Arduino-CLI — RbAmpFleet + Wire, без дополнительных библиотек. enableGcAll() — одноразовое включение; gcLatch() отправляет широковещательный сигнал, checkSync() сообщает о каждом модуле, пропустившем такт, а totalEnergyWh() даёт суммарную энергию парка.)
Что делает скетч
Помощник RbAmpFleet ведёт учёт — находит модули, включает их в широковещательную защёлку и суммирует. В цикле работают две функции: showLive() (показ каждую секунду) и rollEnergyWindow() (на каждое энергетическое окно).
Настройка — просканируйте шину, включите защёлку парка
RbAmpFleet fleet(Wire);
fleet.scan(/*match_product=*/true, added); // find every rbAmp on the bus
fleet.enableGcAll(GC_GROUP, gc_ok); // opt them all into the broadcast latch (one-time)
scan() обходит шину и регистрирует каждый найденный rbAmp (подтверждая по идентификатору продукта); fleet.count() показывает, сколько ответило, так что пропавший или неверно адресованный модуль виден при загрузке. enableGcAll() один раз выставляет флаг защёлкивания General-Call на каждом модуле — после этого одна широковещательная передача может защёлкнуть всю группу.
showLive() — показания по модулям + накопительный итог
for (size_t i = 0; i < g_count; ++i) {
RbAmp* dev = fleet.get(i);
float p = dev->readPower(0);
if (!isnan(p)) p_total += p; // ... print V / A / W for this module
}
Обходит парк и по очереди читает живые напряжение/ток/мощность каждого модуля. Эти живые чтения не нужно синхронизировать — они для дисплея — и суммирует мощность модулей в p_total для живой цифры по всему щиту.
rollEnergyWindow() — согласованная часть
fleet.gcLatch(GC_GROUP, ++g_tick, /*settle=*/50); // ONE broadcast latches all modules together
fleet.checkSync(g_tick, sync, RBAMP_FLEET_MAX_MODULES, missed); // did each accept the tick?
// per module: dev->readPeriodSnapshot(snap, 0, /*skip_latch=*/true); // read the frozen window
fleet.totalPower(p_total); fleet.totalEnergyWh(wh_total);
Поэтому итог и надёжен. gcLatch() отправляет один кадр General-Call на адрес 0x00 — каждый включённый модуль замораживает своё окно измерения в тот же момент (расхождение менее 10 мкс по парку). checkSync() проверяет, что каждый модуль действительно принял такт, и называет тех, кто его пропустил (полезная строка состояния парка). Затем чтения: readPeriodSnapshot(..., skip_latch=true) читает уже уже замороженное окно каждого модуля без повторного защёлкивания, что продвигает его накопленный итог Вт·ч. totalPower() / totalEnergyWh() суммируют парк. Поскольку все модули защёлкнулись вместе, Σ Pi и суммарные Вт·ч согласованы — а не три показания, снятые в три разных момента.
loop() с двумя частотами
Та же идея, что и в мониторе одного модуля: showLive() по таймеру 1 с, rollEnergyWindow() по таймеру энергетического окна — живой дисплей остаётся отзывчивым, а согласованное защёлкивание идёт с собственным, более медленным ритмом.
Адаптируйте под себя
-
Больше цепей —
scan()обрабатывает любое число модулей на шине; дайте каждому уникальный адрес (см. выше) — и они автоматически войдут в парк. По мере роста числа следите за правилами нагрузки шины и подтяжек. -
Независимые парки — дайте не связанным группам разные
group_idи защёлкивайте каждую по собственному ритму, все на одной шине. -
Добавьте экран — поставьте OLED из сборки монитора или просто публикуйте
p_totalи Вт·ч парка. -
Действия по цепям — отключайте реле каждого модуля при превышении его собственного предела (объедините со сборкой с реле).
- Журналируйте панель — одна строка CSV на модуль за интервал на SD-карту (сборка журнала).
Что дальше
- Действуйте по показаниям — отключайте реле или подавайте сигнал, когда цепь пересекает предел тока, локально, без сети.
- Журналируйте — периодическая энергия по каждой цепи на SD-карту или CSV по последовательному порту.
- Хотите это в Home Assistant? Та же многомодульная шина — это весь щит на одном ESP32 с ESPHome.