rbAmp
IT
Negozio

Progetto · · 13 min di lettura

Più TA SCT-013 su un Arduino: misura di molti circuiti su un unico bus

Due o tre moduli rbAmp su un bus I²C dietro un unico Arduino: un latch broadcast, potenza per circuito e un totale coerente dell'intero quadro.

Cosa costruirà

  • Per circuito tensione / corrente / potenza attiva reale da ogni modulo.
  • Una potenza attiva totale coerente — la somma dei moduli, tutti agganciati nello stesso istante (non tre letture campionate in modo indipendente che non si riconciliano — vedi perché conta).

  • Tutto su un unico bus I²C, un Arduino — aggiunga circuiti aggiungendo moduli, senza un nuovo microcontrollore.

Distinta dei materiali

Voce Q.tà Note
rbAmp BASIC SCT-UI1 3 uno per circuito · prodotto
TA SCT-013 3 un modulo ciascuno, portata per circuito · prodotto
Scheda di sviluppo ESP32 (framework Arduino) 1 il target verificato in compilazione
Cavetti jumper — il bus I²C condiviso

Cablaggio del bus condiviso

Tutti i moduli stanno sugli stessi SDA / SCL / alimentazione / massa — differiscono solo per indirizzo:

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
  • Pull-up: ogni modulo ha i pull-up a bordo. Con due o tre moduli su un bus fino a 15 cm, li lasci attivi su ogni modulo — niente da tagliare. Da quattro moduli in su, o su un bus più lungo, segua la documentazione hardware del modulo.

  • I TA si stringono attorno ai loro conduttori — il lato corrente è non invasivo. Alimenti ogni modulo alla sua tensione nominale. Per lavori all'interno di un quadro elettrico, si rivolga a un elettricista qualificato.

Assegni un indirizzo a ciascun modulo

I moduli escono con 0x50, quindi prima che possano condividere un bus si assegna al secondo e al terzo un indirizzo unico (0x51, 0x52). Sul firmware attuale è una normale operazione di produzione — nessuna modalità speciale né strumenti — si prepara il nuovo indirizzo, lo si arma e lo si conferma; il modulo si riavvia al nuovo indirizzo. Lo faccia un modulo alla volta, con gli altri scollegati, così non c'è conflitto di indirizzi — l'helper RbAmpFleet::provision() (o prepareAddressChange() / commitAddressChange() di un singolo modulo) esegue quel commit in due fasi. Nessun jumper, nessun pulsante, nessuna modalità speciale — basta un solo modulo sul bus mentre lo assegna.

Sincronizzi, poi legga

Ecco la parte che rende affidabile il totale. Invece di leggere tre moduli uno dopo l'altro (ciascuno colto in un momento leggermente diverso), si invia un unico broadcast "latch ora" a tutto il bus — ogni modulo congela la sua finestra di misura nello stesso istante. Poi si leggono gli snapshot congelati di ciascun modulo a turno. Le letture sono sequenziali, ma i valori appartengono tutti allo stesso momento, quindi sommarli è corretto. È lo stesso principio di coerenza della build trifase, qui in C++ Arduino.

Lo sketch

Tre moduli UI1 su 0x50 / 0x51 / 0x52, un ESP32 (framework Arduino) a 50 kHz. L'helper RbAmpFleet scansiona il bus, aderisce una volta al latch broadcast ogni modulo, poi a ogni finestra di energia parte un latch General-Call e legge lo snapshot congelato di ciascun modulo:

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);
}

(Verificato in compilazione su ESP32 con Arduino-CLI — RbAmpFleet + Wire, nessuna libreria extra. enableGcAll() è un'adesione una tantum; gcLatch() trasmette in broadcast, checkSync() segnala qualsiasi modulo che ha mancato il tick, e totalEnergyWh() restituisce l'energia sommata del fleet.)

Cosa fa lo sketch

L'helper RbAmpFleet si occupa della contabilità — scoprendo i moduli, aderendo al latch broadcast e totalizzandoli. Due funzioni girano nel ciclo: showLive() (visualizzazione al secondo) e rollEnergyWindow() (per finestra di energia).

Configurazione — scansioni il bus, abiliti il latch del fleet

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() percorre il bus e registra ogni rbAmp trovato (confermandolo tramite l'ID prodotto); fleet.count() dice quanti hanno risposto, così un modulo mancante o con indirizzo errato è evidente all'avvio. enableGcAll() imposta una volta il flag di latch General-Call su ogni modulo — dopo di che un solo broadcast può agganciare l'intero gruppo.

showLive() — letture per modulo + un totale in corso

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
}

Percorre il fleet e legge in sequenza tensione/corrente/potenza live di ogni modulo. Queste letture live non devono essere sincronizzate — servono per il display — e somma la potenza dei singoli moduli in p_total per una cifra live dell'intero quadro.

rollEnergyWindow() — la parte coerente

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);

È per questo che il totale è affidabile. gcLatch() invia un frame General-Call all'indirizzo 0x00 — ogni modulo abilitato congela la sua finestra di misura in quello stesso istante (scarto sotto i 10 µs su tutto il fleet). checkSync() verifica che ogni modulo abbia effettivamente accettato il tick e segnala quelli che lo hanno mancato (una comoda riga di salute del fleet). Poi le letture: readPeriodSnapshot(..., skip_latch=true) legge la finestra già congelata di ciascun modulo senza rifare il latch, il che fa avanzare il totale in wattora del modulo. totalPower() / totalEnergyWh() sommano il fleet. Poiché tutti i moduli hanno fatto il latch insieme, Σ Pi e i Wh sommati sono coerenti — non tre letture prese in tre momenti diversi.

Il loop() a doppia cadenza

Stessa idea del monitor a modulo singolo: showLive() su un timer da 1 s, rollEnergyWindow() sul timer della finestra di energia — il display live resta reattivo mentre il latch coerente gira sulla sua cadenza più lenta.

Lo personalizzi

  • Più circuiti — scan() gestisce quanti moduli ci sono sul bus; dia a ciascuno un indirizzo unico (vedi sopra) e si uniscono automaticamente al fleet. Tenga conto delle regole di carico del bus / pull-up man mano che il numero cresce.

  • Fleet indipendenti — assegni a gruppi non correlati group_id diversi e li agganci ciascuno sulla propria cadenza, tutti sullo stesso bus.

  • Aggiunga uno schermo — inserisca l'OLED della build del monitor, oppure pubblichi semplicemente p_total e i Wh del fleet.

  • Azioni per circuito — faccia scattare un relè per modulo oltre il proprio limite (combini con la build relè).

  • Registri il quadro — una riga per modulo per intervallo su una scheda SD (la build del logger).

Cosa segue

  • Agisca in base alla lettura — faccia scattare un relè o avvisi quando un circuito supera un limite di corrente, in locale, senza rete.
  • Registri — energia periodica per circuito su una scheda SD o su CSV via seriale.
  • Lo vuole in Home Assistant? Lo stesso bus multi-modulo è l'intero quadro su un ESP32 con ESPHome.

Leggi anche