03 · Опрос в реальном времени
Опрос в реальном времени — чтение мгновенных значений U, I, P, PF, направления потока и связанных величин с регулярным интервалом (обычно раз в окно измерения, ~100 мс). Применяется для:
- Живые панели (текущая мощность, напряжение)
- Пороговые тревоги
- Обнаружение событий (включение / выключение нагрузки)
- Мониторинг качества сети (частота, PF)
- Определение направления тока — потребление или выдача (по знаку P_real)
Для тарифного накопления энергии (Втч за период) используйте механизм периодного снимка, описанный в period-metering.md.
Окно измерения (100 мс)
Что это
Модуль измеряет непрерывно и публикует набор результатов примерно каждые 100 мс (прошивки до v1.2: примерно каждые 200 мс):
- RMS напряжения и токов
- Пиковые значения U и I
- Активная мощность P, вычисляемая как
mean(u(t) · i(t))— со знаком, знак указывает направление потока: P > 0— нагрузка потребляет из сети (обычный режим)P < 0— нагрузка отдаёт в сеть (солнечный инвертор, рекуперативная нагрузка)- Реактивная мощность Q, вычисляемая как
√(S² − P²), гдеS = U_rms × I_rms— без знака (≥ 0), включает мощность искажений; на вариантах только с током показывает 0 и шумит вблизи PF ≈ 1 - Коэффициент мощности PF = P / S, где S = U_rms × I_rms. Знак PF совпадает со знаком P — дополнительный признак направления потока.
После расчёта окна прошивка атомарно публикует весь набор результатов (50+ байт) в блок регистров I2C 0x86..0xCD.
Длина окна фиксирована
Окно жёстко задано 100 мс с v1.2, независимо от частоты сети. На образах до v1.2 окно — 200 мс.
При сети 50 Гц окно 100 мс охватывает ровно 5 периодов; при 60 Гц — 6 периодов (на старом окне 200 мс — 10 и 12). В обоих случаях целое число периодов сети сохраняет точность RMS и P.
Регистр V03_PERIOD_MS (0xCA..0xCD, u32 LE) сообщает длительность текущего периода снимка на данный момент (мс с последнего CMD_LATCH_PERIOD — см. главу 04). Он только диагностический; на точность измерения и расчёт энергии не влияет.
Когда начнётся следующее окно
Сразу после публикации предыдущего. Между окнами нет разрыва — измерение непрерывно.
DATA_READY (DRDY) — пин готовности
DRDY — выход с открытым стоком, подтянутый к 3.3 В на стороне мастера. Прошивка переводит его в LOW примерно на 10 мкс после обновления регистров RT — аппаратный сигнал «данные готовы к чтению».
Параметры импульса
- Длительность LOW: ~10 мкс (достаточно для любого мастера с EXTI)
- Частота: ~10 Гц (один импульс на окно 100 мс; ~5 Гц на прошивках до v1.2)
- Тип выхода: открытый сток (поддерживает wired-OR в топологиях с несколькими модулями)
- Смысл: спадающий фронт гарантирует, что все регистры RT согласованы и актуальны
Когда DRDY не нужен
- Мастер опрашивает медленнее частоты окон (раз в секунду или минуту) — данные обновляются десять раз в секунду (v1.2 и новее), поэтому любое чтение получает свежие данные.
- Простой цикл опроса —
read_rt()можно вызывать в любой момент; вы получаете последний зафиксированный результат.
Когда DRDY полезен
- Мастеру нужно минимизировать трафик I2C или освободить ЦП для других задач (системы с батарейным питанием)
- Точная синхронизация: фиксируйте точный момент завершения измерения (полезно для журналов высокого разрешения)
- Обнаружение событий: реагируйте на каждое окно (например, отслеживание мгновенной мощности с шагом ~100 мс)
Использование (Arduino, один модуль)
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);
}
}
— та же задача без доступа к регистрам:
| Библиотека | Вызов | Что делает |
|---|---|---|
| Arduino | RbAmp::setDrdyPin(pin) / RbAmp::waitDataReady(timeout_ms, ev) |
подключите линию DRDY; дождитесь нового снимка |
| ESP-IDF | rbamp_set_drdy_gpio() / rbamp_wait_data_ready() |
подключите GPIO DRDY; дождитесь нового снимка |
| Python | — | не используется — библиотека не задействует пин; обрабатывайте его в своём коде |
| ESPHome | drdy_pin: |
необязательный вход DRDY в YAML; компонент лишь записывает его в журнал |
Знак P и направление потока
В RT-регистрах знак активной мощности — главный признак направления тока:
| Условие | Значение |
|---|---|
P_real > 0 |
Нагрузка потребляет (ток идёт в неё) |
P_real < 0 |
Выдача в сеть (генерация) — энергия выгружается в сеть |
P_real ≈ 0 при I_rms > 0 |
Чисто реактивная нагрузка (ненагруженный трансформатор, конденсатор) |
Значения RMS тока и напряжения всегда ≥ 0 (RMS по определению неотрицательно). Поэтому I_rms нельзя использовать для определения направления потока — используйте P_real.
Пример классификации направления потока
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
}
На прошивке уровня BASIC тарифный накопитель игнорирует экспорт (см. period-metering.md). Регистры RT же всегда несут реальный знак P — поэтому даже на SKU BASIC мастер может определить события экспорта по чтениям RT, журналировать их или построить двунаправленный накопитель на стороне мастера поверх прошивки BASIC.
Справочник регистров RT
Все значения — float32 little-endian (4 байта). READ поддерживает автоинкремент — читайте каждое значение одним 4-байтным пакетом (или весь блок 0x86..0xBD одним пакетом, см. §read-freeze). Целочисленные поля помечены своим типом.
Напряжение
| Адрес | Поле | Тип | Единица | Описание |
|---|---|---|---|---|
0x86 |
U_rms | float32 | V | Среднеквадратичное напряжение за последнее окно измерения |
0x8A |
U_peak | float32 | V | Максимальное отклонение от среднего в течение окна |
Токи (по каналам: 0 = первичный, 1/2 на UI2/UI3, больше на UI5/UI7)
| Адрес | Поле | Тип | Единица |
|---|---|---|---|
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 |
На вариантах с меньшим числом каналов (например, UI1) регистры неиспользуемых каналов возвращают 0.0f вместо NACK. Варианты с большим числом каналов (UI5/UI7) размещают дополнительные значения I_rms / P_real / PF / Q выше 0xCF; расширенную карту см. в datasheet исполнения.
Мощность
| Адрес | Поле | Тип | Единица | Знак | Описание |
|---|---|---|---|---|---|
0xA6 |
P0_real | float32 | W | ± | Активная мощность, канал 0 — P > 0 = потребление, P < 0 = экспорт |
0xAA |
P1_real | float32 | W | ± | Активная мощность, канал 1 (UI2/UI3) |
0xAE |
P2_real | float32 | W | ± | Активная мощность, канал 2 (UI3) |
0xB2 |
PF0 | float32 | – | ± | Коэффициент мощности, диапазон −1…+1, знак совпадает с P0 |
0xB6 |
PF1 | float32 | – | ± | |
0xBA |
PF2 | float32 | – | ± | |
0xD0 |
Q0_reac | float32 | ВАр | ≥ 0 | Реактивная мощность ch0 = √(S² − P²) — включает мощность искажений; шумная вблизи PF ≈ 1; 0 на вариантах только с током |
0xD4 |
Q1_reac | float32 | ВАр | ≥ 0 | |
0xD8 |
Q2_reac | float32 | ВАр | ≥ 0 |
Полную мощность S можно вычислить на стороне мастера: S = U_rms × I_rms. Значения RMS всегда ≥ 0; направление потока задаёт знак P.
Оговорка об атомарности для Q: блок RT 0x86..0xBD (U/I/P/PF) выдаётся под заморозкой чтения и гарантированно без разрывов при пакетном чтении. Регистры Q (0xD0..0xDB) находятся вне этого окна заморозки — если вы читаете U/I/P и Q в двух отдельных транзакциях, U/I/P будут из согласованного снимка, а Q может относиться к следующему коммиту RT. Для согласованности величин на более мелкой, чем период, гранулярности либо читайте Q по снимку CMD_LATCH_PERIOD (0xC2..0xC9 для ch1/ch2; усреднённый Q не выведен — используйте блок снимка в главе 11 §4.12), либо примите рассогласование P и Q до одного окна (~100 мс).
Система
| Адрес | Поле | Тип | Описание |
|---|---|---|---|
0x00 |
STATUS | u8 | bit0 = готовность, bit1 = ошибка |
0x02 |
ERROR | u8 | Последний код ошибки (0x00 = OK) |
0x03 |
VERSION | u8 | Версия прошивки |
0x20 |
AC_FREQ | u8 | Частота сети (Гц), 0, если переход через ноль не обнаружен |
0xCE |
DATA_VALID | u8 | bit0 = действительный результат доступен с момента загрузки |
0xCA |
V03_PERIOD_MS | u32 LE | Длительность текущего периода снимка на данный момент (мс, диагностика — см. гл. 04) |
— та же задача без доступа к регистрам:
| Библиотека | Вызов | Что делает |
|---|---|---|
| Arduino | RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readPower(ch) |
читайте весь блок RT или по одному значению |
| ESP-IDF | rbamp_read_all() / rbamp_read_power() |
читайте весь блок RT или по одному значению |
| Python | dev.read_all() / dev.read_power(ch) |
читайте весь блок RT или по одному значению |
| ESPHome | voltage / power |
YAML-датчики для значений RT |
Опрос — один модуль
Простейший цикл опроса 1 Гц
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);
}
Опрос с фиксированным интервалом без 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);
}
}
Это даёт ~5 отсчётов в секунду — каждое второе окно (v1.2 и новее) (модуль обновляется каждые ~100 мс). Опрашивайте каждые 100 мс, чтобы поймать каждое окно; интервал 200 мс работает и на образах до v1.2.
— та же задача без доступа к регистрам:
| Библиотека | Вызов | Что делает |
|---|---|---|
| Arduino | RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readAllReady(timeout_ms, out, ev) |
прочитайте блок RT; либо дождитесь нового снимка и затем прочитайте его |
| ESP-IDF | rbamp_read_all() / rbamp_read_all_ready() |
прочитайте блок RT; либо дождитесь нового снимка и затем прочитайте его |
| Python | dev.read_all() |
прочитайте весь блок RT одним вызовом |
| ESPHome | update_interval: |
компонент читает блок RT одним пакетом при каждом обновлении |
Многоканальный ток (UI2 / UI3 / UI5 / UI7)
На вариантах UI2/UI3 мастер читает токи и мощности всех каналов прямо из блока реального времени. UI5 и UI7 (5 и 7 токовых каналов) используют те же регистры для каналов 0..2, а для каналов 3 и выше — окно доступа к каналам; см. UI5 / UI7: каналы 3 и выше ниже.
// 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);
}
Токовые каналы независимы — у каждого свои токовые клещи со своим коэффициентом. Модуль UI3 может одновременно контролировать, например, главный ввод, водонагреватель и цепь освещения на одной фазе. Знак P может различаться между каналами: P > 0 на вводе сети (дом потребляет из сети), а на канале выхода солнечной генерации P < 0 (инвертор отдаёт в сеть, питая ту же фазу, из которой потребляет дом).
UI5 / UI7: каналы 3 и выше
Плоский блок реального времени содержит каналы 0, 1 и 2 только. На UI5 (каналы 0..4) и UI7 (каналы 0..6) остальные каналы читаются через окно доступа к каналам: запишите (field << 4) | channel в REG_CHANNEL_SELECT (0x32), затем прочитайте значение из REG_CHANNEL_DATA (0x3C, float32). Поля: 0 = действующий ток, 1 = пиковый ток, 2 = активная мощность, 3 = коэффициент мощности, 13 = средняя мощность за период.
Три правила, которые защищают от молча неверных чисел:
- Не расширяйте плоский шаблон. Регистр после
V03_I2_RMS(0x96) — этоV03_I0_PEAK(0x9A), а не канал 3 — канал 3 и выше существуют только в окне. - Выбирайте перед каждым чтением.
REG_CHANNEL_DATA— это снимок, взятый в момент записи селектора; повторное чтение без новой записи селектора возвращает то же старое значение. - Средняя мощность периода и энергия для каналов 3 и выше поступают только из поля
13— плоских регистров периода для них нет.
// 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);
}
}
Окно работает и для каналов 0..2, поэтому его можно использовать для всех каналов, если хотите единый путь кода (одна лишняя короткая запись на значение). Подробности и все коды полей: api-reference.md → Окно доступа к каналам.
Все каналы используют одно напряжение U
Варианты UI содержат один датчик напряжения — он измеряет фазу, которая питает модуль. Все значения P по каналам вычисляются относительно этого общего* U:
P0 = mean(u(t) · i0(t))
P1 = mean(u(t) · i1(t))
P2 = mean(u(t) · i2(t))
Это предполагает, что все токовые клещи установлены на проводниках одной фазы.
— та же задача без доступа к регистрам:
| Библиотека | Вызов | Что делает |
|---|---|---|
| Arduino | RbAmp::channels() / RbAmp::readCurrent(ch) |
получить число каналов; прочитать канал по индексу |
| ESP-IDF | rbamp_channels() / rbamp_read_channel() |
получите число каналов; прочитайте все поля RT канала (включая 3 и выше) |
| Python | dev.channels / dev.current[ch] |
число каналов после begin(); читайте канал по индексу |
| ESPHome | current_N: |
объявите один слот датчика на каждый токовый канал |
Опрос нескольких модулей — три стратегии
Подход 1 — опрос по кругу (простой)
Мастер опрашивает модули по очереди, например, каждое окно (~100 мс) или каждую секунду:
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);
}
Плюсы: минимум кода, не нужен дополнительный GPIO. Минусы: ЦП мастера постоянно занят; нет точной метки «нового окна».
Стратегия 2 — DRDY на каждый модуль (точно, но требует много GPIO)
DRDY каждого модуля подключён к своему GPIO мастера, у каждого свой обработчик 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);
}
}
}
Плюсы: точная синхронизация, минимальная задержка чтения. Минусы: один GPIO + EXTI на модуль; масштабируется не далее ~4 модулей.
Подход 3 — DRDY по схеме wired-OR (компактный)
Все пины DRDY (с открытым стоком) объединены в одну линию. Мастер фиксирует спадающий фронт у любого модуля и читает все модули:
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);
}
}
}
Плюсы: один GPIO + EXTI на любое число модулей; экономия проводов. Минусы: мастер не знает, какой модуль выставил линию — приходится читать все. Немного смещённые периоды модулей (у каждого свой кварц) дают «двойные» срабатывания (один модуль готов, другой на миллисекунду позже). Безвредно — просто прочитайте все модули.
Таблица компромиссов
| Подход | GPIO мастера | Задержка | Сложность | Масштабируемость |
|---|---|---|---|---|
| Опрос без DRDY | 0 | до 1 окна (~100 мс) | минимальный | до ~16 модулей |
| DRDY на каждый модуль | N | < 1 мс | средний | до ~4 модулей |
| Объединённая линия DRDY (wired-OR) | 1 | ~1–5 мс | низкий | до ~10 модулей |
Рекомендация
- 1–3 модуля, нужна малая задержка → DRDY на каждый модуль
- 3–10 модулей, важен бюджет GPIO → объединённая линия DRDY
- Любое число, задержка не важна → простой опрос
— та же задача без доступа к регистрам:
| Библиотека | Вызов | Что делает |
|---|---|---|
| Arduino | RbAmpFleet::scan(match_product, added) / RbAmpFleet::pollAll(snaps, status, capacity, n_ok) |
обнаружить модули; прочитать все за один проход |
| ESP-IDF | rbamp_fleet_scan() / rbamp_fleet_poll_all() |
обнаружить модули; прочитать все за один проход |
| Python | fleet.scan(match_product=True) / fleet.poll_all() |
обнаружить модули; прочитать все за один проход |
| ESPHome | rbamp: (список) |
один блок rbamp: на модуль, каждый со своим id и address |
Варианты только с током (без датчика напряжения)
На I1/I2/I3 (и на вариантах только с током, с большим числом каналов), без датчика напряжения:
| Регистр | Возвращает |
|---|---|
U_rms (0x86) |
0.0f |
U_peak (0x8A) |
0.0f |
I*_rms, I*_peak |
Реальные значения |
P*_real (0xA6, 0xAA, 0xAE) |
0.0f (нет U → нет P) |
PF*, Q* |
0.0f |
AC_FREQ (0x20) |
Реальное значение (50 или 60). Детекция перехода через ноль идёт от отдельного вывода контроля нуля сети, независимого от фронтенда напряжения, и доступна на всех вариантах, включая варианты только с током. |
ZC_OFFSET (0x4E) |
0xFFFF. Этот регистр — фазовый сдвиг между моментом снимка GC и следующим переходом напряжения через ноль; используется для фазовой компенсации U/I и имеет смысл только при измерении напряжения. На вариантах только с током прошивка фиксирует 0xFFFF (нет измерения напряжения). |
Без P нет информации о направлении тока — I_rms всегда ≥ 0 и не показывает, в какую сторону течёт ток.
Варианты только с током предназначены для:
- Мастера, которые сами обеспечивают источник напряжения и сами вычисляют P (например, ESP32 со встроенным модулем ZMPT и rbAmp-I3 для трёх нагрузок)
- Приложения только по току: обнаружение наличия нагрузки, защита от перегрузки по току, балансировка резистивных нагревательных элементов
Краткий справочник регистров 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
Далее
- period-metering.md — атомарный периодный снимок для тарифного накопления
- troubleshooting.md — что делать, если значения неверны