Ce que vous allez construire
- Par circuit : tension / courant / puissance active réelle de chaque module.
-
Une puissance active totale cohérente — la somme des modules, tous verrouillés au même instant (et non trois lectures échantillonnées indépendamment qui ne se réconcilient pas — voir pourquoi c'est important).
-
Tout sur un seul bus I²C, un seul Arduino — on ajoute des circuits en ajoutant des modules, sans nouveau microcontrôleur.
Nomenclature
| Élément | Qté | Remarques |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 3 | une par circuit · produit |
| TC SCT-013 | 3 | un par module, calibre par circuit · produit |
| Carte de développement ESP32 (framework Arduino) | 1 | la cible vérifiée à la compilation |
| Fils de liaison | — | le bus I²C partagé |
Câblez le bus partagé
Tous les modules sont sur les mêmes SDA / SCL / alimentation / masse — ils ne diffèrent que par leur adresse :
Arduino module A (0x50) module B (0x51) module C (0x52)
------- --------------- --------------- ---------------
SDA ────────┬────── SDA ────┬────── SDA ────┬────── SDA
SCL ────────┼────── SCL ────┼────── SCL ────┼────── SCL
5V ────────┼────── VCC ├────── VCC ├────── VCC
GND ────────┴────── GND ────┴────── GND ────┴────── GND
│ │ │
CT on circuit A CT on circuit B CT on circuit C
-
Tirages : chaque module embarque des tirages intégrés. Avec deux ou trois modules sur un bus de jusqu'à 15 cm, laissez-les actifs sur chaque module — rien à couper. À partir de quatre modules, ou sur un bus plus long, suivez la documentation matérielle du module.
-
Les TC se placent autour de leurs conducteurs — le côté courant est non invasif. Alimentez chaque module à sa tension nominale. Pour toute intervention dans un tableau électrique, faites appel à un électricien qualifié.
Donnez une adresse à chaque module
Les modules sortent d'usine à 0x50 ; avant qu'ils puissent partager un bus, vous attribuez donc à la deuxième et à la troisième une adresse unique (0x51, 0x52). Sur le micrologiciel actuel, c'est une opération de production ordinaire — ni mode spécial ni outillage — vous préparez la nouvelle adresse, l'armez et la validez ; le module redémarre à sa nouvelle adresse. Faites-le un module à la fois, les autres débranchés, pour éviter tout conflit d'adresse — l'assistant RbAmpFleet::provision() (ou prepareAddressChange() / commitAddressChange() pour un seul module) exécute cette validation en deux phases. Pas de cavalier, pas de bouton, pas de mode spécial — juste un module seul sur le bus pendant que vous l'attribuez.
Synchronisez, puis lisez
Voici la partie qui rend le total fiable. Au lieu de lire trois modules l'un après l'autre (chacun pris à un instant légèrement différent), vous envoyez une diffusion « verrouiller maintenant » à tout le bus — chaque module fige sa fenêtre de mesure au même instant. Vous lisez ensuite l'instantané figé de chaque module, tour à tour. Les lectures sont séquentielles, mais les valeurs appartiennent toutes au même moment, donc les additionner est honnête. C'est le même principe de cohérence que le montage triphasé, ici en C++ Arduino.
Le croquis
Trois modules UI1 à 0x50 / 0x51 / 0x52, un ESP32 (framework Arduino) à 50 kHz. L'assistant RbAmpFleet balaie le bus, inscrit chaque module au verrouillage de diffusion une seule fois, puis chaque fenêtre d'énergie déclenche un verrouillage General-Call et lit l'instantané figé de chaque module :
/**
* MultiModuleBus.ino — three rbAmp modules on one I2C bus: per-module power +
* a coherent fleet total, synchronised by the v1.3 General-Call latch.
*
* Three UI1 modules, each metering one independent mains circuit, share a single
* two-wire bus behind one ESP32 at 0x50 / 0x51 / 0x52. Every energy window the
* host fires ONE General-Call broadcast latch, so all three latch their period on
* the same instant (coherent energy). Live V/I/P is read sequentially; the
* broadcast is only for period/energy coherence. Requires v1.3+ firmware.
*
* Board: ESP32 (Arduino framework) -- esp32:esp32:esp32
* Bus: I2C @ 50 kHz (Wire.setClock(50000)) on ESP32-Arduino; non-ESP32 = 100 kHz.
*
* Wiring: SDA->GPIO21, SCL->GPIO22 (all modules); rbAmp VCC->5 V; common GND;
* ~4.7 kOhm pull-ups on SDA/SCL to 3.3 V (host logic level).
*
* ADDRESSING (do this ONCE, before running this sketch): a factory module answers
* at 0x50. Bring modules up ONE AT A TIME and give each a unique address with the
* production-OK two-phase commit (RbAmpFleet::provision(), or a single module's
* prepareAddressChange()/commitAddressChange() — see example 05_AddressChange).
* Assign 0x51 and 0x52; leave the first at 0x50. No jumper, no button, no special
* mode — just one module on the bus at a time while you assign it.
*
* Accuracy: per clamp rating — the class and the sensor's own tolerance are both in the accuracy table on the BASIC page.
*/
#include
#include
/* ---- configuration -------------------------------------------------------- */
static const uint8_t SDA_PIN = 21;
static const uint8_t SCL_PIN = 22;
static const uint32_t I2C_HZ = 50000; /* ESP32-Arduino: 50 kHz */
static const uint8_t GC_GROUP = 0x00; /* 0x00 = all-call (latch every module) */
static const uint32_t LIVE_MS = 1000; /* per-module V/I/P refresh */
static const uint32_t WINDOW_MS = 30000; /* coherent energy window (GC latch) */
/* ---- state ---------------------------------------------------------------- */
static RbAmpFleet fleet(Wire);
static size_t g_count = 0;
static uint16_t g_tick = 0;
static uint32_t next_live_ms = 0;
static uint32_t next_window_ms = 0;
/* ---- live per-module V/I/P + running total active power ------------------- */
static void showLive() {
Serial.println(F("-- live --"));
float p_total = 0.0f;
for (size_t i = 0; i < g_count; ++i) {
RbAmp* dev = fleet.get(i);
if (!dev) continue;
float v = dev->readVoltage();
float a = dev->readCurrent(0);
float p = dev->readPower(0);
if (!isnan(p)) p_total += p;
Serial.print(F(" 0x"));
Serial.print(dev->address(), HEX);
Serial.print(F(" "));
Serial.print(isnan(v) ? 0.0f : v, 1); Serial.print(F(" V "));
Serial.print(isnan(a) ? 0.0f : a, 3); Serial.print(F(" A "));
Serial.print(isnan(p) ? 0.0f : p, 1); Serial.println(F(" W"));
}
Serial.print(F(" TOTAL active power = "));
Serial.print(p_total, 1);
Serial.println(F(" W"));
}
/* ---- coherent energy window: one GC latch -> read each -> aggregate ------- */
static void rollEnergyWindow() {
g_tick++;
/* One broadcast latches every GC-enabled module on the same instant. */
fleet.gcLatch(GC_GROUP, g_tick, /*settle_ms=*/50);
/* Verify each module accepted this tick (fleet sync / missed-frame skew). */
RbAmpFleetSync sync[RBAMP_FLEET_MAX_MODULES];
size_t missed = 0;
fleet.checkSync(g_tick, sync, RBAMP_FLEET_MAX_MODULES, missed);
Serial.print(F("== window tick "));
Serial.print(g_tick);
Serial.print(F(": "));
Serial.print(g_count - missed);
Serial.print(F("/"));
Serial.print(g_count);
Serial.println(F(" in sync =="));
/* Read the already-latched period on each module (skip_latch=true), which
* rolls that module's host-integrated Wh accumulator. */
for (size_t i = 0; i < g_count; ++i) {
RbAmp* dev = fleet.get(i);
if (!dev) continue;
RbAmpPeriodSnapshot snap;
bool ok = dev->readPeriodSnapshot(snap, /*settle_ms=*/0, /*skip_latch=*/true);
Serial.print(F(" 0x"));
Serial.print(dev->address(), HEX);
if (!sync[i].in_sync) {
Serial.print(F(" [missed tick, gc_tick="));
Serial.print(sync[i].gc_tick);
Serial.print(sync[i].reachable ? F("]") : F(", unreachable]"));
}
if (!ok) {
Serial.print(F(" period skipped: "));
Serial.println(RbAmp::errorString(dev->lastError()));
continue;
}
Serial.print(F(" avg_P="));
Serial.print(snap.avg_p[0], 1);
Serial.print(F(" W Wh="));
Serial.println(dev->energy().wh(0), 3);
}
float p_total = 0.0f;
double wh_total = 0.0;
fleet.totalPower(p_total);
fleet.totalEnergyWh(wh_total);
Serial.print(F(" FLEET total P="));
Serial.print(p_total, 1);
Serial.print(F(" W total Wh="));
Serial.println(wh_total, 3);
}
/* ---- lifecycle ------------------------------------------------------------ */
void setup() {
Serial.begin(115200);
while (!Serial && millis() < 2000) {}
Wire.begin(SDA_PIN, SCL_PIN);
Wire.setClock(I2C_HZ);
/* Discover every rbAmp on the bus (PRODUCT_ID confirmed). */
size_t added = 0;
if (!fleet.scan(/*match_product=*/true, added)) {
Serial.println(F("scan failed - bus may be compromised (stuck SDA?)"));
return;
}
g_count = fleet.count();
Serial.print(F("fleet: "));
Serial.print(g_count);
Serial.println(F(" module(s)"));
if (g_count == 0) {
Serial.println(F("no modules - check wiring + that each has a unique address"));
return;
}
/* Opt the whole fleet into GC latch (persisted + reset; one-time, ~1 s each). */
size_t gc_ok = 0;
fleet.enableGcAll(GC_GROUP, gc_ok);
Serial.print(F("GC latch enabled on "));
Serial.print(gc_ok);
Serial.print(F("/"));
Serial.print(g_count);
Serial.println(F(" module(s)"));
uint32_t now = millis();
next_live_ms = now;
next_window_ms = now + WINDOW_MS;
}
void loop() {
if (g_count == 0) { delay(1000); return; }
uint32_t now = millis();
if (static_cast(now - next_live_ms) >= 0) {
next_live_ms = now + LIVE_MS;
showLive();
}
if (static_cast(now - next_window_ms) >= 0) {
next_window_ms = now + WINDOW_MS;
rollEnergyWindow();
}
delay(5);
}
(Compilation vérifiée sur ESP32 avec Arduino-CLI — RbAmpFleet + Wire, sans bibliothèque supplémentaire. enableGcAll() est une activation unique ; gcLatch() diffuse, checkSync() signale tout module ayant manqué le top, et totalEnergyWh() donne l'énergie totale cumulée du parc.)
Ce que fait le croquis
L'assistant RbAmpFleet s'occupe de la comptabilité du parc — découverte des modules, inscription au verrouillage de diffusion et totalisation. Deux fonctions tournent dans la boucle : showLive() (affichage par seconde) et rollEnergyWindow() (par fenêtre d'énergie).
Configuration — balayer le bus, activer le verrouillage du parc
RbAmpFleet fleet(Wire);
fleet.scan(/*match_product=*/true, added); // find every rbAmp on the bus
fleet.enableGcAll(GC_GROUP, gc_ok); // opt them all into the broadcast latch (one-time)
scan() parcourt le bus et enregistre chaque rbAmp trouvé (en confirmant chacun par son identifiant produit) ; fleet.count() indique combien ont répondu, pour qu'un module manquant ou mal adressé soit évident au démarrage. enableGcAll() active une fois l'indicateur de verrouillage General-Call sur chaque module — après quoi une seule diffusion peut verrouiller tout le groupe.
showLive() — lectures par module + total courant
for (size_t i = 0; i < g_count; ++i) {
RbAmp* dev = fleet.get(i);
float p = dev->readPower(0);
if (!isnan(p)) p_total += p; // ... print V / A / W for this module
}
Parcourt le parc et lit tour à tour la tension, le courant et la puissance en direct de chaque module. Ces lectures en direct n'ont pas besoin d'être synchronisées — elles servent à l'affichage — et il additionne la puissance par module dans p_total pour un chiffre en direct de tout le tableau.
rollEnergyWindow() — la partie cohérente
fleet.gcLatch(GC_GROUP, ++g_tick, /*settle=*/50); // ONE broadcast latches all modules together
fleet.checkSync(g_tick, sync, RBAMP_FLEET_MAX_MODULES, missed); // did each accept the tick?
// per module: dev->readPeriodSnapshot(snap, 0, /*skip_latch=*/true); // read the frozen window
fleet.totalPower(p_total); fleet.totalEnergyWh(wh_total);
C'est pourquoi le total est fiable. gcLatch() envoie une trame General-Call à l'adresse 0x00 — chaque module activé fige sa fenêtre de mesure sur ce même instant (écart inférieur à 10 µs à travers le parc). checkSync() vérifie que chaque module a bien accepté le top et nomme ceux qui l'ont manqué (une ligne pratique de santé du parc). Puis les lectures : readPeriodSnapshot(..., skip_latch=true) lit la fenêtre déjà figée de chaque module sans reverrouiller, ce qui fait avancer le total de wattheures de ce module. totalPower() / totalEnergyWh() additionnent le parc. Comme chaque module a été verrouillé ensemble, Σ Pi et les Wh additionnés sont cohérents — pas trois lectures prises à trois moments différents.
La loop() à deux cadences
Même principe que le moniteur à module unique : showLive() sur une minuterie de 1 s, rollEnergyWindow() sur la minuterie de fenêtre d'énergie — l'affichage reste réactif tandis que le verrouillage cohérent tourne à sa propre cadence, plus lente.
Adaptez-le à votre installation
-
Davantage de circuits —
scan()gère autant de modules qu'il y en a sur le bus ; donnez à chacun une adresse unique (voir plus haut) et ils rejoignent le parc automatiquement. Surveillez les règles de charge du bus et de tirage à mesure que le nombre augmente. -
Parcs indépendants — donnez aux groupes sans rapport des
group_iddifférents et verrouillez chacun à sa propre cadence, le tout sur un seul bus. -
Ajoutez un écran — ajoutez l'OLED du montage de surveillance, ou publiez simplement
p_totalet les Wh du parc. -
Actions par circuit — déclenchez un relais par module au-delà de sa propre limite (à combiner avec le montage à relais).
- Journalisez le tableau — une ligne par module et par intervalle sur une carte SD (le montage d'enregistrement).
Pour aller plus loin
- Agissez — déclenchez un relais ou alertez lorsqu'un circuit franchit une limite de courant, localement, sans réseau.
- Journalisez-le — énergie périodique par circuit sur une carte SD ou en CSV via le série.
- Vous voulez plutôt l'intégrer à Home Assistant ? Le même bus multimodule est le tableau complet sur un seul ESP32 avec ESPHome.