rbAmp
DE
Shop

Projekt · · 13 Min. Lesezeit

Mehrere SCT-013-Zangen an einem Arduino: viele Stromkreise über einen Bus messen

Zwei oder drei rbAmp-Module an einem I²C-Bus hinter einem einzigen Arduino: ein Broadcast-Latch, Leistung pro Stromkreis und eine kohärente Gesamtsumme des Verteilers.

Was Sie bauen werden

  • Pro Stromkreis Spannung / Strom / Wirkleistung von jedem Modul.
  • Eine kohärente Gesamtwirkleistung — die Summe der Module, alle auf demselben Moment gelatcht (nicht drei unabhängig abgetastete Werte, die sich nicht abgleichen lassen — siehe warum das wichtig ist).

  • Alles auf einem I²C-Bus, einem Arduino — Stromkreise hinzufügen, indem Sie Module ergänzen, kein neuer Mikrocontroller.

Stückliste

Position Menge Hinweise
rbAmp BASIC SCT-UI1 3 eine pro Stromkreis · Produkt
SCT-013-CT 3 eine pro Modul, Nennwert pro Stromkreis · Produkt
ESP32-Entwicklungsboard (Arduino-Framework) 1 das kompilierte Zielsystem
Steckbrücken — der gemeinsame I²C-Bus

Den gemeinsamen Bus verdrahten

Alle Module sitzen auf demselben SDA / SCL / Strom / Masse — sie unterscheiden sich nur durch die Adresse:

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-Widerstände: Jedes Modul wird mit Pull-ups an Bord geliefert. Bei zwei oder drei Modulen an einem Bus bis 15 cm lassen Sie sie an jedem Modul aktiv — nichts zu durchtrennen. Ab vier Modulen oder bei einem längeren Bus folgen Sie der Hardware-Dokumentation des Moduls.

  • Die CTs legen sich um ihre Leiter — die Stromseite ist berührungslos. Versorgen Sie jedes Modul mit seiner Nennspannung. Für Arbeiten im Inneren eines Elektroverteilers sollten Sie eine qualifizierte Elektrofachkraft hinzuziehen.

Jedem Modul eine Adresse geben

Module werden mit 0x50 ausgeliefert, daher weisen Sie dem zweiten und dritten Modul eine eindeutige Adresse zu (0x51, 0x52), bevor sie sich einen Bus teilen. In der aktuellen Firmware ist dies ein gewöhnlicher Produktionsbetrieb — kein Spezialmodus, keine Spezialwerkzeuge — Sie stellen die neue Adresse bereit, scharf schalten und bestätigen; das Modul startet an seiner neuen Adresse neu. Tun Sie dies jeweils nur an einem Modul, bei abgeklemmtem anderen, damit es keinen Adresskonflikt gibt — der Hilfsaufruf RbAmpFleet::provision() (oder ein einzelnes prepareAddressChange() / commitAddressChange()) führt dieses Zwei-Phasen-Commit aus. Kein Jumper, kein Taster, kein Spezialmodus — nur ein Modul auf dem Bus, während Sie es zuweisen.

Synchronisieren, dann lesen

Hier steckt der Teil, der die Summe vertrauenswürdig macht. Statt drei Module nacheinander auszulesen (jedes in einem leicht anderen Moment erfasst), senden Sie einen Broadcast „jetzt latchen“ an den gesamten Bus — jedes Modul friert sein Messfenster im selben Moment ein. Dann lesen Sie den eingefrorenen Schnappschuss jedes Moduls nacheinander aus. Die Lesevorgänge erfolgen zwar sequenziell, aber alle Werte gehören zum selben Moment, daher ist das Summieren ehrlich. Es ist dasselbe Kohärenzprinzip wie beim Dreiphasen-Aufbau, hier in Arduino-C++.

Der Sketch

Drei UI1-Module bei 0x50 / 0x51 / 0x52, ein ESP32 (Arduino-Framework) mit 50 kHz. Der RbAmpFleet-Helfer scannt den Bus, nimmt jedes Modul einmal in den Broadcast-Latch auf, und dann löst jedes Energiefenster einen General-Call-Latch aus und liest den eingefrorenen Schnappschuss jedes Moduls:

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

(Auf ESP32 mit Arduino-CLI kompiliert geprüft — RbAmpFleet + Wire, ohne zusätzliche Bibliotheken. enableGcAll() ist eine einmalige Aktivierung; gcLatch() sendet den Broadcast, checkSync() meldet jedes Modul, das den Takt verpasst hat, und totalEnergyWh() liefert die summierte Energie des Verbunds.)

Was der Sketch macht

Der RbAmpFleet-Helfer übernimmt die Buchführung — er erkennt die Module, nimmt sie in den Broadcast-Latch auf und summiert sie. Zwei Funktionen laufen in der Schleife: showLive() (Anzeige pro Sekunde) und rollEnergyWindow() (pro Energiefenster).

Einrichtung — Bus scannen, Verbund-Latch aktivieren

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() durchläuft den Bus und registriert jedes gefundene rbAmp (bestätigt über die Produkt-ID); fleet.count() sagt Ihnen, wie viele geantwortet haben, sodass ein fehlendes oder falsch adressiertes Modul beim Start offensichtlich wird. enableGcAll() setzt das General-Call-Latch-Flag einmal auf jedem Modul — danach kann ein einzelner Broadcast die ganze Gruppe latchen.

showLive() — Messwerte pro Modul + laufende Summe

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
}

Durchläuft den Verbund und liest nacheinander Spannung/Strom/Leistung jedes Moduls live aus. Diese Live-Lesungen müssen nicht synchronisiert sein — sie dienen der Anzeige — und sie summiert die Leistung der einzelnen Module zu p_total für eine Live-Gesamtzahl des Verteilers.

rollEnergyWindow() — der kohärente Teil

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

Deshalb ist die Summe vertrauenswürdig. gcLatch() sendet einen General-Call-Frame an die Adresse 0x00 — jedes aktivierte Modul friert sein Messfenster im selben Moment ein (Versatz unter 10 µs über den Verbund). checkSync() prüft, ob jedes Modul den Takt tatsächlich angenommen hat, und benennt jedes, das ihn verpasst hat (eine nützliche Zeile zum Zustand des Verbunds). Dann die Lesevorgänge: readPeriodSnapshot(..., skip_latch=true) liest das bereits eingefrorene Fenster jedes Moduls, ohne erneut zu latchen, was dessen Wattstunden-Summe fortschreibt. totalPower() / totalEnergyWh() summieren den Verbund. Da alle Module gemeinsam gelatcht haben, sind Σ Pi und die summierten Wh kohärent — nicht drei Messungen zu drei verschiedenen Momenten.

Die loop() mit zwei Takten

Dieselbe Idee wie beim Einzelmodul-Monitor: showLive() im 1-s-Takt, rollEnergyWindow() im Takt des Energiefensters — die Live-Anzeige bleibt reaktionsschnell, während der kohärente Latch in seinem eigenen, langsameren Takt läuft.

Passen Sie es an Ihre Bedürfnisse an

  • Weitere Stromkreise — scan() verarbeitet so viele Module, wie am Bus hängen; geben Sie jedem eine eindeutige Adresse (siehe oben), dann treten sie dem Verbund automatisch bei. Achten Sie bei wachsender Anzahl auf die Regeln zu Buslast und Pull-up-Widerständen.

  • Unabhängige Verbünde — geben Sie nicht zusammenhängenden Gruppen unterschiedliche group_ids und latchen Sie jede in ihrem eigenen Takt, alles auf einem Bus.

  • Einen Bildschirm ergänzen — setzen Sie das OLED aus dem Monitor-Aufbau ein oder veröffentlichen Sie einfach p_total und die Verbund-Wh.

  • Aktionen pro Stromkreis — ein Relais pro Modul bei Überschreitung des eigenen Grenzwerts auslösen (kombinieren Sie es mit dem Relaisaufbau).

  • Den Verteiler protokollieren — eine CSV-Zeile pro Modul und Intervall auf eine SD-Karte (der Logger-Aufbau).

Wie es weitergeht

  • Handeln — ein Relais auslösen oder alarmieren, sobald ein Stromkreis einen Stromgrenzwert überschreitet, lokal, ohne Netzwerk.
  • Protokollieren — periodische Energie pro Stromkreis auf eine SD-Karte oder CSV über seriell.
  • Möchten Sie es stattdessen in Home Assistant? Derselbe Mehrmodul-Bus ist der gesamte Verteiler an einem ESP32 mit ESPHome.

Als Nächstes lesen