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) |
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:
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:
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:
/**
* 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
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
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
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
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:
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_sessionaccanto 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_MSper un grafico più vivace, o alziENERGY_MSse 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.)