rbAmp
PT
Loja

Projeto · · 13 min de leitura

Várias pinças SCT-013 num Arduino: medição de muitos circuitos por um barramento

Dois ou três módulos rbAmp num barramento I²C atrás de um único Arduino: um latch broadcast, potência por circuito e um total coerente do quadro inteiro.

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:

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-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:

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

(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

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

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

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

É 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_total e 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.

Leia a seguir