06 · Examples

#include <Wire.h>
#include <RbAmp.h>
#include <RbAmpFleet.h>
RbAmpFleet fleet(Wire);
RbAmpSnapshot   snaps[RBAMP_FLEET_MAX_MODULES];
RbAmpFleetPoll  status[RBAMP_FLEET_MAX_MODULES];
RbAmpFleetSync  sync_status[RBAMP_FLEET_MAX_MODULES];
static void configureOne(RbAmp* dev) {
    if (!dev) return;
    uint8_t variant = dev->readVariant();
    if (variant == 1) {                              // UI1 mains
        dev->setSensorClass(RbAmpSensorClass::Sct013);
        dev->setCTModel(0, 3);                        // SCT-013-030
        dev->saveUserConfig();
    } else if (variant == 5) {                       // I2
        uint8_t models[2] = { 1, 3 };
        dev->configureChannels(RbAmpSensorClass::Sct013, models, 2);
    } else if (variant == 6) {                       // I3
        uint8_t models[3] = { 1, 3, 6 };
        dev->configureChannels(RbAmpSensorClass::Sct013, models, 3);
    }
}
void setup() {
    Serial.begin(115200);
    Wire.begin();
#if defined(ESP32) || defined(ESP8266)
    Wire.setClock(50000);
#endif
    size_t added = 0;
    if (!fleet.scan(true, added)) { Serial.println(F("bus wedged")); return; }
    Serial.print(F("fleet_scan: ")); Serial.print((unsigned)added);
    Serial.print(F(" module(s), ")); Serial.print((unsigned)fleet.excludedCount());
    Serial.println(F(" excluded"));
    for (size_t i = 0; i < fleet.count(); ++i) configureOne(fleet.get(i));
    size_t gc_ok = 0;
    fleet.enableGcAll(0, gc_ok);
    Serial.print(F("enableGcAll → ")); Serial.print((unsigned)gc_ok);
    Serial.print(F("/")); Serial.print((unsigned)fleet.count());
    Serial.println(F(" armed"));
}
void loop() {
    static uint16_t tick = 0;
    fleet.gcLatch(0, tick, 50);
    size_t n_missed = 0;
    fleet.checkSync(tick, sync_status, RBAMP_FLEET_MAX_MODULES, n_missed);
    size_t n_ok = 0;
    fleet.pollAll(snaps, status, RBAMP_FLEET_MAX_MODULES, n_ok);
    float p_total = 0; double e_total = 0;
    fleet.totalPower(p_total);
    fleet.totalEnergyWh(e_total);
    size_t n_total = fleet.count();
    Serial.print(F("ITER ")); Serial.print(tick);
    Serial.print(F(": GC ")); Serial.print((unsigned)(n_total - n_missed));
    Serial.print(F("/")); Serial.print((unsigned)n_total);
    Serial.print(F(" in_sync | poll n_ok=")); Serial.print((unsigned)n_ok);
    Serial.print(F("/")); Serial.print((unsigned)n_total);
    Serial.print(F(" | P_total=")); Serial.print(p_total, 1);
    Serial.print(F(" W  E_total=")); Serial.print(e_total, 3);
    Serial.println(F(" Wh"));
    tick++;
    delay(1000);
}

fleet_scan: 3 module(s), 0 excluded
  [0] @0x50  channels=1  voltage=yes   (mains meter: U + 1 current)
  [1] @0x51  channels=2  voltage=no    (2-channel current sub-meter)
  [2] @0x52  channels=3  voltage=no    (3-channel current sub-meter)
configureChannels(2ch) → mirrors [1 2 -]
configureChannels(3ch) → mirrors [1 2 3]
enableGcAll → 3/3 modules armed
ITER N: GC 3/3 in_sync | poll n_ok=3/3 | P_total≈1260 W  E_total: 0 → 27.84 Wh
   @0x50  V=232.6  I=[5.79]                f=50.00  impl=0x00
   @0x51  V= —     I=[11.58, 3.87]         f=50.00  impl=0x00
   @0x52  V= —     I=[ 3.84, 2.55, 5.84]   f=50.00  impl=0x00  (3rd input free)

RbAmpFleet fleet(Wire);
void provisionNewModule(uint8_t desired_addr, const char* label = nullptr) {
    /* PRECONDITION: exactly one virgin on the bus at 0x50.
     * MUST be one-virgin-at-a-time — see ch.04 + ch.10. */
    RbAmp* dev = nullptr;
    if (!RbAmpFleet::provision(Wire, desired_addr, /*save_config=*/true, dev)) {
        Serial.print(F("provision @0x"));
        Serial.print(desired_addr, HEX);
        Serial.println(F(" failed — discipline violation? see ch.10"));
        return;
    }
    Serial.print(F("provisioned virgin → 0x"));
    Serial.print(desired_addr, HEX);
    Serial.println(F(" (+saved)"));
    if (label) dev->writeLabel(label);
    dev->setSensorClass(RbAmpSensorClass::Sct013);
    dev->setCTModel(0, 3);
    dev->saveUserConfig();
    fleet.add(dev);
}

before: present(0x50)=yes  present(0x52)=no
virgin @0x50: variant=3-channel, channels=3
RbAmpFleet::provision(→0x52, save_config=true) = OK
  (lib log: "provisioned virgin → 0x52 (+saved)")
post:   handle now answers @0x52, isProvisioned()=true
after:  present(0x50)=no   present(0x52)=yes

#include <RbAmp.h>
RbAmp dev(Wire, 0x52);   // I3 sub-meter
void configureMixedCT() {
    uint8_t models[3] = { 1, 3, 6 };
    /* 1=SCT-013-005 (5A), 3=SCT-013-030 (30A), 6=SCT-013-020 (20A) */
    uint32_t t0 = millis();
    if (!dev.configureChannels(RbAmpSensorClass::Sct013, models, 3)) {
        uint8_t reg_err = 0;
        dev.readLastError(reg_err);
        Serial.print(F("configure rejected: REG_ERROR=0x"));
        Serial.println(reg_err, HEX);
        return;
    }
    uint32_t t1 = millis();
    Serial.print(F("configureChannels latency = "));
    Serial.print(t1 - t0); Serial.println(F(" ms"));
    /* Verify mirror */
    uint8_t m0 = 0, m1 = 0, m2 = 0;
    dev.readCTModelCh(0, m0);
    dev.readCTModelCh(1, m1);
    dev.readCTModelCh(2, m2);
    Serial.print(F("applied: ["));
    Serial.print(m0); Serial.print(F(" "));
    Serial.print(m1); Serial.print(F(" "));
    Serial.print(m2); Serial.println(F("]  (expected [1 3 6])"));
    /* Persist verify — reset + re-read */
    dev.reset();
    delay(300);
    dev.readCTModelCh(0, m0);
    dev.readCTModelCh(1, m1);
    dev.readCTModelCh(2, m2);
    Serial.print(F("after reboot: ["));
    Serial.print(m0); Serial.print(F(" "));
    Serial.print(m1); Serial.print(F(" "));
    Serial.print(m2); Serial.println(F("]"));
}

configureChannels(Sct013, {1, 3, 6}, 3) = OK
  → readCTModelCh 0/1/2 = [1, 3, 6]   raw mirror 0x51/52/53 = [01 03 06]
  → ch0 NOT clobbered (Fix-A canon: bind order-independent)
configureChannels latency ≈ 1.4 s
after reboot: [1 3 6]  (persisted through reset)

#include <RbAmpFleet.h>
RbAmpFleet fleet(Wire);
RbAmpFleetSync sync_status[RBAMP_FLEET_MAX_MODULES];
void setup() {
    Wire.begin(); Wire.setClock(50000);
    size_t added = 0;
    fleet.scan(true, added);
    size_t gc_ok = 0;
    fleet.enableGcAll(0, gc_ok);
    Serial.print(F("GC armed: "));
    Serial.print((unsigned)gc_ok); Serial.print(F("/"));
    Serial.println((unsigned)fleet.count());
}
void loop() {
    static uint16_t tick = 0;
    fleet.gcLatch(0, tick, 50);
    size_t n_missed = 0;
    fleet.checkSync(tick, sync_status, RBAMP_FLEET_MAX_MODULES, n_missed);
    size_t n_total = fleet.count();
    Serial.print(F("tick=")); Serial.print(tick);
    Serial.print(F("  in_sync="));
    Serial.print((unsigned)(n_total - n_missed));
    Serial.print(F("/")); Serial.println((unsigned)n_total);
    tick++;
    delay(100);
}

enableGcAll → 3/3 modules armed
tick=0   in_sync=3/3
tick=1   in_sync=3/3
...
tick=9   in_sync=3/3      skew=0 (validated on tick=0xABCD)

#include <Wire.h>
#include <RbAmp.h>
static RbAmp dev(Wire, 0x50);
void setup() {
    Serial.begin(115200);
    while (!Serial && millis() < 3000) {}
    Wire.begin();
    dev.setLogStream(&Serial);
    while (!dev.begin()) {
        Serial.print(F("begin: "));
        Serial.println(dev.errorString());
        delay(1000);
    }
}
void loop() {
    RbAmpSnapshot s;
    if (!dev.readAll(s)) {
        Serial.print(F("read fail: "));
        Serial.println(dev.errorString());
        delay(1000); return;
    }
    Serial.print(F("U=")); Serial.print(s.voltage, 1); Serial.print(F("V "));
    Serial.print(F("f=")); Serial.print(s.frequency, 1); Serial.print(F("Hz   "));
    for (uint8_t ch = 0; ch < s.channels; ++ch) {
        Serial.print(F("I")); Serial.print(ch); Serial.print(F("="));
        Serial.print(s.current[ch], 2); Serial.print(F("A "));
        Serial.print(F("P")); Serial.print(ch); Serial.print(F("="));
        Serial.print(s.power[ch], 1); Serial.print(F("W "));
        Serial.print(F("PF")); Serial.print(ch); Serial.print(F("="));
        Serial.print(s.power_factor[ch], 2); Serial.print(F("  "));
    }
    Serial.println();
    delay(1000);
}

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <RbAmp.h>
static Adafruit_SSD1306 oled(128, 64, &Wire, -1);
static RbAmp dev(Wire, 0x50);
static uint32_t next_latch_ms = 0;
static uint32_t snapshots_ok = 0, snapshots_bad = 0;
void setup() {
    Serial.begin(115200);
    Wire.begin();
    oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
    dev.setLogStream(&Serial);
    while (!dev.begin()) { delay(1000); }
    next_latch_ms = millis() + 60000;
}
void loop() {
    if (millis() < next_latch_ms) { delay(50); return; }
    next_latch_ms = millis() + 60000;
    RbAmpPeriodSnapshot snap;
    if (!dev.readPeriodSnapshot(snap)) { snapshots_bad++; return; }
    snapshots_ok++;
    oled.clearDisplay();
    oled.setTextColor(SSD1306_WHITE);
    oled.setCursor(0, 0);  oled.setTextSize(1); oled.println(F("rbAmp Energy Meter"));
    oled.setCursor(0, 16); oled.setTextSize(2);
    oled.print(snap.avg_p[0], 1); oled.println(F(" W"));
    oled.setTextSize(1);
    oled.print(F("Wh:")); oled.println(dev.energy().wh(0), 4);
    oled.print(F("ok=")); oled.print(snapshots_ok);
    oled.print(F(" bad=")); oled.println(snapshots_bad);
    oled.display();
}

#include <Wire.h>
#include <RbAmp.h>
// Names mod0/mod1/mod2 (not T0/T1/T2) — on the ESP32 the identifiers
// T0/T1/T2 are already taken in the core by the touch-pin macros from
// `pins_arduino.h` and would cause a compile error when declared as
// global variables.
static RbAmp mod0(Wire, 0x50);
static RbAmp mod1(Wire, 0x51);
static RbAmp mod2(Wire, 0x52);
static RbAmp* modules[] = { &mod0, &mod1, &mod2 };
static const uint8_t N = sizeof(modules) / sizeof(modules[0]);
void setup() {
    Serial.begin(115200);
    Wire.begin();
    Wire.setClock(400000);   // 400 kHz reduces skew to ~100 µs
    for (uint8_t i = 0; i < N; ++i) modules[i]->begin();
}
void loop() {
    for (uint8_t i = 0; i < N; ++i) modules[i]->latchPeriod();
    delay(50);   // one shared settle for all 3 modules
    for (uint8_t i = 0; i < N; ++i) {
        RbAmpPeriodSnapshot snap;
        if (modules[i]->readPeriodSnapshot(snap, /*settle_ms=*/0,
                                                  /*skip_latch=*/true)) {
            Serial.print(F("mod")); Serial.print(i);
            Serial.print(F(" P=")); Serial.print(snap.avg_p[0], 0);
            Serial.print(F("W  Wh="));
            Serial.println(modules[i]->energy().wh(0), 3);
        }
    }
    delay(60000);
}

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <RbAmp.h>
static RbAmp dev(Wire, 0x50);
static const char* CH_NAMES[3] = {"main", "heatpump", "lights"};
static WiFiClient espClient;
static PubSubClient mqtt(espClient);
void publish_channel(const char* name, float avg_p, double e_wh) {
    char topic[64], payload[96];
    snprintf(topic, sizeof(topic), "rbamp/%s/state", name);
    snprintf(payload, sizeof(payload),
             "{\"power\":%.1f,\"energy\":%.4f}", avg_p, e_wh);
    mqtt.publish(topic, payload, true);
}
void setup() {
    Serial.begin(115200);
    WiFi.begin("ssid", "pass");
    while (WiFi.status() != WL_CONNECTED) delay(500);
    mqtt.setServer("192.168.1.10", 1883);
    mqtt.setKeepAlive(60);
    mqtt.connect("rbamp-ui3");
    Wire.begin();
    Wire.setClock(50000);    // ESP32 baseline mitigation — see 10 · Troubleshooting
    dev.setLogStream(&Serial);
    while (!dev.begin()) { delay(500); }
}
void loop() {
    if (!mqtt.connected()) mqtt.connect("rbamp-ui3");
    mqtt.loop();             // every iteration — for keepalive
    static uint32_t last_period = 0;
    if (last_period == 0) last_period = millis();
    if (millis() - last_period < 60000) { delay(50); return; }
    last_period = millis();
    RbAmpPeriodSnapshot snap;
    if (!dev.readPeriodSnapshot(snap)) return;
    for (uint8_t ch = 0; ch < dev.channels(); ++ch) {
        publish_channel(CH_NAMES[ch], snap.avg_p[ch], dev.energy().wh(ch));
    }
}

#include <Wire.h>
#include <RbAmp.h>
static RbAmp dev(Wire, 0x50);
static double consume_wh = 0.0;
static double export_wh  = 0.0;
static uint32_t last_sample_ms = 0;
void setup() {
    Serial.begin(115200);
    Wire.begin();
    dev.setLogStream(&Serial);
    while (!dev.begin()) { delay(500); }
    last_sample_ms = millis();
}
void loop() {
    if (millis() - last_sample_ms < 200) { delay(5); return; }  // 5 Hz
    const uint32_t now_ms = millis();
    const uint32_t dt_ms  = now_ms - last_sample_ms;
    last_sample_ms = now_ms;
    const float p_w = dev.readPower(0);
    if (isnan(p_w)) return;
    const double dwh = (double)p_w * dt_ms / 3600000.0;
    if (p_w >= 0.0f) consume_wh += dwh;
    else             export_wh  += -dwh;
    static uint32_t next_print = 0;
    if (millis() >= next_print) {
        next_print = millis() + 200;
        Serial.print(F("P=")); Serial.print(p_w, 1);
        Serial.print(F("W   cons=")); Serial.print(consume_wh, 4);
        Serial.print(F("Wh  exp=")); Serial.print(export_wh, 4);
        Serial.print(F("Wh  net="));
        Serial.print(consume_wh - export_wh, 4);
        Serial.println(F("Wh"));
    }
}

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <RbAmp.h>
static RbAmp mains(Wire, 0x50);    // bidirectional mains
static RbAmp solar(Wire, 0x51);    // generation only
static RbAmp loads(Wire, 0x52);    // UI3 — per-appliance
static RbAmp* mods[] = { &mains, &solar, &loads };
static WiFiClient espClient;
static PubSubClient mqtt(espClient);
void setup() {
    Serial.begin(115200);
    WiFi.begin("ssid", "pass");
    while (WiFi.status() != WL_CONNECTED) delay(500);
    mqtt.setServer("192.168.1.10", 1883);
    mqtt.connect("home-balance");
    Wire.begin();
    for (auto m : mods) while (!m->begin()) delay(500);
}
void loop() {
    delay(60000);
    for (auto m : mods) m->latchPeriod();
    delay(50);
    RbAmpPeriodSnapshot sm, ss, sl;
    mains.readPeriodSnapshot(sm, 0, true);
    solar.readPeriodSnapshot(ss, 0, true);
    loads.readPeriodSnapshot(sl, 0, true);
    char payload[512];
    snprintf(payload, sizeof(payload),
        "{\"mains\":%.3f,\"solar\":%.3f,\"hp\":%.3f,\"ac\":%.3f,\"ev\":%.3f}",
        mains.energy().wh(0),
        solar.energy().wh(0),
        loads.energy().wh(0),
        loads.energy().wh(1),
        loads.energy().wh(2));
    mqtt.publish("home/energy/balance", payload, true);
    mqtt.loop();
}

#include <Wire.h>
#include <RbAmp.h>
static RbAmp dev(Wire, 0x50);
static float p_ema = 0.0f;
static const float EMA_ALPHA = 0.05f;
static const float EVENT_THRESHOLD_W = 200.0f;
void setup() {
    Serial.begin(115200);
    Wire.begin();
    dev.setLogStream(&Serial);
    while (!dev.begin()) { delay(500); }
    p_ema = dev.readPower(0);  // seed so the first reading isn't an event
    if (isnan(p_ema)) p_ema = 0.0f;
}
void loop() {
    delay(200);
    const float p = dev.readPower(0);
    if (isnan(p)) return;
    const float delta = p - p_ema;
    p_ema = (1.0f - EMA_ALPHA) * p_ema + EMA_ALPHA * p;
    if (fabsf(delta) > EVENT_THRESHOLD_W) {
        Serial.print(millis()); Serial.print(F("  "));
        Serial.print(delta > 0 ? F("TURN_ON ") : F("TURN_OFF "));
        Serial.print(F("delta=")); Serial.print(delta, 0); Serial.print(F("W  "));
        Serial.print(F("P=")); Serial.print(p, 0); Serial.print(F("W  "));
        Serial.print(F("EMA=")); Serial.println(p_ema, 0);
    }
}

#define RBAMP_NACK_RETRY_ATTEMPTS 5
#include <Wire.h>
#include <RbAmp.h>
RbAmp dev(Wire, 0x50);
void emitCycle() {
    const float u = dev.readVoltage();
    float i[3]={NAN,NAN,NAN}, p[3]={NAN,NAN,NAN}, pf[3]={NAN,NAN,NAN};
    for (uint8_t c = 0; c < dev.channels(); c++) {
        i[c]  = dev.readCurrent(c);
        p[c]  = dev.readPower(c);
        pf[c] = dev.readPowerFactor(c);
    }
    const float freq = dev.readFrequency();
    RbAmpPeriodSnapshot snap;
    const bool snap_ok = dev.readPeriodSnapshot(snap, 60);
    /* CSV row — the full 28-column format is in SoakMonitor.ino */
    Serial.printf("%lu,%.3f,%.4f,%.3f,%.4f,%.1f,%.4f,%lu,%lu,%.6f,%lu,%lu,%u\n",
        millis(), u, i[0], p[0], pf[0], freq,
        snap.avg_p[0], snap.latch_ms, snap.master_dt_ms,
        dev.energy().wh(0),
        dev.retryExhaustionCount(),
        dev.sanityRejectCount(),
        snap_ok ? 1 : 0);
}
void setup() {
    Serial.begin(115200);
    Wire.begin(21, 22); Wire.setClock(50000);
    while (!dev.begin()) delay(500);
    dev.resetCounters();
    emitCycle();
}
void loop() {
    static uint32_t next_ms = 5UL * 60UL * 1000UL;
    if (millis() >= next_ms) {
        emitCycle();
        next_ms += 5UL * 60UL * 1000UL;
    }
    delay(100);
}

arduino-cli monitor -p COM3 -c baudrate=115200 > soak.csv

#include <Wire.h>
#include <RbAmp.h>
#include "esp_sleep.h"
#include "esp_timer.h"
RTC_DATA_ATTR uint32_t rtc_magic        = 0;
RTC_DATA_ATTR double   rtc_total_wh     = 0;
RTC_DATA_ATTR bool     rtc_primer_done  = false;
RTC_DATA_ATTR uint64_t rtc_last_wake_us = 0;
void setup() {
    Serial.begin(115200);
    Wire.begin();
    RbAmp dev(Wire, 0x50);
    if (rtc_magic != 0xCAFEFEED) {
        rtc_magic = 0xCAFEFEED;
        rtc_total_wh = 0;
        rtc_primer_done = false;
        rtc_last_wake_us = 0;
    }
    dev.begin();              // begin() issues the primer LATCH itself
    dev.energy().disable();   // the master owns the Wh
    if (!rtc_primer_done) {
        // First wake: the primer just latched "dirty" pre-wake data.
        // Note the time and go straight back to sleep — the next wake
        // in 10 min will get a proper 10-minute accumulator.
        rtc_last_wake_us = esp_timer_get_time();
        rtc_primer_done = true;
        esp_sleep_enable_timer_wakeup(10ULL * 60ULL * 1000000ULL);
        esp_deep_sleep_start();
    }
    // skip_latch=true reads what begin()'s primer latched —
    // i.e. the accumulator over the elapsed 10-minute sleep interval.
    RbAmpPeriodSnapshot snap;
    if (dev.readPeriodSnapshot(snap, /*settle_ms=*/0, /*skip_latch=*/true)) {
        // master_dt_ms here is the time within the current wake (after
        // the primer); for energy integration we use our own RTC timer,
        // which survived the deep-sleep.
        const uint64_t now_us = esp_timer_get_time();
        const double   dt_s   = (double)(now_us - rtc_last_wake_us) / 1000000.0;
        rtc_last_wake_us = now_us;
        rtc_total_wh += (double)snap.avg_p[0] * dt_s / 3600.0;
        publish_via_wifi(snap.avg_p[0], rtc_total_wh, (uint32_t)(dt_s * 1000));
    }
    esp_sleep_enable_timer_wakeup(10ULL * 60ULL * 1000000ULL);
    esp_deep_sleep_start();
}
void loop() {}

#include <Wire.h>
#include <RbAmp.h>
RbAmp dev(Wire, 0x50);
void setup() {
    Wire.begin();
#if defined(ESP32) || defined(ESP_PLATFORM) || defined(ESP8266)
    Wire.setClock(50000);
#endif
    Serial.begin(115200);
    while (!dev.begin()) { delay(500); }
    // Per-channel CT model — order doesn't matter on v1.3 (Fix A pure-staging)
    dev.setSensorClass(RbAmpSensorClass::Sct013);
    dev.setCTModel(2, RbAmpCTModel::Sct013_020);   // ch2: boiler (code 6)
    dev.setCTModel(1, RbAmpCTModel::Sct013_030);   // ch1: kitchen (code 3)
    dev.setCTModel(0, RbAmpCTModel::Sct013_005);   // ch0: outlet (code 1)
}
void loop() {
    float u  = dev.readVoltage();
    float i0 = dev.readCurrent(0), p0 = dev.readPower(0);
    float i1 = dev.readCurrent(1), p1 = dev.readPower(1);
    float i2 = dev.readCurrent(2), p2 = dev.readPower(2);
    Serial.printf("U=%.1f V\n", u);
    Serial.printf("  outlet:  I=%.3f A  P=%.1f W\n", i0, p0);
    Serial.printf("  kitchen: I=%.2f A  P=%.1f W\n", i1, p1);
    Serial.printf("  boiler:  I=%.2f A  P=%.1f W\n", i2, p2);
    Serial.printf("  total:   P=%.1f W\n", p0 + p1 + p2);
    delay(2000);
}

#define N_METERS 5
RbAmp meters[N_METERS] = {
    {Wire, 0x50}, {Wire, 0x51}, {Wire, 0x52},
    {Wire, 0x53}, {Wire, 0x54},
};
unsigned long period_start_ms = 0;
const unsigned long PERIOD_MS = 60000;   // 60-second metering period
void setup() {
    Wire.begin();
#if defined(ESP32) || defined(ESP_PLATFORM) || defined(ESP8266)
    Wire.setClock(50000);
#endif
    Serial.begin(115200);
    for (int i = 0; i < N_METERS; i++) {
        while (!meters[i].begin()) { delay(500); }
    }
    period_start_ms = millis();
}
void loop() {
    if (millis() - period_start_ms < PERIOD_MS) {
        delay(100);
        return;
    }
    // Phase 1: sequential latch (~5 ms skew between modules at 50 kHz)
    for (auto& m : meters) m.latchPeriod();
    // Phase 2: shared settle
    delay(50);
    // Phase 3: read the snapshots
    float total_wh = 0.0f;
    for (int i = 0; i < N_METERS; i++) {
        RbAmpSnapshot snap;
        if (meters[i].readPeriodSnapshot(snap, /*skip_latch=*/true) && snap.valid) {
            float wh = snap.avg_p[0] * (snap.period_ms / 3600000.0f);
            Serial.printf("[%d] avg_p=%.1f W  Wh_period=%.2f\n",
                          i, snap.avg_p[0], wh);
            total_wh += wh;
        }
    }
    Serial.printf("TOTAL for the period: %.2f Wh\n\n", total_wh);
    period_start_ms = millis();
}

// Enable GC reception on each module
dev.writeReg(0x27, 0x01);              // REG_FLEET_CONFIG.bit0 = 1
dev.saveUserConfig();                  // CMD_SAVE_USER_CONFIG (production-OK)
dev.reset();                           // CMD_RESET; settle ~300 ms

#define N_METERS 12
RbAmp meters[N_METERS] = { /* initialization */ };
uint16_t tick_counter = 0;
bool billing_grade_latch() {
    // GC frame: A5 27 <group> <tick_lo> <tick_hi> on addr 0x00
    Wire.beginTransmission(0x00);
    Wire.write(0xA5);                          // GC_FRAME_MAGIC
    Wire.write(0x27);                          // CMD_LATCH_PERIOD opcode
    Wire.write(0x00);                          // group = 0 (all-call)
    Wire.write(tick_counter & 0xFF);
    Wire.write(tick_counter >> 8);
    if (Wire.endTransmission() != 0) {
        return false;   // GC frame transmission failed
    }
    tick_counter++;
    delay(50);   // settle + 1 commit cycle for witness refresh
    // Witness check
    int n_ok = 0;
    for (int i = 0; i < N_METERS; i++) {
        uint8_t valid = meters[i].readReg(0x07);   // REG_V03_PERIOD_VALID
        if (valid == 1) n_ok++;
    }
    if (n_ok < N_METERS) {
        // Fall back to a sequential latch for the modules that missed
        for (int i = 0; i < N_METERS; i++) {
            uint8_t valid = meters[i].readReg(0x07);
            if (valid != 1) meters[i].latchPeriod();
        }
        delay(50);
    }
    return n_ok == N_METERS;
}

// Tariff A — modules 0..4 → group = 1
for (int i = 0; i < 5; i++) {
    meters[i].writeReg(0x28, 1);   // REG_GROUP_ID = 1
    meters[i].saveUserConfig();
    meters[i].reset();
}
// Tariff B — modules 5..9 → group = 2
for (int i = 5; i < 10; i++) {
    meters[i].writeReg(0x28, 2);
    meters[i].saveUserConfig();
    meters[i].reset();
}

void daytime_cycle(uint16_t tick) {
    Wire.beginTransmission(0x00);
    Wire.write(0xA5); Wire.write(0x27);
    Wire.write(0x01);             // group = 1 (tariff A only)
    Wire.write(tick & 0xFF); Wire.write(tick >> 8);
    Wire.endTransmission();
    delay(50);
    // read the 5 tariff-A modules
}
void nighttime_cycle(uint16_t tick) {
    Wire.beginTransmission(0x00);
    Wire.write(0xA5); Wire.write(0x27);
    Wire.write(0x02);             // group = 2 (tariff B only)
    Wire.write(tick & 0xFF); Wire.write(tick >> 8);
    Wire.endTransmission();
    delay(50);
    // read the 5 tariff-B modules
}