Lo que va a construir
- Por circuito: tensión / corriente / potencia activa real de cada módulo.
-
Una potencia activa total coherente: la suma de los módulos, todos fijados en el mismo instante (no tres lecturas muestreadas de forma independiente que no cuadran; vea por qué importa).
-
Todo en un bus I²C, un Arduino: añada circuitos añadiendo módulos, sin microcontrolador nuevo.
Lista de materiales
| Elemento | Cant. | Notas |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 3 | una por circuito · producto |
| CT SCT-013 | 3 | una por módulo, calibre por circuito · producto |
| Placa de desarrollo ESP32 (framework Arduino) | 1 | el objetivo verificado por compilación |
| Cables de puente | — | el bus I²C compartido |
Cablee el bus compartido
Todos los módulos están en el mismo SDA / SCL / alimentación / masa: solo se diferencian por la dirección:
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-ups: cada módulo viene con pull-ups integradas. Con dos o tres módulos en un bus de hasta 15 cm, déjelas activas en todos los módulos: no hay nada que cortar. A partir de cuatro módulos, o en un bus más largo, siga el documento de hardware del módulo.
-
Las CT se colocan alrededor de sus conductores: el lado de corriente es no invasivo. Alimente cada módulo a su tensión nominal. Para trabajar dentro de un cuadro eléctrico, llame a un electricista cualificado.
Asigne una dirección a cada módulo
Los módulos salen de fábrica en 0x50, así que antes de que puedan compartir un bus asigne al segundo y al tercero una dirección única (0x51, 0x52). En el firmware actual esto es una operación de producción normal, sin modo especial ni herramientas: prepara la nueva dirección, la arma y la confirma; el módulo se reinicia en su nueva dirección. Hágalo un módulo cada vez, con los demás desconectados, para que no haya colisión de direcciones: el auxiliar RbAmpFleet::provision() (o prepareAddressChange() / commitAddressChange() de un solo módulo) ejecuta esa confirmación en dos fases. Sin puente, sin botón, sin modo especial: solo un módulo en el bus mientras le asigna la dirección.
Sincronice y luego lea
Aquí está la parte que hace fiable el total. En lugar de leer tres módulos uno tras otro (cada uno captado en un momento ligeramente distinto), envía un «latch ahora» de difusión a todo el bus: cada módulo congela su ventana de medida en el mismo instante. Después lee la instantánea congelada de cada módulo por turno. Las lecturas son secuenciales, pero los valores pertenecen todos al mismo momento, así que sumarlos es honesto. Es el mismo principio de coherencia de la construcción trifásica, aquí en C++ de Arduino.
El boceto
Tres módulos UI1 en 0x50 / 0x51 / 0x52, un ESP32 (framework Arduino) a 50 kHz. El auxiliar RbAmpFleet escanea el bus, incorpora cada módulo al latch de difusión una sola vez, y en cada ventana de energía dispara un latch General-Call y lee la instantánea congelada de cada módulo:
/**
* 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);
}
(Verificado por compilación en ESP32 con Arduino-CLI: RbAmpFleet + Wire, sin bibliotecas adicionales. enableGcAll() es una activación única; gcLatch() difunde, checkSync() informa de cualquier módulo que haya perdido el tic y totalEnergyWh() da la energía sumada de la flota.)
Lo que hace el boceto
El auxiliar RbAmpFleet hace la contabilidad de la flota: descubre los módulos, los incorpora al latch de difusión y los totaliza. Dos funciones se ejecutan en el bucle: showLive() (pantalla por segundo) y rollEnergyWindow() (por ventana de energía).
Puesta en marcha: escanee el bus, active el latch de la flota
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() recorre el bus y registra cada rbAmp que encuentra (confirmando cada uno por su ID de producto); fleet.count() indica cuántos han respondido, de modo que un módulo que falta o tiene mala dirección salta a la vista al arrancar. enableGcAll() activa una vez la bandera de latch de General-Call en cada módulo; después, una sola difusión puede fijar todo el grupo.
showLive(): lecturas por módulo más un total corriente
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
}
Recorre la flota y lee la tensión/corriente/potencia en vivo de cada módulo por turno. Estas lecturas en vivo no necesitan estar sincronizadas, son para la pantalla, y suma la potencia de cada módulo en p_total para una cifra en vivo de todo el cuadro.
rollEnergyWindow(): la parte coherente
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);
Por esto el total es fiable. gcLatch() envía una trama General-Call a la dirección 0x00: cada módulo habilitado congela su ventana de medida en ese mismo instante (desfase inferior a 10 µs en toda la flota). checkSync() verifica que cada módulo aceptó el tic y nombra los que lo perdieron (una práctica línea de salud de la flota). Luego las lecturas: readPeriodSnapshot(..., skip_latch=true) lee la ventana ya congelada de cada módulo sin volver a fijarla, lo que avanza el total de vatios-hora de ese módulo. totalPower() / totalEnergyWh() suman la flota. Como todos los módulos se fijaron juntos, Σ Pi y los Wh sumados son coherentes, no tres lecturas tomadas en tres momentos distintos.
El loop() de doble cadencia
La misma idea que el monitor de un solo módulo: showLive() con un temporizador de 1 s, rollEnergyWindow() con el temporizador de ventana de energía; la pantalla en vivo sigue respondiendo mientras el latch coherente funciona con su propia cadencia, más lenta.
Adáptelo a su instalación
-
Más circuitos:
scan()gestiona cuantos módulos haya en el bus; dé a cada uno una dirección única (véase arriba) y se unen a la flota automáticamente. Tenga en cuenta las reglas de carga del bus y de pull-ups a medida que aumenta el número. -
Flotas independientes: asigne a grupos sin relación
group_iddistintos y fije cada uno con su propia cadencia, todos en un mismo bus. -
Añada una pantalla: incorpore la OLED del proyecto de monitor, o simplemente publique
p_totaly los Wh de la flota. -
Acciones por circuito: dispare un relé por módulo cuando supere su propio límite (combínelo con la construcción con relé).
- Registre el cuadro: una fila por módulo y por intervalo en una tarjeta SD (la versión de registro).
Qué sigue
- Actúe: dispare un relé o avise cuando un circuito cruce un límite de corriente, en local, sin red.
- Regístrelo: energía periódica por circuito en una tarjeta SD o en CSV por puerto serie.
- ¿Lo quiere en Home Assistant? El mismo bus multimódulo es todo el cuadro en un ESP32 con ESPHome.