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)
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²)conS = 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.
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.
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)
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);
}
}
— 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
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
}
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 |
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 |
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) |
— 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
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
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.
— 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.
// 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) esV03_I0_PEAK(0x9A), no el canal 3: el canal 3 y superiores existen solo en la ventana. - Seleccione antes de cada lectura.
REG_CHANNEL_DATAes 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.
// 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:
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.
— 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
Estrategia 1: sondeo round-robin (sencillo)
El maestro lee los módulos por turnos, por ejemplo cada ventana (~100 ms) o cada segundo:
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:
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:
rbAmp #1 DRDY ──┐
rbAmp #2 DRDY ──┼──┬─[10K]── +3.3V
rbAmp #3 DRDY ──┘ │
▼
Master GPIO IN (EXTI falling)
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
— 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
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
- period-metering.md: instantánea de período atómica para la acumulación tarifaria
- troubleshooting.md: qué hacer si los valores parecen incorrectos