rbAmp
RU
Магазин

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

Несколько клещей SCT-013 на одном Arduino: учёт многих цепей по одной шине

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

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

  • По каждой цепи напряжение / ток / реальная мощность с каждого модуля.
  • Согласованная суммарная активная мощность — сумма модулей, все защёлкнуты в один и тот же момент (а не три независимо отобранных показания, которые не сходятся — см. почему это важно).

  • Всё на одной шине I²C, одном Arduino — добавляйте цепи, добавляя модули, без нового микроконтроллера.

Спецификация

Позиция Кол-во Примечания
rbAmp BASIC SCT-UI1 3 по одному на цепь · продукт
Клещи SCT-013 CT 3 по одному на модуль, номинал по цепи · продукт
Отладочная плата ESP32 (фреймворк Arduino) 1 проверенная компиляцией цель
Перемычки — общая шина I²C

Проводка общей шины

Все модули стоят на одних SDA / SCL / питании / земле — отличаются только адресом:

Text
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 и читает замороженный снимок каждого модуля:

C++
/**
 * 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() (на каждое энергетическое окно).

Настройка — просканируйте шину, включите защёлку парка

C++
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() — показания по модулям + накопительный итог

C++
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() — согласованная часть

C++
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.

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