rbAmp
ES
Tienda

Proyecto · · 15 min de lectura

Monitor de energía con Arduino y pinzas SCT-013: vatios en una OLED, sin red

Sin Wi-Fi, sin nube, sin Home Assistant: solo un Arduino, un módulo rbAmp y una pequeña OLED que muestra voltios, amperios, vatios y kilovatios-hora reales. La entrada para principiantes a la biblioteca Arduino de rbAmp.

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

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:

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

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

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

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

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

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

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

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:

Text
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_session junto 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_MS para una gráfica más viva, o suba ENERGY_MS si 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.)


Lea a continuación