rbAmp
PT
Loja

Projeto · · 15 min de leitura

Monitor de energia Arduino com pinças SCT-013: watts num OLED, sem rede

Sem Wi-Fi, sem nuvem, sem Home Assistant — apenas um Arduino, um módulo rbAmp e um pequeno OLED a mostrar volts, amperes, watts e quilowatt-hora reais. A porta de entrada para principiantes na biblioteca Arduino rbAmp.

O que vai construir

  • Tensão, corrente, potência ativa e fator de potência em tempo real num OLED de 128×64, atualizado cerca de uma vez por segundo.
  • Energia acumulada (Wh) no mesmo ecrã — watt-hora reais, integrados no anfitrião em tempo de relógio.
  • Tudo através de um único barramento I²C partilhado pelo módulo rbAmp e pelo ecrã — quatro fios de sinal no total.
  • Sem Wi-Fi, sem nuvem, sem HA. Espelho na série para depuração; o OLED é a interface completa.

Lista de materiais

Item Qtd. Notas
rbAmp BASIC SCT-UI1 1 tensão + corrente + potência ativa calculada no módulo · produto
Transformador de corrente SCT-013 1 classificação adequada ao seu circuito · produto
Placa de desenvolvimento ESP32 (framework Arduino) 1 o alvo verificado por compilação — um ESP32 dá Wh de longo prazo honestos (duplos de 64 bits reais) e folga de RAM para o ecrã
OLED I²C SSD1306 128×64 1 o visor (endereço I²C 0x3C, partilha o barramento)
Fios de ligação (jumper) — o barramento I²C partilhado (SDA / SCL / VCC / GND)
Nota

Qualquer placa compatível com Arduino funciona. O esboço é C++ Arduino simples — corre num Uno, Nano, STM32, RP2040 ou ESP32. Usámos um ESP32 aqui porque é barato, está em todo o lado e tem folga para totais de energia honestos a longo prazo. O único aspeto que muda por placa é a velocidade do barramento I²C: um ESP32 quer Wire.setClock(50000) (50 kHz, a definição do seu driver), enquanto a maioria das placas não ESP32 corre o módulo a 100 kHz.

Ligue tudo

O módulo rbAmp e o OLED estão ambos no mesmo barramento I²C de dois fios — têm endereços diferentes (0x50 para o rbAmp, 0x3C para o OLED), por isso coexistem sem conflito:

Text
Arduino                     rbAmp (0x50)        OLED (0x3C)
-------                     ------------        -----------
SDA  ───────────────┬────── SDA ───────┬─────── SDA
SCL  ───────────────┼────── SCL ───────┼─────── SCL
5V   ───────────────┼────── VCC        └─(3.3V) VCC   *(check your OLED's voltage)*
GND  ───────────────┴────── GND ──────────────── GND
                            │
                            └── SCT-013 clamped around ONE mains conductor (arrow → load)
  • O barramento funciona com lógica de 3.3 V (as linhas I²C do módulo toleram 5 V mas ficam em repouso nos 3.3 V do anfitrião). O módulo rbAmp tem pull-ups de 4.7 kΩ integradas para 3.3 V, que servem este barramento de um módulo mais o OLED — não ative as pull-ups internas, mais fracas, do ESP32. Atenção aos níveis: VCC do rbAmp = 5 V, VCC do OLED = 3.3 V, massa comum — o próprio barramento I²C é lógica de 3.3 V. (Porque é que o rbAmp é alimentado a 5 V com um barramento de 3.3 V?)

  • As pinças SCT-013 envolvem à volta um condutor isolado — nunca corte nem descasque um fio sob tensão do lado da corrente. O lado de tensão AC do módulo liga-se à rede. Para trabalhos dentro de um quadro elétrico, chame um eletricista qualificado.

Instale a biblioteca

IDE do Arduino: Sketch → Incluir biblioteca → Gerir bibliotecas… (Sketch → Include Library → Manage Libraries…), pesquise RbAmp, instale. Ou com arduino-cli:

Text
arduino-cli lib install RbAmp

Vai também precisar do driver do OLED — instale o Adafruit SSD1306 (v2.5.14) pelo Gestor de Bibliotecas (Library Manager); ele traz o Adafruit GFX e o Adafruit BusIO automaticamente.

O esboço

Copie isto, defina MY_CT para corresponder à sua pinça e carregue o firmware. Foi construído para um ESP32 (framework Arduino) a 50 kHz (a definição do driver I²C ESP-IDF — um anfitrião que não seja ESP32, como um Uno/Nano, usaria 100 kHz), com um OLED Adafruit SSD1306:

C++
/**
 * StandaloneMonitor.ino — a standalone Arduino energy monitor (no network, no HA).
 *
 * One rbAmp UI1 module + an ESP32 + a 128x64 SSD1306 I2C OLED on the same two-wire
 * bus. Shows Voltage / Current / Power / Power Factor live (~1 s) and a
 * host-integrated Energy (Wh) total. Wh is integrated on the master from avg power
 * x wall-clock dt — that's what makes the total honest.
 *
 * Board:  ESP32 (Arduino framework)  -- esp32:esp32:esp32
 * Bus:    I2C @ 50 kHz  (Wire.setClock(50000)) -- required on ESP32-Arduino (its
 *         Wire wraps the ESP-IDF i2c driver). On a non-ESP32 host use 100 kHz.
 * OLED:   Adafruit_SSD1306 + Adafruit_GFX (addr 0x3C, shares SDA/SCL with rbAmp).
 *
 * Wiring:
 *   SDA -> GPIO21           (both devices)
 *   SCL -> GPIO22           (both devices)
 *   rbAmp VCC -> 5 V        (4.5-5.5 V; below 4.5 V the ADC loses accuracy)
 *   OLED  VCC -> 3.3 V
 *   GND       -> GND        (common ground, both devices)
 *   ~4.7 kOhm pull-ups on SDA and SCL to 3.3 V (host logic level)
 *   OLED 0x3C, rbAmp 0x50
 *
 * Accuracy: per clamp rating — the class and the sensor's own tolerance are both in the accuracy table on the BASIC page.
 */
#include 
#include 
#include 
#include 

/* ---- configuration -------------------------------------------------------- */
static const uint8_t      RBAMP_ADDR = 0x50;
static const uint8_t      OLED_ADDR  = 0x3C;
static const uint16_t     OLED_W     = 128;
static const uint16_t     OLED_H     = 64;
static const uint32_t     I2C_HZ     = 50000;   /* ESP32-Arduino: 50 kHz */

/* Match this to your clamp: Sct013_005 / _010 / _030 / _050 / _020. */
static const RbAmpCTModel MY_CT      = RbAmpCTModel::Sct013_030;

static const uint32_t     LIVE_MS    = 1000;    /* refresh V/I/P/PF each second */
static const uint32_t     ENERGY_MS  = 30000;   /* latch a period + roll Wh every 30 s */

/* ---- objects -------------------------------------------------------------- */
static Adafruit_SSD1306 oled(OLED_W, OLED_H, &Wire, -1);
static RbAmp            dev(Wire, RBAMP_ADDR, RbAmpTopology::Single);

static bool     oled_ok        = false;
static uint32_t next_live_ms   = 0;
static uint32_t next_energy_ms = 0;

/* Last-good live values: a single transient read hiccup should not blank the
 * display, so we hold the previous plausible reading. */
static float lastV = NAN, lastI = NAN, lastP = NAN, lastPF = NAN;
static uint32_t reads_ok = 0, reads_bad = 0;

/* ---- helpers -------------------------------------------------------------- */
static void banner(const __FlashStringHelper* l1, const char* l2) {
    if (!oled_ok) return;
    oled.clearDisplay();
    oled.setTextSize(1);
    oled.setTextColor(SSD1306_WHITE);
    oled.setCursor(0, 0);
    oled.println(l1);
    oled.println(l2);
    oled.display();
}

/* Apply the CT model only if the module isn't already on it (setCTModel()
 * persists to flash, so we avoid rewriting the same value every boot). */
static void ensureCtModel() {
    uint8_t applied = 0;
    if (dev.readCTModelCh(0, applied) && applied == static_cast(MY_CT)) {
        Serial.println(F("CT model already set; skipping flash write"));
        return;
    }
    Serial.println(F("configuring CT model (persists to flash)..."));
    if (!dev.setSensorClass(RbAmpSensorClass::Sct013) || !dev.setCTModel(MY_CT)) {
        Serial.print(F("CT config failed: "));
        Serial.println(RbAmp::errorString(dev.lastError()));
    }
}

static void drawLive() {
    if (!oled_ok) return;
    oled.clearDisplay();
    oled.setTextColor(SSD1306_WHITE);

    /* Power headline, big. */
    oled.setTextSize(2);
    oled.setCursor(0, 0);
    oled.print(isnan(lastP) ? 0.0f : lastP, 0);
    oled.println(F(" W"));

    /* V / I / PF row. */
    oled.setTextSize(1);
    oled.setCursor(0, 20);
    oled.print(isnan(lastV) ? 0.0f : lastV, 1);  oled.print(F("V  "));
    oled.print(isnan(lastI) ? 0.0f : lastI, 3);  oled.print(F("A  PF"));
    oled.println(isnan(lastPF) ? 0.0f : lastPF, 2);

    /* Energy total. */
    oled.setCursor(0, 36);
    oled.print(F("Energy: "));
    oled.print(dev.energy().wh(0), 3);
    oled.println(F(" Wh"));

    /* Health line. */
    oled.setCursor(0, 52);
    oled.print(F("ok="));  oled.print(reads_ok);
    oled.print(F(" bad=")); oled.print(reads_bad);
    oled.display();
}

static void readLive() {
    float v  = dev.readVoltage();
    float i  = dev.readCurrent(0);
    float p  = dev.readPower(0);
    float pf = dev.readPowerFactor(0);

    if (!isnan(v))  lastV  = v;
    if (!isnan(i))  lastI  = i;
    if (!isnan(p))  lastP  = p;
    if (!isnan(pf)) lastPF = pf;

    if (isnan(v) && isnan(i) && isnan(p)) reads_bad++; else reads_ok++;

    Serial.print(F("V="));   Serial.print(lastV, 1);
    Serial.print(F(" I="));  Serial.print(lastI, 3);
    Serial.print(F(" P="));  Serial.print(lastP, 1);
    Serial.print(F(" PF=")); Serial.print(lastPF, 2);
    Serial.print(F(" Wh=")); Serial.println(dev.energy().wh(0), 3);

    drawLive();
}

/* Latch a metering period; the library rolls Wh from avg power x master dt on a
 * successful, valid snapshot. A stale/not-ready period is reported and skipped
 * so the display keeps running on the last live values. */
static void rollEnergy() {
    RbAmpPeriodSnapshot snap;
    if (!dev.readPeriodSnapshot(snap)) {
        Serial.print(F("period skipped: "));
        Serial.println(RbAmp::errorString(dev.lastError()));
        return;
    }
    Serial.print(F("period ok: avg_P0="));
    Serial.print(snap.avg_p[0], 2);
    Serial.print(F("W dt="));
    Serial.print(snap.master_dt_ms);
    Serial.print(F("ms -> Wh="));
    Serial.println(dev.energy().wh(0), 4);
}

/* ---- lifecycle ------------------------------------------------------------ */
void setup() {
    Serial.begin(115200);
    while (!Serial && millis() < 2000) {}

    Wire.begin();
    Wire.setClock(I2C_HZ);

    oled_ok = oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
    if (oled_ok) {
        banner(F("rbAmp monitor"), "booting...");
    } else {
        Serial.println(F("OLED init failed - running headless on Serial"));
    }

    dev.setLogStream(&Serial);
    uint8_t tries = 0;
    while (!dev.begin()) {
        const char* why = RbAmp::errorString(dev.lastError());
        Serial.print(F("rbAmp begin failed: "));
        Serial.println(why);
        banner(F("no rbAmp - retry"), why);
        if (++tries % 5 == 0)
            Serial.println(F("check wiring: SDA/SCL/power/GND + pull-ups"));
        delay(1000);
    }
    Serial.println(F("rbAmp online"));
    ensureCtModel();

    uint32_t now   = millis();
    next_live_ms   = now;
    next_energy_ms = now + ENERGY_MS;
}

void loop() {
    uint32_t now = millis();

    if (static_cast(now - next_live_ms) >= 0) {
        next_live_ms = now + LIVE_MS;
        readLive();
    }
    if (static_cast(now - next_energy_ms) >= 0) {
        next_energy_ms = now + ENERGY_MS;
        rollEnergy();
    }

    delay(5);
}

(Verificado por compilação em ESP32 com Arduino-CLI — Adafruit SSD1306 v2.5.14 + Adafruit GFX. setCTModel() grava na flash, por isso o esboço só reescreve a predefinição do TC quando esta muda de facto — sem desgaste da flash em cada arranque.)

O que o esboço faz

A biblioteca Arduino rbAmp inteira aparece em meia dúzia de chamadas. Duas funções fazem o trabalho real — readLive() a cada segundo e rollEnergy() a cada 30 segundos — conduzidas por um loop() de duas cadências. Eis cada peça.

Configuração — ligar, sondar, configurar

C++
RbAmp dev(Wire, 0x50, RbAmpTopology::Single);   // bus, address, topology
...
while (!dev.begin()) { /* print errorString(), retry */ }
ensureCtModel();

RbAmp dev(Wire, 0x50, RbAmpTopology::Single) liga a biblioteca ao barramento I²C e ao módulo no 0x50; Single indica que é um UI1 de um canal (um UI2/UI3 passaria SplitPhase / ThreePhase). begin() sonda o módulo e lê as suas capacidades — execute-o em ciclo até devolver true, imprimindo RbAmp::errorString(dev.lastError()) para que um erro de ligação seja óbvio. ensureCtModel() lê a predefinição de TC guardada no módulo e só a escreve se for diferente (setCTModel() grava na flash) — evita desgastar a flash em cada arranque.

readLive() — a leitura de cada segundo

C++
float v  = dev.readVoltage();
float i  = dev.readCurrent(0);
float p  = dev.readPower(0);
float pf = dev.readPowerFactor(0);
if (!isnan(v)) lastV = v;   // hold last-good on a transient miss

Estas quatro leituras obtêm as medições reais do módulo: readPower(0) é a potência ativa real em watts — a média de tensão instantânea × corrente, não corrente × uma tensão assumida. Qualquer leitura pode ocasionalmente devolver NaN (um soluço transitório do barramento); o esboço mantém o valor bom anterior (lastV, lastI, …) para que o ecrã nunca pisque para zero, e incrementa um contador ok=/bad= que pode acompanhar no ecrã. Depois chama drawLive() para pintar o OLED.

rollEnergy() — o total de energia honesto

C++
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) { /* stale/not-ready: report + skip */ return; }
// dev.energy().wh(0) has now advanced for this window

A energia funciona de forma diferente das leituras em tempo real. readPeriodSnapshot() envia ao módulo um LATCH atómico — "fecha a janela de medição atual agora" — espera o assentamento, e lê a potência média dessa janela. A biblioteca faz então avançar o total de watt-hora do lado do anfitrião: energia = potência média × tempo decorrido em relógio. Como o anfitrião é dono do intervalo de integração, não há contador no dispositivo que quantize ou derive — dev.energy().wh(0) é um total corrente honesto. Se um período chegar obsoleto ou não pronto, a função assinala-o e retorna; o visor continua a correr com os últimos valores em tempo real.

O loop() de duas cadências

C++
if (now - next_live_ms   >= 0) { next_live_ms   += LIVE_MS;   readLive();   }   // 1 s
if (now - next_energy_ms >= 0) { next_energy_ms += ENERGY_MS; rollEnergy(); }   // 30 s

Dois temporizadores independentes: o visor em tempo real atualiza a cada LIVE_MS (1 s) para uma leitura responsiva, enquanto o latch de energia, mais pesado, corre apenas a cada ENERGY_MS (30 s). Separá-los mantém o ecrã ágil sem fazer latch no módulo 60 vezes por minuto. Altere qualquer das constantes ao seu gosto.

O que verá

No OLED, uma leitura ao vivo que acompanha a carga — ligue um candeeiro ou uma chaleira e veja os watts subir. No Monitor Série (Serial Monitor, 115200 baud), os mesmos valores passam para depuração:

Text
V=230.4 I=0.211 P=48.2 PF=0.97 Wh=12.345

[captura de ecrã / fotografia — espaço para media: o OLED a mostrar uma leitura ao vivo na bancada]

Quão exato é?

Com uma pinça SCT-013, a classe e a tolerância da própria pinça são publicadas por classificação na tabela de exatidão SCT-013. A exatidão alarga perto da extremidade mais baixa da classificação. O módulo mede potência ativa real com compensação de fase por canal — por isso cargas reativas e de baixo fator de potência são lidas com honestidade, e não como potência aparente inflacionada. Para o porquê por trás dos números, veja como a medição de energia por TC funciona na prática.

Personalize-o

Algumas pequenas adições, depois de estar a correr:

  • Um contador de disparos reposicionável — guarde o seu próprio double kwh_session ao lado do total vitalício e ponha-o a zero com um botão de pressão num GPIO livre para uma leitura de "desde que o premi".

  • Mostrar mais — o módulo também reporta a frequência; acrescente um registador de mín./máx. de potência, ou uma linha em kWh (wh / 1000.0).

  • Um alerta sonoro — faça piscar o OLED ou um LED quando a potência cruza um limiar (sem relé, para um aviso apenas no ecrã).

  • Envie-o para fora — está num ESP32, por isso tem Wi-Fi: publique as leituras por MQTT para o seu próprio broker, ou sirva uma pequena página web — sem abdicar do OLED local.

  • Mais lento ou mais rápido — baixe o LIVE_MS para um gráfico mais animado, ou suba o ENERGY_MS se um passo de energia de 30 s estiver bem.

Nenhuma destas toca na medição — são apenas o que faz com os números que readLive() e rollEnergy() já lhe entregam.

O que se segue

Este módulo num ecrã é a base. A partir daqui a série Arduino avança:

  • Meça vários circuitos de uma vez — vários módulos rbAmp no mesmo barramento, lidos e totalizados por um Arduino.
  • Atue sobre a leitura — dispare um relé ou faça soar um buzzer quando um circuito excede um limite de corrente, tudo localmente, sem rede.

  • Registe — escreva energia periódica num cartão SD ou transmita CSV para um PC.

(Prefere-o no Home Assistant? O mesmo módulo encaixa no ESPHome.)


Leia a seguir