rbAmp
FR
Boutique

Projet · · lecture de 9 min

Surveillance d'énergie par circuit dans Home Assistant : tout le tableau sur un seul ESP32

Mesurez tout votre tableau électrique — réseau général plus chaque départ — depuis un seul ESP32 sur un bus I²C à deux fils. Puissance active réelle et énergie par circuit dans le tableau de bord Énergie de Home Assistant, sans cloud.

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

Énergie par circuit et total du réseau dans le tableau de bord Énergie de Home Assistant
Un seul ESP32, un seul bus : le total du réseau général plus chaque départ, détaillé par circuit — énergie réelle, pas une estimation.

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

Sécurité

⚠️ 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 :

  1. Branchez uniquement ce module sur le bus.
  2. Flashez une configuration de test avec son adresse actuelle et cible :

    YAML
    rbamp:
      id: meter
      address: 0x50          # current
      new_address: 0x51      # target — DELETE this line after it succeeds
    

  3. Surveillez le journal pour la ligne de réussite de la nouvelle sonde, puis supprimez new_address: et réglez address: 0x51.

  4. Étiquetez le module et ses TC par rapport à leurs disjoncteurs. Répétez pour 0x52… si vous en ajoutez.
Remarque

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.

YAML
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 :

Text
[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
  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.

Entités de puissance et d'énergie par circuit dans Home Assistant

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

Une carte de tableau de bord de puissance par circuit

  1. 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 ..._energy de 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.


À lire ensuite