Le problème que cela résout
rbAmp fonctionne dans l'autre sens. Un module BASIC multicanal mesure la tension et le courant sur chacun de ses canaux et calcule la puissance active réelle et l'énergie par canal directement sur le module — et il communique en I²C, un bus, donc un seul ESP32 lit une pile de modules sur les deux mêmes fils de signal. Un seul ESP32, des chiffres réels pour chaque circuit, dans votre propre Home Assistant. C'est le montage promis dans B1 : le tableau complet, circuit par circuit.
Ce que vous aurez

Comment ça évolue : modules UI sur un même bus
L'architecture est le cœur du sujet, il vaut donc la peine de trente secondes d'attention :
-
Chaque module mesure la tension et le courant — il donne donc la puissance réelle. Un module de la série UI échantillonne V et ses courants ensemble et calcule
mean(u·i)par canal directement sur puce : puissance active réelle (W) et énergie (Wh), facteur de puissance inclus, sans estimation côté hôte. -
Jusqu'à 3 circuits par module. UI1 / UI2 / UI3 = une référence de tension + 1 / 2 / 3 voies de courant. Un UI3 mesure trois circuits ; deux modules UI3 en mesurent six. (Les modules à 5 et 7 canaux sont sur la feuille de route.)
-
C'est un bus, pas un port série. Chaque module partage les mêmes SDA/SCL. Ajoutez des circuits en ajoutant des modules — pas de nouvel ESP32, pas de nouvel UART, pas de
SoftwareSerial. -
Synchronisé entre modules. Faites tourner le parc dans un groupe et une seule diffusion I²C General-Call (GC) verrouille la période de chaque module au même instant, de sorte que les énergies par circuit se réconcilient avec l'alimentation du réseau.
Puissance active réelle, mesurée par circuit — pas désagrégée
C'est là qu'un montage de surveillance doit être honnête, donc soyons clairs. (Par circuit signifie un TC sur chaque départ — une mesure réelle — et non un capteur unique pour tout le logement qui désagrège le total en estimations par appareil, comme le font les moniteurs NILM à point unique.)
-
La puissance et l'énergie sont réelles, calculées sur le module. Comme chaque canal dispose à la fois de la tension et du courant, le module calcule la vraie puissance active (
P = mean(u·i), facteur de puissance et distorsion de forme d'onde inclus) et accumule des wattheures réels par canal. Il n'y a ni estimation « courant × tension supposée » de puissance apparente, ni approximation par somme de Riemann dans Home Assistant — HA reçoit des Wh finis, par circuit. -
Ce que Basic ne fait pas : un module Basic mesure la consommation (import), dans une seule plage de mesure. Si vous devez séparer l'import de l'export (injection solaire) ou disposer d'une plage dynamique plus large, c'est la série Standard : elle ajoute la mesure bidirectionnelle et la précision multi-plages par-dessus la même puissance réelle par canal.
-
Ce n'est pas un compteur de facturation. Mesure de qualité surveillance et étalonnée, mais non certifiée pour la facturation.
(Vous voulez une charge peu coûteuse et en temps réelcommandeau lieu d'une comptabilité énergétique précise — limites de courant, alertes de surcharge, délestage ? C'est une tâche différente pour les modules I à courant seul — voir le contrôle de charge en temps réel.)
Nomenclature
| Élément | Pourquoi | Où |
|---|---|---|
| 2× rbAmp BASIC SCT-UI3 (V + 3 courants chacun = 6 canaux) | puissance réelle + énergie sur chaque circuit | BASIC SCT-UI3 |
| 6× TC SCT-013 (calibre par circuit : 50 A pour secteur/VE, 30 A pour les appareils, 5 A pour l'éclairage) | une pince par conducteur mesuré | TC SCT-013 |
| 1× carte de développement ESP32 | l'hôte unique pour tout le tableau | — |
| câblage du bus (SDA/SCL/3V3/GND) | un bus I²C vers les deux modules | — |
Tarifs : voir la page de chaque produit. Montez en charge en ajoutant des modules UI sur le même bus — pas d'ESP supplémentaire. (Pas de résistances de tirage externes — les modules les ont à bord. Voir ci-dessous l'adressage pour les bus multimodules.)
La sécurité d'abord — il s'agit de travaux sur un tableau sous tension
⚠️ Ce projet place plusieurs TC à l'intérieur d'un même tableau. Chaque TC se place autour d'un conducteur isolé — vous ne coupez ni ne dénudez jamais un fil sous tension. Pour toute intervention dans un tableau électrique, faites appel à un électricien qualifié. Étiquetez chaque TC par rapport à son disjoncteur.
Adressez chaque module (une seule fois)
Les modules sortent d'usine à 0x50. Un parc a besoin d'adresses uniques, donc le deuxième module reçoit 0x51, via la commande ponctuelle new_address: d'ESPHome — pas de mode usine, pas d'outil supplémentaire. Faites-le un module à la fois, l'autre débranché pour éviter tout conflit d'adresse.
Par module supplémentaire :
- Branchez uniquement ce module sur le bus.
-
Flashez une configuration de test avec son adresse actuelle et cible :
YAMLrbamp: id: meter address: 0x50 # current new_address: 0x51 # target — DELETE this line after it succeeds -
Surveillez le journal pour la ligne de réussite de la nouvelle sonde, puis supprimez
new_address:et réglezaddress: 0x51. - Étiquetez le module et ses TC par rapport à leurs disjoncteurs. Répétez pour
0x52… si vous en ajoutez.
Tirages (bus multimodules). Les modules embarquent des tirages I²C à bord — vous n'en ajoutez jamais en externe. Mais sur un bus de plusieurs modules, ces tirages intégrés se placent en parallèle et deviennent trop forts. Gardez un seul jeu actif (le premier module) et désactivez les tirages sur tous les autres modules (cavalier / coupure par soudure selon le guide matériel). Pour un ou deux modules, vous pouvez les laisser tous tels quels.
Le YAML unique
Un seul fichier pilote tout le tableau : deux modules UI3 à 0x50/0x51, six canaux, chacun remontant de la vraie V/I/P/Wh/PF. Les deux modules tournent dans un même groupe de parc pour que leurs périodes se verrouillent ensemble.
esphome:
name: rbamp-panel-ui
esp32:
board: esp32dev
framework:
type: arduino
wifi:
ssid: !secret wifi_ssid
password: !secret wifi_password
api:
ota:
- platform: esphome
logger:
i2c:
sda: GPIO21
scl: GPIO22
frequency: 50kHz # ESP-IDF i2c_master driver + the module's I²C recovery window interact at
# 100 kHz → intermittent read NACKs on ESP32. 50 kHz is the robust setting.
# STM32 / RP2040 / Linux-SBC masters run this module at 100 kHz fine.
scan: true
external_components:
- source: github://rb-amp/rbamp-esphome@v1.4.0
components: [rbamp]
# Two UI3 modules, one synchronized fleet.
rbamp:
- id: mod_heavy
address: 0x50
update_interval: 10s
ct_models: [SCT_013_050, SCT_013_030, SCT_013_030] # ch0 mains · ch1 water heater · ch2 AC
fleet_gc_enable: true
group_id: 1
- id: mod_light
address: 0x51
update_interval: 10s
ct_models: [SCT_013_005, SCT_013_030, SCT_013_050] # ch0 lighting · ch1 sockets · ch2 EV
fleet_gc_enable: true
group_id: 1
sensor:
# ── Module A @ 0x50: mains + water heater + AC — one voltage sense, real P/Wh per channel ──
- platform: rbamp
rbamp_id: mod_heavy
voltage: { name: "Mains Voltage" }
frequency: { name: "Mains Frequency" }
current: { name: "Mains Current" }
power: { name: "Mains Power" }
energy: { name: "Mains Energy" } # → Energy Dashboard "Grid consumption"
power_factor: { name: "Mains Power Factor" }
current_1: { name: "Water Heater Current" }
power_1: { name: "Water Heater Power", id: p_heater }
energy_1: { name: "Water Heater Energy" } # → Energy Dashboard "Individual device"
power_factor_1: { name: "Water Heater Power Factor" }
current_2: { name: "AC Current" }
power_2: { name: "AC Power", id: p_ac }
energy_2: { name: "AC Energy" }
power_factor_2: { name: "AC Power Factor" }
# ── Module B @ 0x51: lighting + sockets + EV (voltage marked internal — same mains rail) ──
- platform: rbamp
rbamp_id: mod_light
voltage: { name: "Mains Voltage (mod B ref)", internal: true }
current: { name: "Lighting Current" }
power: { name: "Lighting Power", id: p_lighting }
energy: { name: "Lighting Energy" }
power_factor: { name: "Lighting Power Factor" }
current_1: { name: "Sockets Current" }
power_1: { name: "Sockets Power", id: p_sockets }
energy_1: { name: "Sockets Energy" }
power_factor_1: { name: "Sockets Power Factor" }
current_2: { name: "EV Current" }
power_2: { name: "EV Power", id: p_ev }
energy_2: { name: "EV Energy" }
power_factor_2: { name: "EV Power Factor" }
# ── Sum of branches vs mains — should track within a few % on a fully-metered panel ──
- platform: template
name: "Branches Power Sum"
device_class: power
state_class: measurement
unit_of_measurement: W
update_interval: 10s
lambda: |-
float s = 0;
if (id(p_heater).has_state()) s += id(p_heater).state;
if (id(p_ac).has_state()) s += id(p_ac).state;
if (id(p_lighting).has_state()) s += id(p_lighting).state;
if (id(p_sockets).has_state()) s += id(p_sockets).state;
if (id(p_ev).has_state()) s += id(p_ev).state;
return s;
Voyez-le dans Home Assistant
Après le flash, le journal de démarrage confirme que les deux modules sont sur le même bus et se verrouillent ensemble comme un parc :
[i2c ] Found i2c device at address 0x50
[i2c ] Found i2c device at address 0x51
[rbamp] mod_heavy: variant=UI3, fleet_gc=on, group=1
[rbamp] mod_light: variant=UI3, fleet_gc=on, group=1
[rbamp] GC latch enabled fleet-wide: 2 modules (6 channels) in group 1
- Adoptez le nœud rbamp-panel-ui (Paramètres → Appareils et services). Vous obtenez six circuits, chacun avec le courant réel, la puissance, l'énergie et le facteur de puissance.

- Construisez une vue par circuit — une carte d'un coup d'œil classe vos charges par puissance réelle, en direct.

- La somme des départs ≈ l'arrivée. Avec chaque module dans un même
group_id, une seule diffusion les verrouille au même instant, de sorte que la Somme des puissances des départs suit la Puissance du réseau à quelques pour cent près — l'écart correspond à vos petites charges non mesurées. Comme il s'agit de puissances actives réelles, cette réconciliation tient vraiment (elle ne tiendrait pas avec des estimations de puissance apparente).
Ajoutez-le au tableau de bord Énergie [Energy Dashboard]
- Consommation du réseau : pointez-le sur
sensor.mains_energy— le total réel mesuré. - Appareils individuels : ajoutez le capteur
..._energyde chaque circuit. Ce sont de vrais wattheures par circuit calculés sur le module — intégrez-les directement dans le panneau Appareils individuels du tableau de bord Énergie pour une ventilation honnête par circuit, sans artefacts de somme de Riemann.
Suite
-
Contrôle de charge en temps réel. Vous voulez plafonner un circuit, alerter sur une consommation excessive ou délester avant que le disjoncteur général ne saute ? C'est le rôle des modules I à courant seul, rapides et peu coûteux, complétés par quelques automatisations HA. (Voir le contrôle de charge en temps réel avec rbAmp.)
-
Triphasé honnête. Un jeu d'échantillons synchronisé sur les trois phases, sous la version Standard 3 phases. (À venir dans cette série.)
-
Traquez les consommations fantômes. Une fois chaque circuit mesuré, le plancher de veille devient une liste triable. (À venir.)
Commencez ici si vous n'avez pas encore un seul module en marche : rbAmp dans le tableau de bord Énergie de Home Assistant. Pour le détail du câblage du bus et de l'adressage, voir le guide matériel ESPHome et la référence de l'API.