rbAmp
ES
Tienda

Proyecto · · 9 min de lectura

Monitorización de energía por circuito en Home Assistant: todo el cuadro en un ESP32

Mida todo su cuadro eléctrico (red más cada derivación) desde un ESP32 sobre un único bus I²C de dos hilos. Potencia activa real y energía por circuito en el panel de Energía de Home Assistant, sin nube.

El problema que resuelve

rbAmp escala en sentido contrario. Un módulo BASIC multicanal mide tensión y corriente en cada uno de sus canales y calcula potencia activa real y energía por canal en el propio módulo; y se comunica por I²C, un bus, de modo que un ESP32 lee una pila de ellos sobre los mismos dos hilos de señal. Un ESP32, cifras reales para cada circuito, en su propio Home Assistant. Es la construcción que prometió B1: todo el cuadro, circuito por circuito.

Lo que tendrá

Energía por circuito y el total de red en el panel de Energía de Home Assistant
Un ESP32, un bus: el total de la red más cada derivación, desglosado por circuito: energía real, no una estimación.

Cómo escala: módulos UI en un bus

La arquitectura es el punto clave, así que merece la pena dedicarle treinta segundos al principio:

  • Cada módulo mide tensión y corriente, así que informa de la potencia real. Un módulo de la serie UI muestrea V y sus corrientes a la vez y calcula mean(u·i) por canal en el propio chip: potencia activa real (W) y energía (Wh), con el factor de potencia incluido, sin suposiciones en el host.

  • Hasta 3 circuitos por módulo. UI1 / UI2 / UI3 = una referencia de tensión + 1 / 2 / 3 canales de corriente. Un UI3 mide tres circuitos; dos módulos UI3 miden seis. (Los módulos de 5 y 7 canales están en la hoja de ruta.)

  • Es un bus, no un puerto serie. Todos los módulos comparten el mismo SDA/SCL. Añada circuitos añadiendo módulos: sin nuevo ESP32, sin nuevo UART, sin SoftwareSerial.

  • Sincronizado entre módulos. Ejecute la flota en un grupo y una sola difusión General-Call (GC) de I²C fija cada periodo de cada módulo en el mismo instante, de modo que las energías por circuito cuadran con la alimentación de red principal.

Potencia activa real, medida por circuito, no desagregada

Aquí es donde una construcción de monitorización tiene que ser honesta, así que lo digo claramente. (Por circuito significa una CT en cada ramal, una medida real, y no un sensor único de toda la casa que desagrega el total en conjeturas por aparato como hacen los monitores NILM de un solo punto.)

  • La potencia y la energía son reales, calculadas en el módulo. Como cada canal tiene tensión y corriente, el módulo calcula la potencia activa verdadera (P = mean(u·i), con el factor de potencia y la distorsión de la forma de onda incluidos) y acumula vatios-hora reales por canal. No hay una estimación de «corriente × tensión supuesta» de potencia aparente ni conjeturas de suma de Riemann en Home Assistant: HA recibe Wh por circuito, ya terminados.

  • Lo que Basic no hace: un módulo Basic mide consumo (importación), con un único rango de medida. Si necesita separar la importación de la exportación (vertido solar) o un rango dinámico más amplio, esa es la serie Standard: añade medición bidireccional y precisión multirango sobre la misma potencia real por canal.

  • No es un contador de facturación. Es de grado de monitorización y calibrado, pero no está certificado para facturación.

(¿Quiere control de carga barato y en tiempo realcontrolen lugar de una contabilidad de energía precisa: ¿límites de corriente, alertas de sobrecarga, desconexión? Eso es otro trabajo, para los módulos de solo corriente I: vea control de carga en tiempo real.)

Lista de materiales

Elemento Por qué Dónde
2× rbAmp BASIC SCT-UI3 (V + 3 corrientes cada uno = 6 canales) potencia real + energía en cada circuito BASIC SCT-UI3
6× CT SCT-013 (calibre por circuito: 50 A red/VE, 30 A electrodomésticos, 5 A iluminación) una pinza por conductor medido CT SCT-013
1× placa de desarrollo ESP32 el host único de todo el cuadro —
cableado del bus (SDA/SCL/3V3/GND) un bus I²C para ambos módulos —

Precios: vea cada página de producto. Escale añadiendo módulos UI en el mismo bus, sin ESP extra. (Sin resistencias pull-up externas: los módulos las llevan integradas. Vea abajo el direccionamiento para buses con varios módulos.)

Seguridad ante todo: esto es trabajo con el cuadro bajo tensión

Seguridad

⚠️ Este proyecto coloca varias CT dentro de un mismo cuadro. Cada CT se coloca alrededor de un conductor aislado: nunca corte ni pele un cable vivo. Para trabajar dentro de un cuadro eléctrico, llame a un electricista cualificado. Etiquete cada CT con su interruptor automático.

Asigne una dirección a cada módulo (una sola vez)

Los módulos salen de fábrica con 0x50. Una flota necesita direcciones únicas, así que el segundo módulo recibe 0x51, usando el one-shot new_address: de ESPHome: sin modo de fábrica, sin herramientas adicionales. Hágalo un módulo cada vez, con el otro desconectado, para que no haya colisión de direcciones.

Por módulo adicional:

  1. Conecte solo ese módulo al bus.
  2. Grabe una configuración de prueba con su corriente y dirección de destino:

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

  3. Vigile el registro hasta la línea de éxito del nuevo sondeo, luego elimine new_address: y ponga address: 0x51.

  4. Etiquete el módulo y sus CT con los interruptores automáticos a los que pertenecen. Repita para 0x52… si añade más.
Nota

Pull-ups (buses multimódulo). Los módulos llevan pull-ups I²C integradas: nunca añada externas. Pero en un bus de varios módulos, esas pull-ups integradas quedan en paralelo y se vuelven demasiado fuertes. Mantenga un juego activo (el primer módulo) y desactive las pull-ups de todos los demás módulos (puente / corte de soldadura según la guía de hardware). Para uno o dos módulos puede dejarlas todas como están.

El YAML único

Un solo archivo maneja todo el cuadro: dos módulos UI3 en 0x50/0x51, seis canales, cada uno informando de V/I/P/Wh/PF reales. Ambos módulos están en un mismo grupo de flota para que sus periodos se fijen juntos.

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;

Véalo en Home Assistant

Tras la grabación, el registro de arranque confirma ambos módulos en el mismo bus, fijándose juntos como una flota:

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. Adopte el nodo rbamp-panel-ui (Ajustes → Dispositivos y servicios). Obtendrá seis circuitos, cada uno con corriente real, potencia, energía y factor de potencia.

Entidades de potencia y energía por circuito en Home Assistant

  1. Construya una vista por circuito: una tarjeta de vistazo clasifica sus cargas por potencia real, en vivo.

Una tarjeta de potencia por circuito en el panel

  1. La suma de ramales ≈ acometida. Con todos los módulos en un mismo group_id, una sola difusión los fija en el mismo instante, de modo que la Suma de potencias de ramales sigue a la Potencia de red con un margen de unos pocos por ciento; la diferencia son sus pequeñas cargas no medidas. Como estas son cifras de potencia activa reales, esa conciliación sí se cumple (no se cumpliría con estimaciones de potencia aparente).

Añádalo al panel de Energía [Energy Dashboard]

  • Consumo de red: apúntelo a sensor.mains_energy: el total real y medido.
  • Dispositivos individuales: añada el sensor ..._energy de cada circuito. Son vatios-hora reales por circuito calculados en el módulo: colóquelos directamente en el panel Dispositivos individuales del panel de Energía [Individual devices] para un desglose honesto por circuito, sin artefactos de suma de Riemann.

Lo que viene después

  • Control de carga en tiempo real. ¿Quiere limitar un circuito, avisar de consumo excesivo o desconectar carga antes de que dispare el interruptor principal? Eso es trabajo para los módulos I rápidos y baratos de solo corriente y unas cuantas automatizaciones de HA. (Véase control de carga en tiempo real con rbAmp.)

  • Trifásico honesto. Un único conjunto de muestras sincronizado a través de las tres fases, bajo la versión Standard 3-phase. (Próximamente en esta serie.)

  • Caza de vampiros. Con cada circuito medido, el consumo en reposo se convierte en una lista ordenable. (Próximamente.)

Empiece aquí si aún no tiene un único módulo en marcha: rbAmp en el panel de Energía de Home Assistant. Para el cableado del bus y el detalle del direccionamiento, vea la guía de hardware de ESPHome y la referencia de la API.


Lea a continuación