rbAmp
IT
Negozio

Progetto · · 15 min di lettura

Misuratore di energia Arduino con TA SCT-013: watt su OLED, senza rete

Niente Wi-Fi, niente cloud, niente Home Assistant — solo un Arduino, un modulo rbAmp e un piccolo OLED che mostra volt, ampere, watt e kilowattora reali. Il punto di partenza per principianti per la libreria Arduino rbAmp.

Cosa costruirà

  • Tensione, corrente, potenza attiva reale e fattore di potenza live su un OLED 128×64, aggiornato circa una volta al secondo.
  • Energia (Wh) accumulata sullo stesso schermo — wattora reali, integrati sull'host nel tempo dell'orologio.
  • Tutto su un unico bus I²C condiviso dal modulo rbAmp e dal display — quattro fili di segnale in tutto.
  • Nessun Wi-Fi, nessun cloud, nessun HA. Specchio seriale per il debug; l'OLED è l'intera interfaccia.

Distinta dei materiali

Voce Q.tà Note
rbAmp BASIC SCT-UI1 1 tensione + corrente + potenza reale a bordo · prodotto
Trasformatore di corrente SCT-013 1 portata da adattare al suo circuito · prodotto
Scheda di sviluppo ESP32 (framework Arduino) 1 il target verificato in compilazione — un ESP32 offre Wh a lungo termine onesti (double a 64 bit reali) e margine di RAM per il display
OLED I²C SSD1306 128×64 1 il display (indirizzo I²C 0x3C, condivide il bus)
Cavetti jumper — il bus I²C condiviso (SDA / SCL / VCC / GND)
Nota

Qualsiasi scheda compatibile Arduino funziona. Lo sketch è C++ Arduino semplice — gira su un Uno, un Nano, uno STM32, un RP2040 o un ESP32. Qui abbiamo usato un ESP32 perché è economico, diffuso e ha margine per totali energetici onesti a lungo termine. L'unica cosa che cambia da scheda a scheda è la velocità del bus I²C: un ESP32 vuole Wire.setClock(50000) (50 kHz, impostazione del suo driver), mentre la maggior parte delle schede non ESP32 fa girare il modulo a 100 kHz.

Lo cablili

Il modulo rbAmp e l'OLED si trovano entrambi sullo stesso bus I²C a due fili — hanno indirizzi diversi (0x50 per rbAmp, 0x3C per l'OLED), quindi coesistono senza conflitti:

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)
  • Il bus lavora a logica 3.3 V (le linee I²C del modulo tollerano 5 V ma restano a riposo sui 3.3 V dell'host). Il modulo rbAmp ha pull-up a bordo da 4.7 kΩ verso 3.3 V, che servono questo bus con un solo modulo più l'OLED — non abiliti quelli interni deboli dell'ESP32. Notare i livelli: VCC rbAmp = 5 V, VCC OLED = 3.3 V, massa comune — il bus I²C stesso è a logica 3.3 V. (Perché rbAmp è alimentato a 5 V con un bus a 3.3 V?)

  • I TA SCT-013 si stringono attorno a un conduttore isolato — per il lato corrente non taglia né spella mai il filo sotto tensione. Il lato di tensione CA del modulo si collega alla rete. Per lavori all'interno di un quadro elettrico, si rivolga a un elettricista qualificato.

Installazione della libreria

Arduino IDE: Sketch → Includi libreria → Gestisci librerie…, cerchi RbAmp, installi. Oppure con arduino-cli:

Text
arduino-cli lib install RbAmp

Le serve anche il driver OLED — installi Adafruit SSD1306 (v2.5.14) dal Library Manager; si porta dietro automaticamente Adafruit GFX e Adafruit BusIO.

Lo sketch

Copi questo nel suo sketch, imposti MY_CT in base al suo TA, e faccia il flash. È pensato per un ESP32 (framework Arduino) a 50 kHz (impostazione del driver I²C ESP-IDF — un host non ESP32 come Uno/Nano userebbe 100 kHz), con un 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);
}

(Verificato in compilazione su ESP32 con Arduino-CLI — Adafruit SSD1306 v2.5.14 + Adafruit GFX. setCTModel() scrive nella flash, quindi lo sketch riscrive il preset TA solo quando cambia davvero — nessun consumo della flash a ogni avvio.)

Cosa fa lo sketch

L'intera libreria Arduino rbAmp si utilizza con una manciata di chiamate. Due funzioni fanno il lavoro vero — readLive() ogni secondo e rollEnergy() ogni 30 secondi — guidate da un loop() a doppia cadenza. Ecco ogni pezzo.

Configurazione — collegamento, interrogazione, impostazione

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

RbAmp dev(Wire, 0x50, RbAmpTopology::Single) collega la libreria al bus I²C e al modulo su 0x50; Single indica che è un UI1 monocanale (un UI2/UI3 userebbe SplitPhase / ThreePhase). begin() interroga il modulo e ne legge le capacità — lo ripeta finché non restituisce true, stampando RbAmp::errorString(dev.lastError()) così un errore di cablaggio è evidente. ensureCtModel() legge il preset TA memorizzato nel modulo e lo scrive solo se differisce (setCTModel() persiste nella flash) — così si evita di consumare la flash a ogni avvio.

readLive() — la lettura al secondo

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

Queste quattro letture prelevano le misure reali del modulo: readPower(0) è la potenza attiva reale in watt — la media di tensione istantanea × corrente, non corrente × una tensione presunta. Qualsiasi lettura può occasionalmente restituire NaN (un'instabilità transitoria del bus); lo sketch mantiene l'ultimo valore buono (lastV, lastI, …) così il display non torna mai a zero, e incrementa un contatore ok=/bad= che può osservare sullo schermo. Poi chiama drawLive() per disegnare l'OLED.

rollEnergy() — il totale energetico onesto

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

L'energia funziona diversamente dalle letture live. readPeriodSnapshot() invia al modulo un LATCH atomico — "chiudi ora la finestra di misura corrente" — attende il settle, e legge la potenza media di quella finestra. La libreria poi aggiorna lato host il totale in wattora: energy = average_power × elapsed_wall-clock_time. Poiché è l'host a possedere l'intervallo di integrazione, non c'è alcun contatore on-device da quantizzare o far derivare — dev.energy().wh(0) è un totale in corso onesto. Se un periodo torna non aggiornato o non pronto, la funzione lo segnala e ritorna; il display continua a girare sugli ultimi valori live.

Il loop() a doppia cadenza

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

Due timer indipendenti: il display live si aggiorna ogni LIVE_MS (1 s) per una lettura reattiva, mentre il latch energia, più pesante, viene eseguito solo ogni ENERGY_MS (30 s). Disaccoppiarli mantiene lo schermo reattivo senza fare il latch del modulo 60 volte al minuto. Modifichi a piacere una delle due costanti.

Cosa vedrà

Sull'OLED, una lettura live che segue il carico — accenda una lampada o un bollitore e guardi i watt salire. Sul monitor seriale (115200 baud), gli stessi valori scorrono per il debug:

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

[screenshot / foto — slot media: l'OLED che mostra una lettura live sul banco]

Quanto è accurato?

Con un TA SCT-013, la classe e la tolleranza propria del TA sono pubblicate per portata nella tabella di precisione SCT-013. La precisione si allarga vicino all'estremo basso della portata. Il modulo misura la potenza attiva reale con compensazione di fase per canale — quindi i carichi reattivi e a basso fattore di potenza si leggono onestamente, non come potenza apparente gonfiata. Per il perché dietro i numeri, veda come funziona davvero la misura di energia con TA.

Lo personalizzi

Alcune piccole aggiunte, una volta che è in funzione:

  • Un contatore di scatto azzerabile — tenga un proprio double kwh_session accanto al totale cumulativo e lo azzeri con un pulsante su un GPIO libero per una lettura "da quando l'ho premuto".

  • Mostri di più — il modulo riporta anche la frequenza; aggiunga un tracker di potenza min/max, o una riga kWh (wh / 1000.0).

  • Un allarme sonoro — far lampeggiare l'OLED o un LED quando la potenza supera una soglia (nessun relè necessario per un avviso solo visivo).

  • Lo invii all'esterno — è su un ESP32, quindi ha il Wi-Fi: pubblichi le letture via MQTT al suo broker, o serva una piccola pagina web — senza rinunciare all'OLED locale.

  • Più lento o più veloce — abbassi LIVE_MS per un grafico più vivace, o alzi ENERGY_MS se un passo di energia da 30 s va bene.

Niente di tutto questo tocca la misura — sono tutte cose da fare con i numeri che readLive() e rollEnergy() già le forniscono.

Cosa segue

Questo singolo modulo su uno schermo è la base. Da qui la serie Arduino si sviluppa:

  • Misuri più circuiti insieme — più moduli rbAmp sullo stesso bus, letti e totalizzati da un unico Arduino.
  • Agisca in base alla lettura — faccia scattare un relè o suonare un cicalino quando un circuito supera un limite di corrente, tutto in locale, senza rete.

  • Registri — scriva l'energia periodica su una scheda SD o trasmetta un CSV a un PC.

(Preferisce in Home Assistant? Lo stesso modulo si inserisce in ESPHome.)


Leggi anche