rbAmp
PT
Loja
Docs
Atualizado

03 · Consulta em tempo real

Consulta em tempo real — leitura de valores instantâneos de U, I, P, PF, sentido do fluxo e métricas relacionadas em intervalos regulares (tipicamente uma vez por janela de medição, ~100 ms). Usa-se para:

  • Painéis em tempo real (potência e tensão atuais)
  • Alarmes de limiar
  • Deteção de eventos (ligar / desligar de carga)
  • Monitorização da qualidade da rede (frequência, PF)
  • Determinar o sentido da corrente — consumo ou exportação (pelo sinal de P_real)

Para a acumulação tarifária de energia (Wh ao longo de um período) use o mecanismo de instantâneo do período descrito em period-metering.md.

A janela de medição (100 ms)

Temporização da janela de medição e de quando o seu conjunto de resultados é publicado.

O que é

O módulo mede continuamente e publica um conjunto de resultados a cada ~100 ms (imagens de firmware anteriores à v1.2: a cada ~200 ms):

  • RMS de tensão e correntes
  • Valores de pico de U e I
  • Potência ativa P, calculada como mean(u(t) · i(t)) — com sinal, sendo o sinal indicativo do sentido do fluxo:
  • P > 0 — a carga consome da rede (modo normal)
  • P < 0 — a carga exporta para a rede (inversor solar, carga regenerativa)
  • Potência reativa Q, calculada como √(S² − P²) com S = U_rms × I_rms — sem sinal (≥ 0), inclui a potência de distorção; é 0 nas variantes só de corrente e ruidosa perto de FP ≈ 1
  • Fator de potência PF = P / S, com S = U_rms × I_rms. O sinal de PF coincide com o de P — um indicador adicional do sentido do fluxo.

Após calcular uma janela, o firmware publica atomicamente o conjunto completo de resultados (50+ bytes) no bloco de registos I²C 0x86..0xCD.

Comprimento da janela é fixo

A janela está fixa em 100 ms a partir da v1.2, independentemente da frequência da rede. Nas imagens anteriores à v1.2 a janela é de 200 ms.

Com a rede a 50 Hz, uma janela de 100 ms cobre exatamente 5 ciclos; a 60 Hz, 6 ciclos (10 e 12 na janela mais antiga de 200 ms). Em ambos os casos o número inteiro de ciclos da rede mantém o RMS e P exatos.

Nota

O registo V03_PERIOD_MS (0xCA..0xCD, u32 LE) indica a duração do período de instantâneo atual até ao momento (ms desde o último CMD_LATCH_PERIOD — ver capítulo 04). É apenas de diagnóstico; não afeta a exatidão da medição nem o cálculo de energia.

Quando a janela seguinte começar

Imediatamente após a anterior ser publicada. Não há intervalo entre janelas — a medição é contínua.

Como a janela de medição se relaciona com o instantâneo do período.

DATA_READY (DRDY) — o pino de pronto

DRDY é uma saída em dreno aberto puxada para 3.3 V do lado do mestre. O firmware põe-na em LOW durante ~10 µs depois de os registos RT terem sido atualizados — um sinal de hardware que diz "os dados estão prontos para ler".

Parâmetros de pulso

  • Duração LOW: ~10 µs (confortável para qualquer mestre com EXTI)
  • Frequência: ~10 Hz (um pulso por janela de 100 ms; ~5 Hz nas imagens anteriores à v1.2)
  • Tipo de saída: dreno aberto (suporta OR por fio em topologias multimódulo)
  • Semântica: o flanco descendente garante que todos os registos RT estão coerentes e atualizados

Quando o DRDY não é necessário

  • O mestre consulta mais devagar do que a taxa da janela (uma vez por segundo ou por minuto) — os dados são atualizados dez vezes por segundo (v1.2 e posteriores), por isso qualquer leitura apanha dados frescos.
  • Um ciclo de consulta trivial — read_rt() pode ser chamado a qualquer momento; obtém o resultado comprometido mais recente.

Quando o DRDY é útil

  • O mestre quer minimizar o tráfego I²C ou libertar CPU para outras tarefas (sistemas alimentados por bateria)
  • Sincronização precisa: ler o instante exato em que a medição termina (útil para registos de alta resolução)
  • Deteção de eventos: reagir a cada janela (p. ex., seguimento de potência instantânea com granularidade de ~100 ms)

Utilização (Arduino, um módulo)

C++
const uint8_t PIN_DRDY = 15;   // example pin — any input-capable GPIO works
volatile bool data_ready = false;

void on_drdy_falling() {
  data_ready = true;
}

void setup() {
  Serial.begin(115200);
  Wire.begin();
  pinMode(PIN_DRDY, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PIN_DRDY), on_drdy_falling, FALLING);
}

void loop() {
  if (data_ready) {
    data_ready = false;
    float u = rb_read_float_le(0x50, 0x86);
    float i = rb_read_float_le(0x50, 0x8E);
    float p = rb_read_float_le(0x50, 0xA6);
    const char* dir = (p >= 0.0f) ? "consume" : "export";
    Serial.printf("U=%.1f I=%.3f P=%.1f (%s)\n", u, i, p, dir);
  }
}
Nas bibliotecas cliente

— a mesma tarefa sem acesso a registos:

Biblioteca Chamada O que faz
Arduino RbAmp::setDrdyPin(pin) / RbAmp::waitDataReady(timeout_ms, ev) ligue a linha DRDY; aguarde um novo instantâneo
ESP-IDF rbamp_set_drdy_gpio() / rbamp_wait_data_ready() ligue o GPIO DRDY; aguarde um novo instantâneo
Python — não exposto — a biblioteca não usa o pino; trate-o no seu próprio código
ESPHome drdy_pin: entrada DRDY opcional no YAML; o componente apenas a regista

O sinal de P e o sentido do fluxo

Nos registos RT, o sinal da potência ativa é o indicador principal do sentido da corrente:

Condição Significado
P_real > 0 A carga consome (corrente a entrar)
P_real < 0 Carga que exporta para a rede (geração)
P_real ≈ 0 enquanto I_rms > 0 Carga puramente reativa (transformador em vazio, condensador)

Os valores RMS de corrente e tensão são sempre ≥ 0 (o RMS é não negativo por definição). Por isso I_rms não pode ser usado para determinar o sentido do fluxo — use P_real.

Exemplo de classificação de fluxo

C++
void classify_flow(float p) {
  if (p > 10.0f) {
    Serial.println("CONSUMING from grid");
  } else if (p < -10.0f) {
    Serial.println("EXPORTING to grid");
  } else {
    Serial.println("idle / reactive only");
  }
  // ±10 W threshold to avoid chatter near zero
}
Nota

Nos firmwares de nível BASIC o acumulador tarifário ignora a exportação (veja period-metering.md). Os registos RT, no entanto, levam sempre o sinal real de tempo real de P — por isso, mesmo num SKU BASIC, o mestre pode detetar eventos de exportação a partir das leituras RT, registá-los ou construir um acumulador bidirecional do lado do mestre sobre o firmware BASIC.

Referência dos registos RT

Todos os valores são float32 little-endian (4 bytes). A LEITURA suporta incremento automático — leia cada valor como uma rajada de 4 bytes (ou todo o bloco 0x86..0xBD numa só rajada, veja §read-freeze). Os campos inteiros estão marcados com o seu tipo.

Tensão

Endereço Campo Tipo Unidade Descrição
0x86 U_rms float32 V Tensão RMS na última janela de medição
0x8A U_peak float32 V Desvio máximo em relação à média durante a janela

Correntes (por canal: 0 = primário, 1/2 nos UI2/UI3, mais nos UI5/UI7)

Endereço Campo Tipo Unidade
0x8E I0_rms float32 A
0x92 I1_rms float32 A
0x96 I2_rms float32 A
0x9A I0_peak float32 A
0x9E I1_peak float32 A
0xA2 I2_peak float32 A
Nota

Nas variantes com menos canais (p. ex., UI1), os registos de canais não usados devolvem 0.0f em vez de NACK. As variantes com mais canais (UI5/UI7) colocam os seus valores adicionais de I_rms / P_real / PF / Q em registos acima de 0xCF; consulte a folha de dados do SKU para o mapa estendido.

Potência

Endereço Campo Tipo Unidade Sinal Descrição
0xA6 P0_real float32 W ± Potência ativa, canal 0 — P > 0 = consumo, P < 0 = exportação
0xAA P1_real float32 W ± Potência ativa, canal 1 (UI2/UI3)
0xAE P2_real float32 W ± Potência ativa, canal 2 (UI3)
0xB2 PF0 float32 – ± Fator de potência, intervalo −1…+1, sinal igual ao de P0
0xB6 PF1 float32 – ±
0xBA PF2 float32 – ±
0xD0 Q0_reac float32 VAr ≥ 0 Potência reativa ch0 = √(S² − P²) — inclui a potência de distorção; ruidosa perto de FP ≈ 1; 0 nas variantes só de corrente
0xD4 Q1_reac float32 VAr ≥ 0
0xD8 Q2_reac float32 VAr ≥ 0
Nota

A potência aparente S pode ser derivada no mestre: S = U_rms × I_rms. Os valores RMS são sempre ≥ 0; o sentido do fluxo está no sinal de P.

Ressalva de atomicidade para Q: o bloco RT 0x86..0xBD (U/I/P/PF) é entregue sob read-freeze e está garantido sem rasgos numa única leitura em rajada. Os registos Q (0xD0..0xDB) estão fora dessa janela de congelamento — se ler U/I/P + Q em duas transações separadas, U/I/P virão de um instantâneo coerente, mas Q pode pertencer à confirmação RT seguinte. Para coerência entre grandezas com granularidade inferior ao período, ou lê Q sob um instantâneo CMD_LATCH_PERIOD (0xC2..0xC9 para a Q média de ch1/ch2 não é exposta — use o bloco de instantâneo do capítulo 11 §4.12), ou aceite o desfasamento de até uma janela (~100 ms) entre P e Q.

Sistema

Endereço Campo Tipo Descrição
0x00 STATUS u8 bit0 = pronto, bit1 = erro
0x02 ERROR u8 Último código de erro (0x00 = OK)
0x03 VERSION u8 Versão do firmware
0x20 AC_FREQ u8 Frequência da rede (Hz), 0 se não for detetado cruzamento por zero
0xCE DATA_VALID u8 bit0 = resultado válido disponível desde o arranque
0xCA V03_PERIOD_MS u32 LE Duração até agora do período de instantâneo atual (ms, diagnóstico — ver cap. 04)
Nas bibliotecas cliente

— a mesma tarefa sem acesso a registos:

Biblioteca Chamada O que faz
Arduino RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readPower(ch) ler o bloco RT completo, ou um valor de cada vez
ESP-IDF rbamp_read_all() / rbamp_read_power() ler o bloco RT completo, ou um valor de cada vez
Python dev.read_all() / dev.read_power(ch) ler o bloco RT completo, ou um valor de cada vez
ESPHome voltage / power Sensores YAML para os valores RT

Polling — um só módulo

Ciclo de polling de 1 Hz, o mais simples

C++
void loop() {
  float u = rb_read_float_le(0x50, 0x86);
  float i = rb_read_float_le(0x50, 0x8E);
  float p = rb_read_float_le(0x50, 0xA6);
  float pf = rb_read_float_le(0x50, 0xB2);
  float q = rb_read_float_le(0x50, 0xD0);
  uint8_t freq = rb_read_u8(0x50, 0x20);
  const char* dir = (p >= 0.0f) ? "-> consume" : "<- export ";

  Serial.printf("U=%.1fV  I=%.3fA  P=%.1fW %s  PF=%.3f  Q=%.1fVAR  f=%dHz\n",
                u, i, p, dir, pf, q, freq);
  delay(1000);
}

Consulta com intervalo fixo sem DRDY

C++
unsigned long last_read = 0;

void loop() {
  unsigned long now = millis();
  if (now - last_read >= 200) {
    last_read = now;
    float p = rb_read_float_le(0x50, 0xA6);
    Serial.println(p);
  }
}

Isto dá ~5 amostras por segundo — uma em cada duas janelas (v1.2 e posteriores) (o módulo atualiza a cada ~100 ms). Faça polling a cada 100 ms para apanhar cada janela; o intervalo de 200 ms também funciona nas imagens anteriores à v1.2.

Nas bibliotecas cliente

— a mesma tarefa sem acesso a registos:

Biblioteca Chamada O que faz
Arduino RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readAllReady(timeout_ms, out, ev) leia o bloco RT; ou aguarde um novo instantâneo e depois leia-o
ESP-IDF rbamp_read_all() / rbamp_read_all_ready() leia o bloco RT; ou aguarde um novo instantâneo e depois leia-o
Python dev.read_all() leia o bloco RT completo numa só chamada
ESPHome update_interval: o componente lê o bloco RT numa só rajada a cada atualização

Corrente multicanal (UI2 / UI3 / UI5 / UI7)

Nas variantes UI2/UI3 o mestre lê correntes e potências de todos os canais diretamente do bloco de tempo real. UI5 e UI7 (5 e 7 canais de corrente) usam os mesmos registos para os canais 0..2 e uma janela de acesso a canais para os canais 3 e seguintes — ver UI5 / UI7: canais 3 e seguintes abaixo.

C++
// UI3: three current channels on one module
void read_ui3(uint8_t addr) {
  float u = rb_read_float_le(addr, 0x86);
  float i0 = rb_read_float_le(addr, 0x8E);
  float i1 = rb_read_float_le(addr, 0x92);
  float i2 = rb_read_float_le(addr, 0x96);
  float p0 = rb_read_float_le(addr, 0xA6);
  float p1 = rb_read_float_le(addr, 0xAA);
  float p2 = rb_read_float_le(addr, 0xAE);

  Serial.printf("U=%.1f  Ch0: %.3fA/%.1fW  Ch1: %.3fA/%.1fW  Ch2: %.3fA/%.1fW\n",
                u, i0, p0, i1, p1, i2, p2);
}

Os canais de corrente são independentes — cada um tem a sua própria pinça CT com o seu próprio coeficiente. Um módulo UI3 pode monitorizar, por exemplo, a alimentação principal, o termoacumulador e o circuito de iluminação em simultâneo, na mesma fase. O sinal de P pode diferir entre canais: P > 0 na entrada da rede (a casa consome da rede) enquanto o canal de saída solar mostra P < 0 (o inversor exporta enquanto alimenta a mesma fase de que a casa consome).

UI5 / UI7: canais 3 e superiores

O bloco de tempo real plano contém apenas os canais 0, 1 e 2. No UI5 (canais 0..4) e no UI7 (canais 0..6), os restantes canais são lidos através da janela de acesso a canais: escreva (field << 4) | channel em REG_CHANNEL_SELECT (0x32) e depois leia o valor de REG_CHANNEL_DATA (0x3C, float32). Campos: 0 = corrente RMS, 1 = corrente de pico, 2 = potência ativa, 3 = fator de potência, 13 = potência média do período.

Três regras que evitam números errados sem aviso:

  • Não estenda o padrão plano. O registo a seguir a V03_I2_RMS (0x96) é V03_I0_PEAK (0x9A), e não o canal 3 — o canal 3 e superiores existem apenas na janela.
  • Selecione antes de cada leitura. REG_CHANNEL_DATA é um instantâneo tirado quando o seletor é escrito; ler de novo sem nova escrita do seletor devolve o mesmo valor antigo.
  • A média de período e a energia dos canais 3 e seguintes vêm apenas do campo 13 — não há registos planos de período para eles.
C++
// UI5 / UI7: read current and power on every channel.
// rb_read_u8 / rb_read_float_le / rb_write_u8 are the helpers from initialization.md.

float rb_read_channel(uint8_t addr, uint8_t field, uint8_t ch) {
  rb_write_u8(addr, 0x32, (field << 4) | ch);   // REG_CHANNEL_SELECT: choose field + channel
  return rb_read_float_le(addr, 0x3C);          // REG_CHANNEL_DATA: the selected value
}

void read_ui7(uint8_t addr) {
  uint8_t n = rb_read_u8(addr, 0x24);           // TOPOLOGY: number of current channels (5 on UI5, 7 on UI7)
  float u = rb_read_float_le(addr, 0x86);       // one shared voltage

  Serial.printf("U=%.1f V\n", u);
  for (uint8_t ch = 0; ch < n; ch++) {
    float i, p;
    if (ch < 3) {                               // channels 0..2: flat real-time block
      i = rb_read_float_le(addr, 0x8E + 4 * ch);
      p = rb_read_float_le(addr, 0xA6 + 4 * ch);
    } else {                                    // channels 3..n-1: channel access window
      i = rb_read_channel(addr, 0, ch);         // field 0 = RMS current
      p = rb_read_channel(addr, 2, ch);         // field 2 = active power
    }
    Serial.printf("Ch%u: %.3f A  %.1f W\n", ch, i, p);
  }
}

A janela também funciona para os canais 0..2, pelo que pode usá-la para todos os canais se preferir um único caminho de código (uma pequena escrita extra por valor). Detalhes e todos os códigos de campo: api-reference.md → Janela de acesso aos canais.

Todos os canais partilham uma tensão U

As variantes UI contêm um único sensor de tensão — mede a fase que alimenta o módulo. Todos os valores P dos canais são calculados em relação a esta U partilhada*:

Text
P0 = mean(u(t) · i0(t))
P1 = mean(u(t) · i1(t))
P2 = mean(u(t) · i2(t))

Isto pressupõe que todas as pinças CT estão em condutores da mesma fase.

Nas bibliotecas cliente

— a mesma tarefa sem acesso a registos:

Biblioteca Chamada O que faz
Arduino RbAmp::channels() / RbAmp::readCurrent(ch) obter o número de canais; ler um canal por índice
ESP-IDF rbamp_channels() / rbamp_read_channel() obtenha o número de canais; leia todos os campos RT de um canal (incl. 3 e seguintes)
Python dev.channels / dev.current[ch] número de canais após begin(); leia um canal pelo índice
ESPHome current_N: declarar um slot de sensor por canal de corrente

Polling de vários módulos — três estratégias

As três estratégias para consultar vários módulos: round-robin, DRDY por módulo e DRDY em OR-cabeado.

Estratégia 1 — polling em round-robin (simples)

O mestre lê os módulos à vez, por exemplo a cada janela (~100 ms) ou a cada segundo:

C++
const uint8_t modules[] = {0x50, 0x51, 0x52};
const int N = 3;
int idx = 0;

void loop() {
  uint8_t addr = modules[idx];
  float p = rb_read_float_le(addr, 0xA6);
  Serial.printf("[0x%02X] P=%.1f W\n", addr, p);
  idx = (idx + 1) % N;
  delay(200);
}

Prós: código mínimo, sem GPIO extra. Contras: a CPU do mestre fica continuamente ocupada; sem marca de tempo precisa de "nova janela".

Estratégia 2 — DRDY por módulo (preciso, intensivo em GPIO)

O DRDY de cada módulo está ligado ao seu próprio GPIO do mestre, cada um com o seu próprio handler EXTI:

C++
const uint8_t modules[] = {0x50, 0x51, 0x52};
const uint8_t pins[]    = {15, 16, 17};
volatile bool ready[]   = {false, false, false};

void IRAM_ATTR drdy_0() { ready[0] = true; }
void IRAM_ATTR drdy_1() { ready[1] = true; }
void IRAM_ATTR drdy_2() { ready[2] = true; }

void setup() {
  Wire.begin();
  void (*isr_arr[])() = {drdy_0, drdy_1, drdy_2};
  for (int i = 0; i < 3; i++) {
    pinMode(pins[i], INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(pins[i]), isr_arr[i], FALLING);
  }
}

void loop() {
  for (int i = 0; i < 3; i++) {
    if (ready[i]) {
      ready[i] = false;
      float p = rb_read_float_le(modules[i], 0xA6);
      Serial.printf("[%d] P=%.1f W\n", i, p);
    }
  }
}

Vantagens: sincronização precisa, latência de leitura mínima. Desvantagens: um GPIO + EXTI por módulo; não escala para além de ~4 módulos.

Estratégia 3 — DRDY em OR por fio (compacto)

Todos os pinos DRDY (dreno aberto) estão ligados num único fio. O mestre deteta a aresta descendente de qualquer módulo e lê todos os módulos:

Text
rbAmp #1 DRDY ──┐
rbAmp #2 DRDY ──┼──┬─[10K]── +3.3V
rbAmp #3 DRDY ──┘  │
                   ▼
              Master GPIO IN (EXTI falling)
C++
const uint8_t modules[] = {0x50, 0x51, 0x52};
const uint8_t PIN_DRDY = 15;   // example pin — any input-capable GPIO works
volatile bool any_ready = false;

void IRAM_ATTR drdy() { any_ready = true; }

void setup() {
  Wire.begin();
  pinMode(PIN_DRDY, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PIN_DRDY), drdy, FALLING);
}

void loop() {
  if (any_ready) {
    any_ready = false;
    for (int i = 0; i < 3; i++) {
      float p = rb_read_float_le(modules[i], 0xA6);
      Serial.printf("[0x%02X] P=%.1f W\n", modules[i], p);
    }
  }
}

Vantagens: um GPIO + EXTI para qualquer número de módulos; económico em fios. Desvantagens: o mestre não sabe qual módulo ativou a linha — tem de ler todos. Períodos de módulos ligeiramente desfasados (cada um tem o seu cristal) produzem disparos "duplos" (um módulo pronto, outro um milissegundo depois). Inofensivo — basta ler todos os módulos.

Tabela de compromissos

Abordagem GPIO do mestre Latência Complexidade Escalabilidade
Consulta (polling) sem DRDY 0 até 1 janela (~100 ms) mínimo até ~16 módulos
DRDY por módulo N < 1 ms médio até ~4 módulos
DRDY em OR-cabeado 1 ~1–5 ms baixo até ~10 módulos

Recomendação

  • 1–3 módulos, com latência baixa exigida → DRDY por módulo
  • 3–10 módulos, o orçamento de GPIO conta → DRDY em OR-cabeado
  • Qualquer número de módulos, a latência não importa → polling simples
Nas bibliotecas cliente

— a mesma tarefa sem acesso a registos:

Biblioteca Chamada O que faz
Arduino RbAmpFleet::scan(match_product, added) / RbAmpFleet::pollAll(snaps, status, capacity, n_ok) descobrir os módulos; ler todos numa só passagem
ESP-IDF rbamp_fleet_scan() / rbamp_fleet_poll_all() descobrir os módulos; ler todos numa só passagem
Python fleet.scan(match_product=True) / fleet.poll_all() descobrir os módulos; ler todos numa só passagem
ESPHome rbamp: (lista) um bloco rbamp: por módulo, cada um com o seu próprio id e address

Variantes só de corrente (sem sensor de tensão)

Em I1/I2/I3 (e nas variantes só de corrente com mais canais), sem sensor de tensão:

Registo Devolve
U_rms (0x86) 0.0f
U_peak (0x8A) 0.0f
I*_rms, I*_peak Valores reais
P*_real (0xA6, 0xAA, 0xAE) 0.0f (sem U → sem P)
PF*, Q* 0.0f
AC_FREQ (0x20) Valor real (50 ou 60). A deteção de passagem por zero vem de um pino dedicado de ZC da rede, independente da entrada de tensão, e está disponível em todos os variantes, incluindo os só de corrente.
ZC_OFFSET (0x4E) 0xFFFF. Este registo é o desvio de fase entre o instante do instantâneo GC e o próximo cruzamento por zero de tensão, usado na compensação de fase U/I — só é significativo quando um sinal de tensão está a ser medido. Nas variantes só de corrente é forçado a 0xFFFF pelo firmware (sem medição de tensão).

Sem P não há informação sobre o sentido da corrente — I_rms é sempre ≥ 0 e não mostra em que sentido a corrente circula.

As variantes só de corrente destinam-se a:

  • Mestres que fornecem a sua própria fonte de tensão e calculam P eles próprios (p. ex., um ESP32 com um módulo ZMPT incorporado mais um rbAmp-I3 para três cargas)
  • Aplicações só de corrente: deteção de presença de carga, proteção contra sobrecorrente, equilíbrio de elementos de aquecimento resistivos

Referência rápida dos registos RT

Text
0x00 STATUS (u8)         — bit0=ready, bit1=error
0x02 ERROR (u8)          — last error code
0x03 VERSION (u8)        — protocol version (0x04 = v1.3)
0x05 CT_MODEL (u8, RW)   — staging only; bind via CMD_SET_CT_MODEL_CHn (see ch 02)
0x20 AC_FREQ (u8)        — mains frequency, Hz (all variants — ZC-sourced from a dedicated pin)
0x30 I2C_ADDRESS (u8 RW) — slave address; change via two-phase commit (see ch 02)

0x86 U_rms (f32)         — V
0x8A U_peak (f32)        — V
0x8E I0_rms (f32)        — A
0x92 I1_rms (f32)        — A
0x96 I2_rms (f32)        — A
0x9A I0_peak (f32)       — A
0x9E I1_peak (f32)       — A
0xA2 I2_peak (f32)       — A
0xA6 P0_real (f32, ±)    — W  (sign: + consume, − export)
0xAA P1_real (f32, ±)    — W
0xAE P2_real (f32, ±)    — W
0xB2 PF0 (f32, ±)        — −1..+1
0xB6 PF1 (f32, ±)        — −1..+1
0xBA PF2 (f32, ±)        — −1..+1

0xCA V03_PERIOD_MS (u32) — diagnostic, current snapshot-period duration
0xCE DATA_VALID (u8)     — bit0 = valid after boot

0xD0 Q0_reac (f32, ≥0)   — VAr, √(S²−P²), includes distortion
0xD4 Q1_reac (f32, ≥0)   — VAr
0xD8 Q2_reac (f32, ≥0)   — VAr

Seguinte