rbAmp
RU
Магазин
Документация
Обновлено

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, один модуль)

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);
  }
}
В клиентских библиотеках

— та же задача без доступа к регистрам:

Библиотека Вызов Что делает
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.

Пример классификации направления потока

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
}
Примечание

На прошивке уровня 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 Гц

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

Опрос с фиксированным интервалом без 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);
  }
}

Это даёт ~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 и выше ниже.

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

Токовые каналы независимы — у каждого свои токовые клещи со своим коэффициентом. Модуль 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 — плоских регистров периода для них нет.
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);
  }
}

Окно работает и для каналов 0..2, поэтому его можно использовать для всех каналов, если хотите единый путь кода (одна лишняя короткая запись на значение). Подробности и все коды полей: api-reference.md → Окно доступа к каналам.

Все каналы используют одно напряжение U

Варианты UI содержат один датчик напряжения — он измеряет фазу, которая питает модуль. Все значения P по каналам вычисляются относительно этого общего* U:

Text
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: объявите один слот датчика на каждый токовый канал

Опрос нескольких модулей — три стратегии

Три стратегии опроса нескольких модулей: круговой опрос, DRDY на каждый модуль и объединённая линия DRDY (wired-OR).

Подход 1 — опрос по кругу (простой)

Мастер опрашивает модули по очереди, например, каждое окно (~100 мс) или каждую секунду:

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

Плюсы: минимум кода, не нужен дополнительный GPIO. Минусы: ЦП мастера постоянно занят; нет точной метки «нового окна».

Стратегия 2 — DRDY на каждый модуль (точно, но требует много GPIO)

DRDY каждого модуля подключён к своему GPIO мастера, у каждого свой обработчик 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);
    }
  }
}

Плюсы: точная синхронизация, минимальная задержка чтения. Минусы: один GPIO + EXTI на модуль; масштабируется не далее ~4 модулей.

Подход 3 — DRDY по схеме wired-OR (компактный)

Все пины DRDY (с открытым стоком) объединены в одну линию. Мастер фиксирует спадающий фронт у любого модуля и читает все модули:

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

Плюсы: один 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

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

Далее

  • period-metering.md — атомарный периодный снимок для тарифного накопления
  • troubleshooting.md — что делать, если значения неверны