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) |
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:
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:
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:
/**
* 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
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
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
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
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:
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_sessionao 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_MSpara um gráfico mais animado, ou suba oENERGY_MSse 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.)