O que vai construir
- Tensão / corrente / potência ativa por circuito de cada módulo.
-
Uma potência ativa total coerente — a soma dos módulos, todos com latch no mesmo instante (e não três leituras amostradas de forma independente que não reconciliam — veja porque é que isso importa).
-
Tudo num barramento I²C, um Arduino — acrescente circuitos acrescentando módulos, sem novo microcontrolador.
Lista de materiais
| Item | Qtd. | Notas |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 3 | uma por circuito · produto |
| TC SCT-013 | 3 | uma por módulo, classificação por circuito · produto |
| Placa de desenvolvimento ESP32 (framework Arduino) | 1 | o alvo verificado por compilação |
| Fios de ligação (jumper) | — | o barramento I²C partilhado |
Ligue o barramento partilhado
Todos os módulos assentam no mesmo SDA / SCL / alimentação / massa — diferem apenas no endereço:
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 vem com pull-ups integradas. Com dois ou três módulos num barramento até 15 cm, deixe-as ativas em todos os módulos — nada para cortar. A partir de quatro módulos, ou num barramento mais longo, siga o guia de hardware do módulo.
-
As TC envolvem à volta dos seus condutores — o lado da corrente é não invasivo. Alimente cada módulo à sua tensão nominal. Para trabalhos dentro de um quadro elétrico, chame um eletricista qualificado.
Dê um endereço a cada módulo
Os módulos saem de fábrica com 0x50, por isso, antes de partilharem um barramento, atribua ao segundo e ao terceiro um endereço único (0x51, 0x52). Na firmware atual isto é uma operação de produção normal — sem modo especial nem ferramentas — prepara o novo endereço, arma e confirma; o módulo reinicia no novo endereço. Faça-o um módulo de cada vez, com os outros desligados, para não haver colisão — o auxiliar RbAmpFleet::provision() (ou prepareAddressChange() / commitAddressChange() de um só módulo) executa esse commit em duas fases. Sem jumper, sem botão, sem modo especial — apenas um módulo no barramento enquanto o atribui.
Sincronize e depois leia
Aqui está a parte que torna o total fiável. Em vez de ler três módulos um a seguir ao outro (cada um apanhado num instante ligeiramente diferente), envia um "latch já" broadcast para o barramento inteiro — cada módulo congela a sua janela de medição no mesmo instante. Depois lê o instantâneo congelado de cada módulo, por turnos. As leituras são sequenciais, mas os valores pertencem todos ao mesmo momento, por isso somá-los é honesto. É o mesmo princípio de coerência da construção trifásica, aqui em C++ de Arduino.
O esboço
Três módulos UI1 em 0x50 / 0x51 / 0x52, um ESP32 (framework Arduino) a 50 kHz. O auxiliar RbAmpFleet varre o barramento, inscreve cada módulo no latch broadcast uma vez, e depois cada janela de energia dispara um latch General-Call e lê o instantâneo congelado 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 compilação em ESP32 com Arduino-CLI — RbAmpFleet + Wire, sem bibliotecas extra. enableGcAll() é uma opção única; gcLatch() faz broadcast, checkSync() reporta qualquer módulo que tenha falhado o tick, e totalEnergyWh() dá a energia somada da frota.)
O que o esboço faz
O auxiliar RbAmpFleet faz a contabilidade — descobre os módulos, inscreve-os no latch broadcast e totaliza-os. Duas funções correm no ciclo: showLive() (visor por segundo) e rollEnergyWindow() (por janela de energia).
Configuração — varrer o barramento, ativar o latch da frota
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 o barramento e regista cada rbAmp que encontra (confirmando cada um pelo ID de produto); fleet.count() diz quantos responderam, para que um módulo em falta ou mal endereçado seja óbvio no arranque. enableGcAll() define a flag de latch General-Call em todos os módulos uma vez — depois disso, um único broadcast pode fazer latch do grupo inteiro.
showLive() — leituras por módulo + um total corrente
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 a frota e lê a tensão/corrente/potência em tempo real de cada módulo, por turnos. Estas leituras não precisam de estar sincronizadas — são para o visor — e soma a potência de cada módulo em p_total para um valor global do quadro em tempo real.
rollEnergyWindow() — a parte coerente
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 isto que o total é fiável. gcLatch() envia uma trama General-Call para o endereço 0x00 — cada módulo ativo congela a sua janela de medição nesse mesmo instante (desvio inferior a 10 µs em toda a frota). checkSync() verifica se cada módulo aceitou de facto o tick e nomeia os que falharam (uma linha útil de saúde da frota). Depois as leituras: readPeriodSnapshot(..., skip_latch=true) lê a janela de cada módulo já congelada sem voltar a fazer latch, o que faz avançar o total de watt-hora desse módulo. totalPower() / totalEnergyWh() somam a frota. Como todos os módulos fizeram latch em conjunto, Σ Pi e os Wh somados são coerentes — não três leituras tiradas em três momentos diferentes.
O loop() de duas cadências
Mesma ideia do monitor de módulo único: showLive() num temporizador de 1 s, rollEnergyWindow() no temporizador da janela de energia — o ecrã em tempo real mantém-se ágil enquanto o latch coerente corre na sua própria cadência, mais lenta.
Personalize-o
-
Mais circuitos — o
scan()trata de quantos módulos estiverem no barramento; dê a cada um um endereço único (ver acima) e entram na frota automaticamente. Atenção às regras de carga do barramento / pull-ups à medida que o número cresce. -
Frotas independentes — dê a grupos não relacionados
group_ids diferentes e faça latch de cada um na sua própria cadência, todos num só barramento. -
Acrescente um ecrã — encaixe o OLED do monitor Arduino, ou publique apenas
p_totale os Wh da frota. -
Ações por circuito — dispare um relé por módulo acima do seu próprio limite (combine com a construção com relé).
- Registe o quadro — uma linha CSV por módulo e por intervalo num cartão SD (a construção de registo).
O que se segue
- Atue sobre ela — dispare um relé ou alerte quando um circuito ultrapassa um limite de corrente, localmente, sem rede.
- Registe — energia periódica por circuito num cartão SD ou em CSV pela série.
- Quer no Home Assistant? O mesmo barramento multimódulo é o quadro inteiro num único ESP32 com ESPHome.