rbAmp
ES
Tienda
Docs
Actualizado

03 · Sondeo en tiempo real

Sondeo en tiempo real: lectura de valores instantáneos de U, I, P, FP, sentido del flujo y métricas relacionadas a intervalos regulares (normalmente una vez por ventana de medición, ~100 ms). Se usa para:

  • Paneles en vivo (potencia y tensión actuales)
  • Alarmas de umbral
  • Detección de eventos (encendido / apagado de la carga)
  • Monitorización de la calidad de red (frecuencia, PF)
  • Determinar el sentido de la corriente: consumo o exportación (según el signo de P_real)

Para la acumulación de energía tarifaria (Wh en un período), use el mecanismo de instantánea de período descrito en period-metering.md.

La ventana de medición (100 ms)

Temporización de la ventana de medida y momento en que se publica su conjunto de resultados.

Qué es

El módulo mide de forma continua y publica un conjunto de resultados cada ~100 ms (imágenes de firmware anteriores a v1.2: cada ~200 ms):

  • RMS de tensión y corrientes
  • Valores de pico de U e I
  • Potencia activa P, calculada como mean(u(t) · i(t)): con signo, indicando el sentido del flujo:
  • P > 0: la carga consume de la red (modo normal)
  • P < 0: la carga exporta a la red (inversor solar, carga regenerativa)
  • Potencia reactiva Q, calculada como √(S² − P²) con S = U_rms × I_rms: sin signo (≥ 0), incluye la potencia de distorsión; da 0 en variantes solo de corriente y es ruidosa cerca de FP ≈ 1
  • Factor de potencia FP = P / S, con S = U_rms × I_rms. El signo de FP coincide con el de P: un indicador adicional del sentido del flujo.

Tras calcular una ventana, el firmware publica de forma atómica el conjunto completo de resultados (más de 50 bytes) en el bloque de registros I²C 0x86..0xCD.

La longitud de la ventana es fija

La ventana está fijada en 100 ms desde la v1.2, con independencia de la frecuencia de red. En imágenes anteriores a la v1.2 la ventana es de 200 ms.

A 50 Hz de red, una ventana de 100 ms cubre exactamente 5 ciclos; a 60 Hz, 6 ciclos (10 y 12 en la ventana anterior de 200 ms). En ambos casos el número entero de ciclos de red mantiene RMS y P precisos.

Nota

El registro V03_PERIOD_MS (0xCA..0xCD, u32 LE) informa de la duración del período de instantánea actual hasta ahora (ms desde el último CMD_LATCH_PERIOD; vea el capítulo 04). Es solo de diagnóstico; no afecta a la precisión de la medición ni al cálculo de energía.

Cuando empiece la siguiente ventana

Inmediatamente después de publicar la anterior. No hay hueco entre ventanas: la medición es continua.

Cómo se relaciona la ventana de medida con la instantánea del periodo.

DATA_READY (DRDY): el pin de listo

DRDY es una salida de drenador abierto con pull-up a 3.3 V en el lado del master. El firmware lo pone en LOW durante ~10 µs después de refrescar los registros RT: una señal hardware que dice «los datos están listos para leer».

Parámetros del pulso

  • Duración LOW: ~10 µs (cómodo para cualquier master con EXTI)
  • Frecuencia: ~10 Hz (un pulso por ventana de 100 ms; ~5 Hz en imágenes anteriores a v1.2)
  • Tipo de salida: drenador abierto (admite wired-OR en topologías de varios módulos)
  • Significado: el flanco de bajada garantiza que todos los registros RT son coherentes y están actualizados

Cuando no se necesita DRDY

  • El master sondea más despacio que la frecuencia de ventana (una vez por segundo o por minuto): los datos se refrescan diez veces por segundo (v1.2 y posteriores), así que cualquier lectura obtiene datos frescos.
  • Un bucle de sondeo sencillo: read_rt() puede llamarse en cualquier momento; obtiene el último resultado confirmado.

Cuándo es útil DRDY

  • El master quiere reducir el tráfico I²C o liberar CPU para otras tareas (sistemas alimentados por batería)
  • Sincronización precisa: lea el instante exacto en que termina la medición (útil para registros de alta resolución)
  • Detección de eventos: reaccione a cada ventana (p. ej., seguimiento de potencia instantánea con una granularidad de ~100 ms)

Uso (Arduino, un 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);
  }
}
En las bibliotecas cliente

— la misma tarea sin acceso a registros:

Biblioteca Llamada Qué hace
Arduino RbAmp::setDrdyPin(pin) / RbAmp::waitDataReady(timeout_ms, ev) conecte la línea DRDY; espere una nueva instantánea
ESP-IDF rbamp_set_drdy_gpio() / rbamp_wait_data_ready() conecte el GPIO DRDY; espere una nueva instantánea
Python — no expuesto: la biblioteca no usa el pin; gestiónelo en su propio código
ESPHome drdy_pin: entrada DRDY opcional en YAML; el componente solo la registra

El signo de P y el sentido del flujo

En los registros RT, el signo de la potencia activa es el indicador principal del sentido de la corriente:

Condición Significado
P_real > 0 La carga consume (la corriente entra)
P_real < 0 Carga que exporta a la red (generación)
P_real ≈ 0 mientras I_rms > 0 Carga puramente reactiva (transformador en vacío, condensador)

Los valores RMS de corriente y tensión son siempre ≥ 0 (el RMS no es negativo por definición). Por tanto I_rms no puede usarse para determinar el sentido del flujo: use P_real.

Ejemplo de clasificación del sentido del flujo

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

En el firmware de nivel BASIC, el acumulador de tarifas ignora la exportación (véase period-metering.md). Los registros RT, sin embargo, siempre llevan el signo real en tiempo real de P: así, incluso en un SKU BASIC, el maestro puede detectar eventos de exportación a partir de lecturas RT, registrarlos o construir un acumulador bidireccional en el maestro sobre el firmware BASIC.

Referencia de registros RT

Todos los valores son float32 little-endian (4 bytes). LA LECTURA admite autoincremento: lea cada valor como una ráfaga de 4 bytes (o todo el bloque 0x86..0xBD en una sola ráfaga, véase §read-freeze). Los campos enteros se marcan con su tipo.

Tensión

Dirección Campo Tipo Unidad Descripción
0x86 U_rms float32 V Tensión RMS en la última ventana de medición
0x8A U_peak float32 V Desviación máxima respecto a la media durante la ventana

Corrientes (por canal: 0 = primario, 1/2 en UI2/UI3, más en UI5/UI7)

Dirección Campo Tipo Unidad
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

En variantes con menos canales (p. ej., UI1), los registros de canales no usados devuelven 0.0f en lugar de NACK. Las variantes con más canales (UI5/UI7) colocan sus valores adicionales de I_rms / P_real / PF / Q en registros por encima de 0xCF; consulte la hoja de datos del modelo para el mapa ampliado.

Potencia

Dirección Campo Tipo Unidad Signo Descripción
0xA6 P0_real float32 W ± Potencia activa, canal 0: P > 0 = consumo, P < 0 = exportación
0xAA P1_real float32 W ± Potencia activa, canal 1 (UI2/UI3)
0xAE P2_real float32 W ± Potencia activa, canal 2 (UI3)
0xB2 PF0 float32 – ± Factor de potencia, rango −1…+1, el signo coincide con P0
0xB6 PF1 float32 – ±
0xBA PF2 float32 – ±
0xD0 Q0_reac float32 VAr ≥ 0 Potencia reactiva canal 0 = √(S² − P²): incluye la potencia de distorsión; ruidosa cerca de FP ≈ 1; 0 en variantes solo de corriente
0xD4 Q1_reac float32 VAr ≥ 0
0xD8 Q2_reac float32 VAr ≥ 0
Nota

La potencia aparente S puede derivarse en el master: S = U_rms × I_rms. Los valores RMS son siempre ≥ 0; el sentido del flujo está en el signo de P.

Advertencia de atomicidad para Q: el bloque RT 0x86..0xBD (U/I/P/PF) se entrega bajo congelación de lectura y está garantizado sin desgarros en una sola lectura en ráfaga. Los registros Q (0xD0..0xDB) quedan fuera de esa ventana de congelación: si lee U/I/P + Q en dos transacciones separadas, U/I/P serán de una instantánea coherente, pero Q puede pertenecer al siguiente commit RT. Para la coherencia entre magnitudes a granularidad inferior al periodo, lea Q bajo una instantánea de CMD_LATCH_PERIOD (el promedio de Q de ch1/ch2 en 0xC2..0xC9 no está expuesto; use el bloque de instantánea del capítulo 11 §4.12) o acepte un desfase de hasta una ventana (~100 ms) entre P y Q.

Sistema

Dirección Campo Tipo Descripción
0x00 STATUS u8 bit0 = listo, bit1 = error
0x02 ERROR u8 Último código de error (0x00 = OK)
0x03 VERSION u8 Versión del firmware
0x20 AC_FREQ u8 Frecuencia de red (Hz), 0 si no se detecta cruce por cero
0xCE DATA_VALID u8 bit0 = resultado válido disponible desde el arranque
0xCA V03_PERIOD_MS u32 LE Duración hasta ahora del período de instantánea actual (ms, diagnóstico; vea el cap. 04)
En las bibliotecas cliente

— la misma tarea sin acceso a registros:

Biblioteca Llamada Qué hace
Arduino RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readPower(ch) lea el bloque de tiempo real completo, o un valor cada vez
ESP-IDF rbamp_read_all() / rbamp_read_power() lea el bloque de tiempo real completo, o un valor cada vez
Python dev.read_all() / dev.read_power(ch) lea el bloque de tiempo real completo, o un valor cada vez
ESPHome voltage / power Sensores YAML para los valores RT

Sondeo: un solo módulo

Bucle de sondeo más simple, 1 Hz

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);
}

Sondeo a intervalo fijo sin 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);
  }
}

Esto da ~5 muestras por segundo: una de cada dos ventanas (v1.2 y posteriores; el módulo se actualiza cada ~100 ms). Sondee cada 100 ms para captar cada ventana; el intervalo de 200 ms también funciona en imágenes anteriores a la v1.2.

En las bibliotecas cliente

— la misma tarea sin acceso a registros:

Biblioteca Llamada Qué hace
Arduino RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readAllReady(timeout_ms, out, ev) lea el bloque RT; o espere una nueva instantánea y léala
ESP-IDF rbamp_read_all() / rbamp_read_all_ready() lea el bloque RT; o espere una nueva instantánea y léala
Python dev.read_all() lea el bloque RT completo en una sola llamada
ESPHome update_interval: el componente lee el bloque RT en una sola ráfaga en cada actualización

Corriente multicanal (UI2 / UI3 / UI5 / UI7)

En las variantes UI2/UI3, el master lee corrientes y potencias de todos los canales directamente del bloque de tiempo real. UI5 y UI7 (5 y 7 canales de corriente) usan los mismos registros para los canales 0..2 y una ventana de acceso a canales para los canales 3 en adelante; vea UI5 / UI7: canales 3 y siguientes más abajo.

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);
}

Los canales de corriente son independientes: cada uno tiene su propia pinza CT con su propio coeficiente. Un módulo UI3 puede monitorizar, por ejemplo, la acometida principal, el calentador de agua y el circuito de iluminación a la vez, en la misma fase. El signo de P puede diferir entre canales: P > 0 en la entrada de red (la vivienda consume de la red) mientras el canal de salida solar muestra P < 0 (el inversor exporta mientras alimenta la misma fase de la que consume la vivienda).

UI5 / UI7: canales 3 y superiores

El bloque de tiempo real plano contiene solo los canales 0, 1 y 2. En UI5 (canales 0..4) y UI7 (canales 0..6), el resto de canales se lee a través de la ventana de acceso a canales: escriba (field << 4) | channel en REG_CHANNEL_SELECT (0x32) y lea el valor de REG_CHANNEL_DATA (0x3C, float32). Campos: 0 = corriente RMS, 1 = corriente de pico, 2 = potencia activa, 3 = factor de potencia, 13 = potencia media de período.

Tres reglas que evitan números erróneos sin aviso:

  • No extienda el patrón plano. El registro que sigue a V03_I2_RMS (0x96) es V03_I0_PEAK (0x9A), no el canal 3: el canal 3 y superiores existen solo en la ventana.
  • Seleccione antes de cada lectura. REG_CHANNEL_DATA es una instantánea tomada cuando se escribe el selector; leerlo de nuevo sin una nueva escritura del selector devuelve el mismo valor antiguo.
  • La media de período y la energía de los canales 3 y siguientes solo provienen del campo 13: no hay registros de período planos para ellos.
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);
  }
}

La ventana también funciona para los canales 0..2, así que puede usarla para todos los canales si prefiere una sola vía de código (una escritura pequeña adicional por valor). Detalles y todos los códigos de campo: api-reference.md → Ventana de acceso por canal.

Todos los canales comparten una misma tensión U

Las variantes UI contienen un único sensor de tensión: mide la fase que alimenta el módulo. Las potencias P de todos los canales se calculan frente a esta compartida* U:

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

Esto supone que todas las pinzas CT están en conductores de la misma fase.

En las bibliotecas cliente

— la misma tarea sin acceso a registros:

Biblioteca Llamada Qué hace
Arduino RbAmp::channels() / RbAmp::readCurrent(ch) obtenga el número de canales; lea un canal por índice
ESP-IDF rbamp_channels() / rbamp_read_channel() obtenga el número de canales; lea todos los campos RT de un canal (incl. 3 y siguientes)
Python dev.channels / dev.current[ch] número de canales tras begin(); lea un canal por índice
ESPHome current_N: declare una ranura de sensor por cada canal de corriente

Sondeo multimódulo: tres estrategias

Las tres estrategias para sondear varios módulos: round-robin, DRDY por módulo y DRDY en OR cableado.

Estrategia 1: sondeo round-robin (sencillo)

El maestro lee los módulos por turnos, por ejemplo cada ventana (~100 ms) o 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);
}

Pros: código mínimo, no requiere GPIO extra. Contras: la CPU del master queda ocupada de forma continua; no hay marca temporal precisa de «nueva ventana».

Estrategia 2: DRDY por módulo (precisa, con uso intensivo de GPIO)

El DRDY de cada módulo va al GPIO propio del maestro, cada uno con su propio manejador 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);
    }
  }
}

Ventajas: sincronización precisa, latencia de lectura mínima. Inconvenientes: un GPIO + EXTI por módulo; no escala más allá de ~4 módulos.

Estrategia 3: DRDY wired-OR (compacta)

Todos los pines DRDY (drenador abierto) van unidos en un único hilo. El master detecta el flanco de bajada de cualquier módulo y lee todos los 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);
    }
  }
}

Ventajas: un GPIO + EXTI para cualquier número de módulos; ahorra cableado. Inconvenientes: el maestro no sabe qué módulo activó la línea; debe leerlos todos. Los periodos de módulos ligeramente desfasados (cada uno tiene su propio cristal) producen disparos «dobles» (un módulo listo y otro un milisegundo después). Es inocuo: basta con leer todos los módulos.

Tabla de compensaciones

Enfoque GPIO del maestro Latencia Complejidad Escalabilidad
Sondeo sin DRDY 0 hasta 1 ventana (~100 ms) mínimo hasta ~16 módulos
DRDY por módulo N < 1 ms medio hasta ~4 módulos
DRDY en OR cableado 1 ~1–5 ms bajo hasta ~10 módulos

Recomendación

  • 1–3 módulos, se requiere baja latencia → DRDY por módulo
  • 3–10 módulos, el presupuesto de GPIO importa → DRDY en OR cableado
  • Cualquier número; la latencia no importa → sondeo simple
En las bibliotecas cliente

— la misma tarea sin acceso a registros:

Biblioteca Llamada Qué hace
Arduino RbAmpFleet::scan(match_product, added) / RbAmpFleet::pollAll(snaps, status, capacity, n_ok) descubra los módulos; lea todos ellos en una sola pasada
ESP-IDF rbamp_fleet_scan() / rbamp_fleet_poll_all() descubra los módulos; lea todos ellos en una sola pasada
Python fleet.scan(match_product=True) / fleet.poll_all() descubra los módulos; lea todos ellos en una sola pasada
ESPHome rbamp: (lista) un bloque rbamp: por módulo, cada uno con su propio id y address

Variantes solo de corriente (sin sensor de tensión)

En I1/I2/I3 (y en las variantes solo de corriente de canales superiores), sin sensor de tensión:

Registro Devuelve
U_rms (0x86) 0.0f
U_peak (0x8A) 0.0f
I*_rms, I*_peak Valores reales
P*_real (0xA6, 0xAA, 0xAE) 0.0f (sin U → sin P)
PF*, Q* 0.0f
AC_FREQ (0x20) Valor real (50 o 60). La detección de cruce por cero procede de un pin dedicado de cruce por cero de red, independiente del frontal de tensión, y está disponible en todas las variantes, incluidas las solo de corriente.
ZC_OFFSET (0x4E) 0xFFFF. Este registro es el desfase de fase entre el instante de la instantánea GC y el siguiente cruce por cero de tensión, usado para la compensación de fase U/I; solo tiene sentido cuando se mide una señal de tensión. En variantes solo de corriente el firmware lo fuerza a 0xFFFF (sin medición de tensión).

Sin P no hay información sobre el sentido de la corriente: I_rms es siempre ≥ 0 y no muestra en qué sentido circula la corriente.

Las variantes solo de corriente están pensadas para:

  • Masters que aportan su propia fuente de tensión y calculan P ellos mismos (p. ej., un ESP32 con un módulo ZMPT integrado más un rbAmp-I3 para tres cargas)
  • Aplicaciones solo de corriente: detección de presencia de carga, protección contra sobrecorriente, equilibrado de elementos calefactores resistivos

Referencia rápida de registros 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

Siguiente