rbAmp
PT
Loja

Projeto · · 9 min de leitura

Monitorização de energia por circuito no Home Assistant: o quadro inteiro num só ESP32

Meça o quadro elétrico inteiro — rede mais cada derivação — a partir de um ESP32 num único barramento I²C de dois fios. Potência ativa real e energia por circuito no Painel de Energia (Energy Dashboard) do Home Assistant, sem nuvem.

O problema que isto resolve

O rbAmp funciona ao contrário. Um módulo BASIC multicanal mede tensão e corrente em cada um dos seus canais e calcula potência ativa real e energia por canal no próprio módulo — e comunica por I²C, um barramento, por isso um ESP32 lê uma pilha deles pelos mesmos dois fios de sinal. Um ESP32, valores reais para cada circuito, no seu próprio Home Assistant. Esta é a construção B1 prometida — o quadro completo, circuito a circuito.

O que terá

Energia por circuito e o total da rede no Painel de Energia do Home Assistant (Energy Dashboard)
Um ESP32, um barramento: o total da rede mais cada derivação, separados por circuito — energia real, não estimada.

Como escala: módulos UI num só barramento

A arquitetura é o ponto central, por isso vale meio minuto logo no início:

  • Cada módulo mede tensão e corrente — por isso reporta potência real. Um módulo da série UI amostra V e as suas correntes em simultâneo e calcula mean(u·i) por canal no chip: potência ativa real (W) e energia (Wh), incluindo o fator de potência, sem estimativas no anfitrião.

  • Até 3 circuitos por módulo. UI1 / UI2 / UI3 = uma referência de tensão + 1 / 2 / 3 canais de corrente. Um UI3 mede três circuitos; dois UI3 medem seis. (Módulos de 5 e 7 canais estão no roteiro.)

  • É um barramento, não uma porta série. Todos os módulos partilham o mesmo SDA/SCL. Acrescente circuitos acrescentando módulos — sem novo ESP32, sem nova UART, sem SoftwareSerial.

  • Sincronizados entre módulos. Corra a frota num só grupo e um único broadcast General-Call I²C (GC) faz latch de cada período de cada módulo no mesmo instante, para que as energias por circuito concilem com a alimentação da rede.

Potência ativa real, medida por circuito — não desagregada

É aqui que uma construção de monitorização tem de ser honesta, por isso fica dito sem rodeios. (Por circuito significa uma TC em cada derivação — uma medição real — e não um sensor único da casa a desagregar o total em estimativas por aparelho, como fazem os monitores NILM de ponto único.)

  • A potência e a energia são reais, calculadas no módulo. Como cada canal tem tensão e corrente, o módulo calcula a verdadeira potência ativa (P = mean(u·i), incluindo fator de potência e distorção da forma de onda) e acumula watt-hora reais por canal. Não há estimativa "corrente × tensão assumida" de potência aparente nem adivinhação de soma de Riemann no Home Assistant — o HA recebe Wh por circuito já finalizados.

  • O que o Basic não faz: um módulo Basic mede o consumo (importação), com uma única gama de medição. Se precisar de separar a importação da exportação (injeção solar) ou uma gama dinâmica mais ampla, essa é a série Standard — acrescenta medição bidirecional e precisão multi-gama sobre a mesma potência real por canal.

  • Não é um contador de faturação. De qualidade de monitorização e calibrado, mas não certificado para faturação.

(Quer controlo de carga barato e em tempo realcontroloem vez de contabilidade de energia precisa — limites de corrente, alertas de sobrecarga, cortes? Isso é outra tarefa para os módulos I apenas de corrente — veja controlo de carga em tempo real.)

Lista de materiais

Item Porquê Onde
2× rbAmp BASIC SCT-UI3 (V + 3 correntes cada = 6 canais) potência real + energia em cada circuito BASIC SCT-UI3
6× TC SCT-013 (calibre por circuito: 50 A rede/VE, 30 A aparelhos, 5 A iluminação) uma pinça por condutor medido TC SCT-013
1× placa de desenvolvimento ESP32 o anfitrião único para o quadro inteiro —
ligação do barramento (SDA/SCL/3V3/GND) um barramento I²C para os dois módulos —

Preços: veja cada página de produto. Escale acrescentando módulos UI no mesmo barramento — sem ESP extra. (Sem resistências pull-up externas — os módulos já as têm integradas. Veja abaixo a secção de endereçamento para barramentos com vários módulos.)

Segurança em primeiro lugar — isto é trabalho com o quadro sob tensão

Segurança

⚠️ Este projeto põe várias TC dentro de um quadro elétrico. Cada TC envolve à volta um condutor isolado — nunca o corte nem descasque. Para trabalhos dentro de um quadro elétrico, chame um eletricista qualificado. Identifique cada TC com o respetivo disjuntor.

Dê endereço a cada módulo (uma vez)

Os módulos saem de fábrica com 0x50. Uma frota precisa de endereços únicos, por isso o segundo módulo recebe 0x51, usando a opção pontual new_address: do ESPHome — sem modo de fábrica, sem ferramentas extra. Faça-o um módulo de cada vez, com o outro desligado, para não haver colisão de endereços.

Por módulo adicional:

  1. Ligue apenas esse módulo ao barramento.
  2. Carregue uma configuração de teste com a sua corrente e endereço de destino:

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

  3. Veja o log à procura da linha de sucesso da nova sondagem e depois remova new_address: e defina address: 0x51.

  4. Identifique o módulo e as suas pinças TC nos respetivos disjuntores. Repita para 0x52… se acrescentar mais.
Nota

Pull-ups (barramentos multimódulo). Os módulos trazem pull-ups I²C integradas — nunca acrescente externas. Mas num barramento de vários módulos essas pull-ups integradas ficam em paralelo e tornam-se demasiado fortes. Mantenha um conjunto ativo (o primeiro módulo) e desative as pull-ups em todos os outros módulos (jumper / corte de solda segundo o guia de hardware). Com um ou dois módulos pode deixá-las todas como estão.

O YAML único

Um ficheiro comanda o quadro inteiro: dois módulos UI3 em 0x50/0x51, seis canais, cada um a reportar V/I/P/Wh/PF reais. Ambos os módulos correm num só grupo de frota para que os seus períodos façam latch em conjunto.

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;

Veja-o no Home Assistant

Após a carga do firmware, o log de arranque confirma os dois módulos no mesmo barramento, a fazer latch em conjunto como frota:

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. Adicione o nó rbamp-panel-ui (Definições → Dispositivos e serviços). Obtém seis circuitos, cada um com corrente real, potência, energia e fator de potência.

Entidades de potência e energia por circuito no Home Assistant

  1. Construa uma vista por circuito — um cartão de relance ordena as suas cargas pela potência real, ao vivo.

Um cartão de potência por circuito no painel

  1. Soma das derivações ≈ alimentação. Com todos os módulos num mesmo group_id, um único broadcast faz latch deles no mesmo instante, por isso a Soma de Potências das Derivações acompanha a Potência do Quadro com alguns por cento de diferença — o desvio são as suas pequenas cargas não medidas. Como estes são valores de potência ativa reais, essa reconciliação de facto se verifica (não se verificaria com estimativas de potência aparente).

Adicione-o ao Painel de Energia (Energy Dashboard)

  • Consumo da rede: aponte para sensor.mains_energy — o total real, medido.
  • Dispositivos individuais: acrescente o sensor ..._energy de cada circuito. São watt-hora reais por circuito calculados no módulo — coloque-os diretamente no painel Dispositivos individuais do Painel de Energia para uma divisão por circuito honesta, sem artefactos de soma de Riemann.

O que vem a seguir

  • Controlo de carga em tempo real. Quer limitar um circuito, alertar para consumo excessivo ou cortar carga antes de o disjuntor geral disparar? Essa é uma tarefa para os módulos I rápidos e baratos de só corrente e algumas automações do HA. (Veja controlo de carga em tempo real com rbAmp.)

  • Trifásico honesto. Um conjunto de amostras sincronizado em todas as três fases, ao abrigo da versão Standard de 3 fases. (Em breve nesta série.)

  • Caçar os vampiros. Com cada circuito medido, o consumo em stand-by torna-se uma lista ordenável. (Em breve.)

Comece aqui se ainda não tiver um único módulo a funcionar: rbAmp no Painel de Energia do Home Assistant. Para o detalhe da ligação do barramento e endereçamento, veja o guia de hardware ESPHome e a referência da API.


Leia a seguir