Lo que va a construir
- Tensión, corriente, potencia activa real y factor de potencia en vivo sobre una OLED de 128×64, que se actualiza aproximadamente una vez por segundo.
- Energía acumulada (Wh) en la misma pantalla: vatios-hora reales, integrados en el host sobre tiempo de reloj.
- Todo sobre un único bus I²C compartido por el módulo rbAmp y la pantalla: cuatro cables de señal en total.
- Sin Wi-Fi, sin nube, sin HA. Espejo serie para depuración; la OLED es toda la interfaz.
Lista de materiales
| Elemento | Cant. | Notas |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 1 | tensión + corriente + potencia real en el chip · producto |
| Transformador de corriente SCT-013 | 1 | calibre según su circuito · producto |
| Placa de desarrollo ESP32 (framework Arduino) | 1 | el objetivo verificado por compilación: un ESP32 da Wh honestos a largo plazo (dobles de 64 bits reales) y margen de RAM para la pantalla |
| OLED I²C SSD1306 de 128×64 | 1 | la pantalla (dirección I²C 0x3C, comparte el bus) |
| Cables de puente | — | el bus I²C compartido (SDA / SCL / VCC / GND) |
Cualquier placa compatible con Arduino sirve. El boceto es C++ de Arduino sencillo: funciona en un Uno, un Nano, un STM32, un RP2040 o un ESP32. Aquí usamos un ESP32 porque es barato, está en todas partes y tiene margen para totales de energía honestos a largo plazo. Lo único que cambia según la placa es la velocidad del bus I²C: un ESP32 quiere Wire.setClock(50000) (50 kHz, el ajuste de su driver), mientras que la mayoría de las placas que no son ESP32 usan el módulo a 100 kHz.
Conéctelo
El módulo rbAmp y la pantalla OLED están ambos en el mismo bus I²C de dos hilos; tienen direcciones distintas (0x50 para rbAmp, 0x3C para la OLED), así que coexisten sin conflicto:
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)
-
El bus funciona con lógica de 3.3 V (las líneas I²C del módulo toleran 5 V pero en reposo están a los 3.3 V del host). El módulo rbAmp lleva pull-ups de 4.7 kΩ integradas a 3.3 V, que sirven a este bus de un solo módulo más la OLED: no active las internas, más débiles, del ESP32. Atención a los niveles: VCC del rbAmp = 5 V, VCC de la OLED = 3.3 V, masa común; el propio bus I²C es de lógica de 3.3 V. (¿Por qué el rbAmp va a 5 V con un bus de 3.3 V?)
-
Las pinzas SCT-013 se colocan alrededor de un conductor aislado; nunca corte ni pele el cable vivo en el lado de corriente. El lado de tensión AC del módulo se conecta a la red. Para trabajar dentro de un cuadro eléctrico, llame a un electricista cualificado.
Instale la biblioteca
IDE de Arduino: Sketch → Include Library → Manage Libraries… [Sketch → Incluir biblioteca → Gestionar bibliotecas…], busque RbAmp e instale. O con arduino-cli:
arduino-cli lib install RbAmp
También necesitará el driver de la OLED: instale Adafruit SSD1306 (v2.5.14) desde el Gestor de bibliotecas [Library Manager]; trae Adafruit GFX y Adafruit BusIO automáticamente.
El boceto
Copie esto, ajuste MY_CT para que coincida con su pinza y grabe. Está pensado para un ESP32 (framework Arduino) a 50 kHz (el ajuste del driver I²C de ESP-IDF; un host que no es ESP32, como un Uno/Nano, usaría 100 kHz), con una 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 compilación en ESP32 con Arduino-CLI: Adafruit SSD1306 v2.5.14 + Adafruit GFX. setCTModel() escribe en la memoria flash, así que el boceto solo reescribe el preajuste de CT cuando realmente cambia; sin desgaste de flash en cada arranque.)
Lo que hace el boceto
Toda la biblioteca Arduino de rbAmp aparece en un puñado de llamadas. Dos funciones hacen el trabajo real: readLive() cada segundo y rollEnergy() cada 30 segundos, impulsadas por un loop() de doble cadencia. Aquí va cada pieza.
Puesta en marcha: enlace, sondee, configure
RbAmp dev(Wire, 0x50, RbAmpTopology::Single); // bus, address, topology
...
while (!dev.begin()) { /* print errorString(), retry */ }
ensureCtModel();
RbAmp dev(Wire, 0x50, RbAmpTopology::Single) vincula la biblioteca al bus I²C y al módulo en 0x50; Single indica que es un UI1 de un canal (un UI2/UI3 pasaría SplitPhase / ThreePhase). begin() sondea el módulo y lee sus capacidades; repita hasta que devuelva true, imprimiendo RbAmp::errorString(dev.lastError()) para que un error de cableado sea obvio. ensureCtModel() lee el preajuste de CT almacenado en el módulo y solo lo escribe si difiere (setCTModel() persiste en la flash); así se evita desgastar la flash en cada arranque.
readLive(): la lectura de una vez por 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 cuatro lecturas obtienen las medidas reales del módulo: readPower(0) es la potencia activa real en vatios: la media de tensión instantánea × corriente, no corriente × una tensión supuesta. Cualquier lectura puede devolver ocasionalmente NaN (un fallo transitorio del bus); el boceto conserva el último valor bueno (lastV, lastI, …) para que la pantalla nunca parpadee a cero, e incrementa un contador ok=/bad= que puede vigilar en pantalla. Después llama a drawLive() para pintar la OLED.
rollEnergy() — el total de energía honesto
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) { /* stale/not-ready: report + skip */ return; }
// dev.energy().wh(0) has now advanced for this window
La energía funciona de forma distinta a las lecturas en vivo. readPeriodSnapshot() envía al módulo un LATCH atómico («cierre la ventana de medida actual ahora»), espera el asentamiento y lee la potencia media de esa ventana. Después la biblioteca avanza el total de vatios-hora del host: energy = average_power × elapsed_wall-clock_time. Como el host es dueño del intervalo de integración, no hay un contador en el dispositivo que cuantizar o desviar; dev.energy().wh(0) es un total corriente honesto. Si un periodo llega obsoleto o no listo, la función lo informa y vuelve; la pantalla sigue funcionando con los últimos valores en vivo.
El loop() de doble cadencia
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
Dos temporizadores independientes: la pantalla en vivo se actualiza cada LIVE_MS (1 s) para una lectura ágil, mientras que el latch de energía, más pesado, solo se ejecuta cada ENERGY_MS (30 s). Desacoplarlos mantiene la pantalla fluida sin fijar el módulo 60 veces por minuto. Cambie cualquiera de las dos constantes a su gusto.
Lo que verá
En la OLED, una lectura en vivo que sigue la carga: conecte una lámpara o un hervidor y vea cómo saltan los vatios. En el monitor serie [Serial Monitor] (115200 baudios), los mismos valores se desplazan para depuración:
V=230.4 I=0.211 P=48.2 PF=0.97 Wh=12.345
[captura / foto: espacio multimedia: la OLED mostrando una lectura en vivo en el banco de pruebas]
¿Qué tan precisa es?
Con una pinza SCT-013, la clase y la tolerancia propia de la pinza se publican por calibre en la tabla de precisión de la SCT-013. La precisión se amplía cerca del extremo bajo del calibre. El módulo mide la potencia activa real con compensación de fase por canal, así que las cargas reactivas y de bajo factor de potencia se leen honestamente, no como potencia aparente inflada. Para el porqué detrás de las cifras, vea cómo funciona realmente la medición de energía con CT.
Adáptelo a su instalación
Algunas pequeñas adiciones, una vez que esté en marcha:
-
Un contador de disparos reiniciable: mantenga su propio
double kwh_sessionjunto al total de por vida y bórrelo con un pulsador en un GPIO libre, para una lectura de «desde que lo pulsé». -
Mostrar más: el módulo también informa de la frecuencia; añada un registrador de mínimo/máximo de potencia, o una línea de kWh (
wh / 1000.0). -
Una alarma suave: haga parpadear la OLED o un LED cuando la potencia cruce un umbral (no hace falta relé para un aviso solo visual).
-
Envíelo fuera: está en un ESP32, así que tiene Wi-Fi: publique las lecturas por MQTT a su propio broker, o sirva una pequeña página web, sin renunciar a la OLED local.
-
Más lento o más rápido: baje
LIVE_MSpara una gráfica más viva, o subaENERGY_MSsi un paso de energía de 30 s le parece bien.
Nada de esto toca la medición: son todas las cosas que puede hacer con los números que readLive() y rollEnergy() ya le entregan.
Qué sigue
Este módulo solo en una pantalla es la base. A partir de aquí, la serie Arduino se va construyendo:
- Mida varios circuitos a la vez: varios módulos rbAmp en el mismo bus, leídos y totalizados por un solo Arduino.
-
Actúe con la lectura: dispare un relé o suene un zumbador cuando un circuito supere un límite de corriente, todo en local, sin red.
-
Regístrelo: escriba la energía periódica en una tarjeta SD o envíe el CSV a un PC.
(¿Lo prefiere en Home Assistant? El mismo módulo encaja en ESPHome.)