Ce que vous allez construire
- Tension, courant, puissance active et facteur de puissance en direct sur un OLED 128×64, rafraîchi environ une fois par seconde.
- Énergie (Wh) cumulée sur le même écran — wattheures réels, intégrés sur l'hôte en temps mural.
- Tout passe par un seul bus I²C partagé par le module rbAmp et l'écran — quatre fils de signal au total.
- Ni Wi-Fi, ni cloud, ni HA. Miroir série pour le débogage ; l'OLED est toute l'interface.
Nomenclature
| Élément | Qté | Remarques |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 1 | tension + courant + puissance réelle sur puce · produit |
| Transformateur de courant SCT-013 | 1 | calibre adapté à votre circuit · produit |
| Carte de développement ESP32 (framework Arduino) | 1 | la cible vérifiée à la compilation — un ESP32 donne une énergie longue durée fiable (doubles 64 bits réels) et la marge de RAM nécessaire à l'écran |
| OLED I²C SSD1306 128×64 | 1 | l'écran (adresse I²C 0x3C, partage le bus) |
| Fils de liaison | — | le bus I²C partagé (SDA / SCL / VCC / GND) |
Toute carte compatible Arduino convient. Le croquis est du C++ Arduino ordinaire — il tourne sur un Uno, un Nano, un STM32, un RP2040 ou un ESP32. Nous utilisons ici un ESP32 parce qu'il est bon marché, partout disponible, et qu'il offre la marge pour des totaux d'énergie longue durée fiables. Le seul paramètre qui change d'une carte à l'autre est la vitesse du bus I²C : un ESP32 attend Wire.setClock(50000) (50 kHz, réglage de son pilote), tandis que la plupart des cartes non ESP32 font fonctionner le module à 100 kHz.
Câblage
Le module rbAmp et l'écran OLED sont tous deux sur le même bus I²C à deux fils — ils ont simplement des adresses différentes (0x50 pour rbAmp, 0x3C pour l'OLED), ils coexistent donc sans conflit :
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)
-
Le bus fonctionne en logique 3.3 V (les lignes I²C du module tolèrent le 5 V mais sont au repos à la tension 3.3 V de l'hôte). Le module rbAmp embarque des tirages de 4.7 kΩ intégrés vers 3.3 V, qui suffisent pour ce bus à un module plus l'OLED — vous n'activez pas les tirages internes faibles de l'ESP32. Notez les niveaux : VCC rbAmp = 5 V, VCC OLED = 3.3 V, masse commune — le bus I²C lui-même est en logique 3.3 V. (Pourquoi rbAmp est-il alimenté en 5 V avec un bus 3.3 V ?)
-
Les pinces SCT-013 se placent autour d'un conducteur isolé — vous ne coupez ni ne dénudez jamais le fil sous tension côté courant. Le côté tension alternative du module se branche au secteur. Pour toute intervention dans un tableau électrique, faites appel à un électricien qualifié.
Installer la bibliothèque
IDE Arduino : Croquis → Inclure une bibliothèque → Gérer les bibliothèques…, recherchez RbAmp, installez. Ou avec arduino-cli :
arduino-cli lib install RbAmp
Il vous faut aussi le pilote OLED — installez Adafruit SSD1306 (v2.5.14) depuis le gestionnaire de bibliothèques ; il installe automatiquement Adafruit GFX et Adafruit BusIO.
Le croquis
Copiez ceci, réglez MY_CT pour correspondre à votre pince, et flashez. Il est conçu pour un ESP32 (framework Arduino) à 50 kHz (réglage du pilote I²C ESP-IDF — une carte non ESP32 comme un Uno/Nano utiliserait 100 kHz), avec 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);
}
(Compilation vérifiée sur ESP32 avec Arduino-CLI — Adafruit SSD1306 v2.5.14 + Adafruit GFX. setCTModel() écrit en flash, donc le croquis ne réécrit le préréglage du TC que lorsqu'il change réellement — pas d'usure de la flash à chaque démarrage.)
Ce que fait le croquis
Toute la bibliothèque Arduino rbAmp tient en une poignée d'appels. Deux fonctions font le vrai travail — readLive() chaque seconde et rollEnergy() toutes les 30 secondes — pilotées par une loop() à deux cadences. Voici chaque pièce.
Configuration — lier, sonder, configurer
RbAmp dev(Wire, 0x50, RbAmpTopology::Single); // bus, address, topology
...
while (!dev.begin()) { /* print errorString(), retry */ }
ensureCtModel();
RbAmp dev(Wire, 0x50, RbAmpTopology::Single) lie la bibliothèque au bus I²C et au module à 0x50 ; Single indique qu'il s'agit d'un UI1 monocanal (un UI2/UI3 passerait SplitPhase / ThreePhase). begin() sonde le module et lit ses capacités — bouclez dessus jusqu'à ce qu'il renvoie true, en affichant RbAmp::errorString(dev.lastError()) pour qu'une erreur de câblage soit évidente. ensureCtModel() lit le préréglage de TC stocké dans le module et ne l'écrit que s'il diffère (setCTModel() persiste en flash) — pour ne pas user la flash à chaque démarrage.
readLive() — la lecture une fois par seconde
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
Ces quatre lectures extraient les mesures réelles du module : readPower(0) est la puissance active réelle en watts — la moyenne de la tension × courant instantanés, et non le courant × une tension supposée. Une lecture peut parfois renvoyer NaN (un accroc passager du bus) ; le croquis conserve la dernière bonne valeur (lastV, lastI, …) pour que l'écran ne clignote jamais à zéro, et incrémente un compteur ok=/bad= que vous pouvez suivre à l'écran. Il appelle ensuite drawLive() pour afficher l'OLED.
rollEnergy() — le total d'énergie fiable
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) { /* stale/not-ready: report + skip */ return; }
// dev.energy().wh(0) has now advanced for this window
L'énergie fonctionne différemment des lectures en direct. readPeriodSnapshot() envoie au module un LATCH atomique — « fermer la fenêtre de mesure courante maintenant » — attend le temps de stabilisation, puis relit la puissance moyenne de cette fenêtre. La bibliothèque fait ensuite avancer le total de wattheures côté hôte : energy = average_power × elapsed_wall-clock_time. Comme c'est l'hôte qui gère l'intervalle d'intégration, il n'y a aucun compteur embarqué qui puisse être quantifié ou dériver — dev.energy().wh(0) est un total courant fiable. Si une période revient périmée ou non prête, la fonction le signale et s'arrête ; l'affichage continue avec les dernières valeurs en direct.
La loop() à deux cadences
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
Deux minuteries indépendantes : l'affichage en direct se rafraîchit toutes les LIVE_MS (1 s) pour une lecture réactive, tandis que la mesure d'énergie plus lourde ne tourne que toutes les ENERGY_MS (30 s). Les dissocier garde l'écran réactif sans verrouiller le module 60 fois par minute. Modifiez l'une ou l'autre constante à votre convenance.
Ce que vous verrez
Sur l'OLED, une lecture en direct qui suit la charge — allumez une lampe ou une bouilloire et regardez les watts bondir. Sur le moniteur série (115200 bauds), les mêmes valeurs défilent pour le débogage :
V=230.4 I=0.211 P=48.2 PF=0.97 Wh=12.345
[capture d'écran / photo — emplacement média : l'OLED affichant une lecture en direct sur l'établi]
Quelle est sa précision ?
Avec une pince SCT-013, la classe et la tolérance propre de la pince sont publiées par calibre dans le tableau de précision SCT-013. La précision s'élargit près de la limite basse du calibre. Le module mesure la puissance active réelle avec une compensation de phase par canal — donc les charges réactives et à faible facteur de puissance se lisent honnêtement, et non comme une puissance apparente gonflée. Pour les raisons derrière les chiffres, voir comment fonctionne réellement la mesure d'énergie par TC.
Adaptez-le à votre installation
Quelques petits ajouts, une fois que ça tourne :
-
Un compteur de déclenchement remettable à zéro — conservez votre propre
double kwh_sessionà côté du total à vie, et remettez-le à zéro depuis un bouton-poussoir sur une broche GPIO libre pour une lecture « depuis que je l'ai appuyé ». -
Afficher davantage — le module fournit aussi la fréquence ; ajoutez un suivi de puissance min/max, ou une ligne en kWh (
wh / 1000.0). -
Une alarme douce — faites clignoter l'OLED ou une LED lorsque la puissance franchit un seuil (aucun relais nécessaire pour un simple avertissement à l'écran).
-
Envoyez-le ailleurs — vous êtes sur un ESP32, donc vous avez le Wi-Fi : publiez les lectures via MQTT vers votre propre broker, ou servez une petite page web — sans renoncer à l'OLED local.
-
Plus lent ou plus rapide — baissez
LIVE_MSpour un graphique plus vif, ou montezENERGY_MSsi un pas d'énergie de 30 s vous convient.
Rien de tout cela ne touche à la mesure — ce sont simplement les usages des chiffres que readLive() et rollEnergy() vous fournissent déjà.
Pour aller plus loin
Ce module unique sur un écran est la base. À partir de là, la série Arduino se construit :
- Mesurez plusieurs circuits à la fois — plusieurs modules rbAmp sur le même bus, lus et totalisés par un seul Arduino.
-
Agissez sur la lecture — déclenchez un relais ou faites sonner un buzzer quand un circuit dépasse une limite de courant, tout localement, sans réseau.
-
Enregistrez-le — écrivez l'énergie périodique sur une carte SD ou diffusez un CSV vers un PC.
(Vous préférez l'intégrer à Home Assistant ? Le même module s'intègre à ESPHome.)