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

16 · Примеры Python на Linux SBC

Эта глава — аналог для SBC к arduino-examples.md, micropython-examples.md, esp-idf-examples.md, stm32-hal-examples.md и pico-sdk-examples.md: те же десять сценариев, перенесённые на CPython в Linux (Raspberry Pi OS, Armbian, общий ARM/x86 Linux).

Примечание

Эти примеры обращаются к rbAmp напрямую через сырой API регистров I²C. Они предназначены для сервисных интеграций под Linux — шлюзов Home Assistant, роутеров OpenWrt, контейнеров Docker / k3s, пользовательских IoT-мостов — где Python подходит для задачи и прямой доступ к регистрам допустим.

Для более удобного структурированного интерфейса используйте пакет Python rbamp (см. таблицу клиентских библиотек в README). Пакет скрывает детали регистров за классом RbAmp с именованными методами (dev.voltage, dev.latch_period(), dev.read_period_snapshot() и т. д.), аккумулятором по каналам RbAmpEnergy, вариантом asyncio через async for, хелперами для нескольких модулей, автообнаружением MQTT для HA и шаблонами служб systemd в комплекте примеров, а также CLI rbamp (rbamp scan / read --watch / period). Тот же пакет работает без изменений на MicroPython — см. таблицу клиентских библиотек в README. Большинство проектов стоит начинать с пакета и обращаться к сырому API только при необходимости.

Чем Linux отличается от микроконтроллера

Главное отличие: Linux уже делает большую часть работы, которую примеры для голого железа прописывают вручную. Вы не инициализируете периферию I²C, не синхронизируете настенные часы и не боретесь с сохранением памяти между перезагрузками. Всё это есть на системном уровне. Ваш скрипт Python занимается только измерениями и бизнес-логикой и ничем больше.

Concretely:

Опасение Голый микроконтроллер Linux SBC
Инициализация периферии I²C i2c_init() / HAL_I2C_Init() Уже обрабатывается драйвером ядра (i2c-dev). Откройте /dev/i2c-N как файловый дескриптор.
Подтяжки Задать на этапе разработки платы или через gpio_pull_up() Решено в аппаратуре. Linux до них не дотрагивается.
Часы (UTC) Реализуйте SNTP и вызывайте gmtime_r() systemd-timesyncd / chrony автоматически синхронизируют часы. time.time() возвращает реальное количество секунд с начала эпохи.
Сохранение между перезагрузками Регистры резервной области RTC, RAM NOINIT, NVM Файловая система. Используйте JSON-файл, SQLite или /var/lib/rbamp/.
Глубокий сон esp_deep_sleep_start() / HAL_PWR_EnterSTANDBYMode() Не важно. SBC работает постоянно, а затраты в простое в любом случае определяются Wi-Fi или Ethernet. Сон здесь не применим.
ISR DRDY Прерывание по выводу в прошивке События по фронту в пространстве пользователя через gpiod / gpiozero. Задержка — несколько сотен микросекунд, в основном из-за планирования ядра.
MQTT Поднять Wi-Fi, самостоятельно написать стек TCP/TLS pip install paho-mqtt.
Демон / супервизор Цикл while без условия Модуль службы systemd с автоперезапуском и журналированием в journal.
Права доступа Не применимо Пользователь, от имени которого запускается ваш скрипт, должен входить в группы i2c и gpio или работать от root.
Система сборки CMake / idf.py / CubeIDE pip install -r requirements.txt (или pyproject.toml).

Если вы до сих пор писали прошивки, сдвиг мышления такой: перестаньте тянуться к низкоуровневым API. ОС уже отдаёт всё как файлы или вызовы стандартной библиотеки.

Настройка I²C в Linux (однократно)

Шаги ниже приведены для Raspberry Pi OS на Raspberry Pi 3/4/5. Другие SBC (Orange Pi, BeagleBone, x86 с USB-I2C адаптером) действуют по тому же принципу с другим номером шины.

1. Включите контроллер I²C в ядре

Raspberry Pi OS, простой путь:

Bash
sudo raspi-config nonint do_i2c 0           # 0 = enable

Или отредактируйте дерево устройств вручную:

Bash
sudo nano /boot/firmware/config.txt          # /boot/config.txt on older releases
# Add or uncomment the next line:
dtparam=i2c_arm=on
# Bus speed 100 kHz (recommended) — see also chapter 01:
dtparam=i2c_arm=on,i2c_arm_baudrate=100000

sudo reboot

После перезагрузки ядро показывает шину как символьное устройство:

Bash
ls /dev/i2c-*
# -> /dev/i2c-1

Для Pi 4/5 можно также включить дополнительные шины записями dtoverlay=i2c-bus,bus=N — полезно, когда нужна отдельная шина I²C для rbAmp вне HAT-плат.

Другие SBC:

  • Orange Pi / NanoPi / Banana Pi: похожие настройки dtoverlay или extlinux.conf зависят от BSP.
  • BeagleBone Black: config-pin P9.19 i2c / P9.20 i2c для I²C-2; узел — /dev/i2c-2.
  • x86 / общий Linux: USB-I2C адаптер (FT232H, MCP2221A, CH341) появляется как /dev/i2c-N после загрузки нужного модуля ядра.

2. Установите утилиты доступа на уровне ядра (необязательно, но полезно)

Bash
sudo apt update
sudo apt install -y i2c-tools
i2cdetect -y 1                              # scan bus 1

i2cdetect должен показать 50 по адресу rbAmp по умолчанию:

Text
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:                         -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
...
50: 50 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

3. Права пользователя

Добавьте своего пользователя в группу i2c, чтобы не использовать sudo при каждом запуске скрипта:

Bash
sudo usermod -aG i2c $USER
# Log out and back in for the group change to take effect.

Для доступа к DRDY / GPIO:

Bash
sudo usermod -aG gpio $USER                  # Raspberry Pi
sudo usermod -aG dialout $USER               # often required for serial / USB-CDC

Verify:

Bash
groups
# -> ... i2c gpio ...

4. Пакеты Python

Используйте виртуальное окружение, чтобы изолировать зависимости:

Bash
python3 -m venv ~/venv-rbamp
source ~/venv-rbamp/bin/activate

pip install --upgrade pip
pip install smbus2 gpiozero paho-mqtt
# Optional extras used in some examples:
pip install luma.oled            # SSD1306 / SH1106
pip install RPi.GPIO             # alternative to gpiozero on Pi
pip install python-periphery     # cross-SBC I2C / GPIO without smbus2

Для опубликованного проекта используйте pyproject.toml (PEP 621):

TOML
[project]
name = "my-rbamp-app"
version = "0.1.0"
dependencies = [
    "smbus2>=0.4.0",
    "paho-mqtt>=2.0,<3.0",          # 2.x: callback API version must be passed explicitly
    "gpiozero>=2.0",
]
Примечание о paho-mqtt 2.x

— версия 2.0 сделала версию API с колбэками обязательным аргументом конструктора. Все примеры в этой главе передают mqtt.CallbackAPIVersion.VERSION1, чтобы сохранить простые сигнатуры старого API (on_connect(client, userdata, flags, rc, properties=None)); если вы предпочитаете v2 (с ReasonCode + ConnectFlags), передайте CallbackAPIVersion.VERSION2 и соответственно обновите колбэки.

5. Время

По умолчанию systemd-timesyncd синхронизирует системные часы в UTC по NTP. Проверка:

Bash
timedatectl
#                Local time: Thu 2026-05-22 18:30:01 CEST
#            Universal time: Thu 2026-05-22 16:30:01 UTC
#  System clock synchronized: yes
#                NTP service: active

В Python затем вызываете time.time() (секунды UTC с эпохи), datetime.datetime.now(timezone.utc), time.localtime(), и это и есть нужное вам системное время. В вашем скрипте не нужен код SNTP.

6. Краткая справка по SBC

SBC Узел I²C Группа Примечания по DRDY
Raspberry Pi 3/4/5 /dev/i2c-1 i2c, gpio рекомендуется gpiozero
BeagleBone Black /dev/i2c-2 i2c, gpio Adafruit_BBIO / libgpiod
Orange Pi 4/5 /dev/i2c-3 (зависит от системы) i2c, gpio OPi.GPIO или libgpiod
Общий x86 + USB-I2C /dev/i2c-3..N i2c DRDY через GPIO адаптера (FT232H это поддерживает)

Остальная часть главы предполагает Raspberry Pi 4 / 5 + Raspberry Pi OS, но каждый пример работает на любом SBC после замены номера шины и библиотеки GPIO.


Оглавление примеров

# Заголовок Сложность Выход MQTT DRDY Несколько модулей Двунаправленный Сценарий использования
1 Быстрое чтение минимальный Консоль — — — — Проверка работоспособности
2 Счётчик энергии за 60 секунд на OLED низкий SSD1306 — — — — Счётчик Вт·ч в корпусе
3 Монитор нескольких модулей низкий Консоль — — да (3) — Мониторинг всего дома
4 Учёт энергии по отдельным приборам (UI3) средний — да — — — Субсчётчики в HA
5 Двунаправленный учёт на стороне мастера для модуля BASIC средний Консоль — да — да (мастер) Солнечный дом на уровне BASIC
6 Баланс энергии дома высокий — да — да (3) да Полный баланс дома
7 Обнаружение событий питания средний Файловый журнал — да — — Журнал событий приборов
8 Публикатор MQTT с HA Auto-discovery средний — да (+disco) — — необязательно Готовая интеграция с HA
9 Демон systemd с хранением в SQLite средний journald + DB да — — — Производственный регистратор
10 Тарификация по времени суток (TOU) с системными часами средний Консоль да — — необязательно Учёт по пиковому и внепиковому тарифу

Общие хелперы (rbamp_io.py)

Поместите этот файл рядом со своими скриптами (или импортируйте из пакета). Чтобы сэкономить место, он не повторяется в примерах ниже.

Python
"""rbAmp raw-I2C helpers for Linux CPython.

Uses smbus2 — the most widely available userspace I2C library on Linux.
For older systems, ``python3-smbus`` (the official Linux i2c-tools binding)
exposes a nearly identical API.

For cross-SBC portability without smbus2, swap in python-periphery; the
helpers are thin enough to port in a few minutes.
"""
from __future__ import annotations

import struct
import time
from typing import Optional

from smbus2 import SMBus, i2c_msg


# ---------- rbAmp register addresses (subset used in the examples) ----------
REG_STATUS         = 0x00
REG_COMMAND        = 0x01
REG_VERSION        = 0x03
REG_CT_MODEL       = 0x05
REG_PERIOD_VALID   = 0x07
REG_AC_FREQ        = 0x20
REG_I2C_ADDRESS    = 0x30
REG_U_RMS          = 0x86
REG_U_PEAK         = 0x8A
REG_I0_RMS         = 0x8E
REG_I1_RMS         = 0x92
REG_I2_RMS         = 0x96
REG_P0_REAL        = 0xA6
REG_PF0            = 0xB2
REG_Q0             = 0xD0
REG_PERIOD_AVG_P1  = 0xC2
REG_PERIOD_AVG_P2  = 0xC6
REG_DATA_VALID     = 0xCE
REG_PERIOD_AVG_P0  = 0xDC
REG_PERIOD_MAX_P   = 0xE0
REG_PERIOD_LATCH_MS= 0xEC

CMD_RESET          = 0x01
CMD_LATCH_PERIOD   = 0x27


class RbAmpIO:
    """Thin wrapper around an SMBus / address pair.

    Holds the bus handle and the target slave address, exposing one helper
    per primitive operation. Designed to be composed into larger classes
    (or used directly in scripts).
    """

    def __init__(self, bus: SMBus, addr: int = 0x50) -> None:
        """Bind to an already-opened SMBus and a 7-bit address.

        :param bus: An ``smbus2.SMBus(N)`` instance.
        :param addr: 7-bit slave address (default 0x50).
        """
        self.bus = bus
        self.addr = addr

    # ----- I2C primitives -----

    def read_u8(self, reg: int) -> int:
        """Read one byte from a register."""
        return self.bus.read_byte_data(self.addr, reg)

    def write_u8(self, reg: int, val: int) -> None:
        """Write one byte to a register."""
        self.bus.write_byte_data(self.addr, reg, val & 0xFF)

    def read_float_le(self, reg: int) -> float:
        """Read a little-endian float32 from four consecutive registers.

        rbAmp supports READ auto-increment (a single burst-read is valid for
        atomicity). The per-byte form below is shown for clarity. WRITE
        transactions, by contrast, are byte-at-a-time only. See chapter 11.
        """
        b = bytes(self.read_u8(reg + i) for i in range(4))
        return struct.unpack(" int:
        """Read a little-endian uint32 from four consecutive registers."""
        b = bytes(self.read_u8(reg + i) for i in range(4))
        return struct.unpack(" bool:
        """Return True if the slave acks a single-byte read of REG_STATUS."""
        try:
            self.bus.read_byte_data(self.addr, REG_STATUS)
            return True
        except OSError:
            return False

    def wait_ready(self, timeout_s: float = 2.0) -> None:
        """Block until DATA_VALID bit 0 reads 1, or raise TimeoutError."""
        deadline = time.monotonic() + timeout_s
        while time.monotonic() < deadline:
            try:
                if self.read_u8(REG_DATA_VALID) & 0x01:
                    return
            except OSError:
                pass
            time.sleep(0.05)
        raise TimeoutError(f"rbAmp at 0x{self.addr:02X} not ready in {timeout_s}s")


def broadcast_latch(bus: SMBus, tick16: int, group: int = 0) -> bool:
    """Broadcast CMD_LATCH_PERIOD to rbAmp modules with GC reception enabled.

    Canonical 5-byte general-call frame: A5 27 group tick_lo tick_hi.
    Slaves reject any first byte != 0xA5. GC reception is opt-in per
    module (FLEET_CONFIG.bit0, default OFF). See chapter 11 §6.3.2.

    Returns True on ACK; False on NACK (caller must fall back to
    per-module sequential snapshot).
    """
    msg = i2c_msg.write(0x00, [
        0xA5,                            # frame magic
        CMD_LATCH_PERIOD,                # opcode 0x27
        group & 0xFF,                    # group_id (0 = all-call)
        tick16 & 0xFF,                   # tick_lo
        (tick16 >> 8) & 0xFF,            # tick_hi
    ])
    try:
        bus.i2c_rdwr(msg)
        return True
    except OSError:
        return False

Пример 1 — быстрое чтение (минимальное)

Цель: выводить U, I, P, PF в консоль раз в секунду. Аппаратура: любой SBC и один rbAmp UI1 на /dev/i2c-1.

example_01.py:

Python
#!/usr/bin/env python3
"""rbAmp quick-read smoke test."""
import time
from smbus2 import SMBus
from rbamp_io import RbAmpIO, REG_VERSION, REG_U_RMS, REG_I0_RMS, REG_P0_REAL, REG_PF0

I2C_BUS = 1
RB_ADDR = 0x50

with SMBus(I2C_BUS) as bus:
    meter = RbAmpIO(bus, RB_ADDR)
    meter.wait_ready()                              # wait for first RT window
    print(f"rbAmp version: 0x{meter.read_u8(REG_VERSION):02X}")

    while True:
        u  = meter.read_float_le(REG_U_RMS)         # RMS voltage,  V
        i_ = meter.read_float_le(REG_I0_RMS)        # RMS current,  A
        p  = meter.read_float_le(REG_P0_REAL)       # active power, W (signed)
        pf = meter.read_float_le(REG_PF0)           # power factor, signed
        print(f"U={u:.1f}V  I={i_:.3f}A  P={p:+.1f}W  PF={pf:+.3f}")
        time.sleep(1)

Run:

Bash
python3 example_01.py
# rbAmp version: 0x04
# U=230.1V  I=0.262A  P=+60.2W  PF=+0.998
# U=229.9V  I=0.262A  P=+60.1W  PF=+0.998
# ...

Если вы видите PermissionError: [Errno 13] на /dev/i2c-1, ваш пользователь не входит в группу i2c — исправьте по разделу настройки Linux выше.


Пример 2 — счётчик энергии за 60 секунд на OLED

Цель: счётчик Вт·ч, обновляемый раз в минуту, выводится на OLED SSD1306 128×64 на общей шине I²C с rbAmp. Аппаратура: SBC + rbAmp + OLED SSD1306 (0x3C) на той же шине. Учёт: однонаправленный (уровень BASIC). Библиотека: luma.oled для дисплея (pip install luma.oled).

Python
#!/usr/bin/env python3
"""60-second energy meter on a 128x64 SSD1306, shared I2C bus."""
import time
from smbus2 import SMBus
from luma.core.interface.serial import i2c as luma_i2c
from luma.oled.device import ssd1306
from luma.core.render import canvas

from rbamp_io import (
    RbAmpIO, REG_COMMAND, REG_PERIOD_VALID,
    REG_PERIOD_AVG_P0, CMD_LATCH_PERIOD,
)

I2C_BUS = 1
RB_ADDR = 0x50

# luma opens its own connection but still drives /dev/i2c-1 — coexists with smbus2.
serial = luma_i2c(port=I2C_BUS, address=0x3C)
oled = ssd1306(serial, width=128, height=64)


def draw(avg_p: float, dt_s: float, total_wh: float) -> None:
    """Render the three lines."""
    with canvas(oled) as c:
        c.text((0, 0),  f"P:  {avg_p:6.1f} W", fill="white")
        c.text((0, 16), f"dt: {dt_s:6.1f} s",  fill="white")
        c.text((0, 32), f"{total_wh:.2f} Wh",  fill="white")


with SMBus(I2C_BUS) as bus:
    meter = RbAmpIO(bus, RB_ADDR)
    meter.wait_ready()

    # Primer snapshot — discard its snapshot.
    meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)
    t_prev = time.monotonic()
    total_wh = 0.0

    while True:
        time.sleep(60)

        # 1) Final snapshot — closes the period [t_prev .. now].
        meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)
        t_now = time.monotonic()
        time.sleep(0.05)                              # let firmware finalise snapshot

        # 2) Verify the snapshot is fresh.
        if (meter.read_u8(REG_PERIOD_VALID) & 0x01) == 0:
            print("WARN: stale snapshot")
            t_prev = time.monotonic()
            continue

        # 3) Read time-averaged power, channel 0.
        avg_p = meter.read_float_le(REG_PERIOD_AVG_P0)

        # 4) Energy uses the MASTER clock — same idea as on a microcontroller,
        # except `time.monotonic()` is the Linux equivalent of `HAL_GetTick()`.
        dt_s = t_now - t_prev
        e_wh = avg_p * dt_s / 3600.0
        total_wh += e_wh
        t_prev = t_now

        draw(avg_p, dt_s, total_wh)
        print(f"avg_P={avg_p:.1f}  E_period={e_wh:.3f}  total={total_wh:.3f}")

Пример 3 — Монитор нескольких модулей

Цель: опрашивать три модуля (основной ввод, водонагреватель, кондиционер) и выводить сумму. Аппаратура: SBC + 3 × rbAmp UI1 по адресам 0x50, 0x51, 0x52.

Python
#!/usr/bin/env python3
"""Round-robin polling of three rbAmp modules."""
import time
from smbus2 import SMBus
from rbamp_io import RbAmpIO, REG_U_RMS, REG_P0_REAL

I2C_BUS = 1
MODULES = [
    (0x50, "Mains "),
    (0x51, "Boiler"),
    (0x52, "AC    "),
]

with SMBus(I2C_BUS) as bus:
    meters = [(RbAmpIO(bus, addr), label) for addr, label in MODULES]

    # Probe every module before entering the read loop.
    for meter, label in meters:
        if not meter.probe():
            raise SystemExit(f"{label} at 0x{meter.addr:02X} not found")
    print("All modules OK")

    while True:
        total_p = 0.0
        print("---")
        for meter, label in meters:
            u = meter.read_float_le(REG_U_RMS)
            p = meter.read_float_le(REG_P0_REAL)
            print(f"[{label}] U={u:.1f}  P={p:+.1f} W")
            total_p += p
        print(f"TOTAL: {total_p:.1f} W")
        time.sleep(2)

probe() вызывает 1-байтовое read_byte_data и перехватывает OSError(EREMOTEIO) — аналог NACK на I²C в Linux.


Пример 4 — учёт энергии по отдельным приборам (UI3)

Цель: модуль UI3 с тремя токовыми клещами на трёх разных нагрузках одной фазы; независимые счётчики Вт·ч публикуются в MQTT каждую минуту. Аппаратура: SBC, 1 × rbAmp UI3 и брокер MQTT (Mosquitto, EMQX, аддон HA Mosquitto).

Python
#!/usr/bin/env python3
"""Per-appliance UI3 energy tracker with MQTT publishing."""
import json
import time

import paho.mqtt.client as mqtt
from smbus2 import SMBus

from rbamp_io import (
    RbAmpIO, REG_COMMAND, REG_PERIOD_VALID,
    REG_PERIOD_AVG_P0, REG_PERIOD_AVG_P1, REG_PERIOD_AVG_P2,
    CMD_LATCH_PERIOD,
)

I2C_BUS    = 1
RB_ADDR    = 0x50
CH_NAMES   = ("main", "heatpump", "lights")
MQTT_HOST  = "192.168.1.10"

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION1, client_id="rbamp-ui3")
try:
    client.connect(MQTT_HOST, 1883, keepalive=60)
except OSError as e:
    print(f"MQTT broker unreachable at boot ({e}); will retry in loop_start()")
client.loop_start()                            # paho's thread reconnects automatically


def mqtt_publish(name: str, avg_p: float, e_wh: float) -> None:
    """Publish one channel's state to MQTT."""
    payload = json.dumps({"power": round(avg_p, 1), "energy": round(e_wh, 4)})
    client.publish(f"rbamp/{name}/state", payload, qos=0, retain=False)


with SMBus(I2C_BUS) as bus:
    meter = RbAmpIO(bus, RB_ADDR)
    meter.wait_ready()

    meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)        # primer
    t_prev = time.monotonic()
    total_wh = [0.0, 0.0, 0.0]

    while True:
        time.sleep(60)

        meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)
        t_now = time.monotonic()
        time.sleep(0.05)

        if (meter.read_u8(REG_PERIOD_VALID) & 0x01) == 0:
            t_prev = time.monotonic()
            continue

        # PERIOD_AVG_P_W per channel: I0 at 0xDC, I1 at 0xC2, I2 at 0xC6.
        avg_p = (
            meter.read_float_le(REG_PERIOD_AVG_P0),
            meter.read_float_le(REG_PERIOD_AVG_P1),
            meter.read_float_le(REG_PERIOD_AVG_P2),
        )
        dt_s = t_now - t_prev
        t_prev = t_now

        for ch in range(3):
            e = avg_p[ch] * dt_s / 3600.0
            total_wh[ch] += e
            print(f"[{CH_NAMES[ch]}] avg_P={avg_p[ch]:+.1f} W  E_total={total_wh[ch]:.3f} Wh")
            mqtt_publish(CH_NAMES[ch], avg_p[ch], total_wh[ch])

Пример 5 — двунаправленный учёт на стороне мастера для модуля BASIC

Цель: реализовать двунаправленный учёт на мастере, когда модуль работает с прошивкой BASIC. SBC реагирует на спад DRDY через gpiozero и разделяет потребление и выдачу. Аппаратура: Raspberry Pi + rbAmp UI1; DRDY на GPIO 15 (нумерация BCM).

Python
#!/usr/bin/env python3
"""Master-side bidirectional accounting via DRDY GPIO IRQ."""
import time
from threading import Event

from gpiozero import Button
from smbus2 import SMBus

from rbamp_io import RbAmpIO, REG_P0_REAL

I2C_BUS  = 1
RB_ADDR  = 0x50
PIN_DRDY = 15                  # BCM

# Wrap the bus in a context manager so the /dev/i2c-N fd is released cleanly
# on any unhandled exception (Ctrl-C, NACK retry exhaustion, etc.).
with SMBus(I2C_BUS) as bus:
    meter  = RbAmpIO(bus, RB_ADDR)
    meter.wait_ready()

    # gpiozero treats DRDY as a "Button":
    #   pull_up=True -> the line idles HIGH (matches rbAmp's open-drain output)
    #   bounce_time=None — we want the raw falling edges, not debounced
    drdy = Button(PIN_DRDY, pull_up=True, bounce_time=None)
    data_ready = Event()

    def on_drdy() -> None:
        """gpiozero callback — only sets the flag. All I/O happens in the main loop."""
        data_ready.set()

    drdy.when_pressed = on_drdy

    e_consumed_wh = 0.0
    e_exported_wh = 0.0
    t_last = time.monotonic()
    t_last_print = t_last
    print("Bidirectional accumulator started")

    while True:
        if not data_ready.wait(timeout=1.0):
            continue                                # no edge in the last second
        data_ready.clear()

        t_now = time.monotonic()
        p = meter.read_float_le(REG_P0_REAL)        # signed P_real
        dt_s = t_now - t_last
        t_last = t_now

        if p > 0:
            e_consumed_wh += p * dt_s / 3600.0
        else:
            e_exported_wh += -p * dt_s / 3600.0

        # Summary print every 5 s.
        if t_now - t_last_print >= 5.0:
            t_last_print = t_now
            print(f"P={p:+8.1f}W   consumed={e_consumed_wh:.4f} Wh  "
                  f"exported={e_exported_wh:.4f} Wh  "
                  f"net={(e_consumed_wh - e_exported_wh):+.4f} Wh")

Notes:

  • threading.Event — естественный примитив синхронизации: set() вызывается из колбэка, wait() — из основного цикла. Задержка планирования Linux намного меньше периода RT-окна ~100 мс, поэтому ни одно событие не теряется.
  • Для старых выпусков Pi OS без gpiozero используйте RPi.GPIO.add_event_detect(15, GPIO.FALLING, callback=on_drdy). Для SBC без Pi используйте gpiod.LineRequest (libgpiod 2.x). Остальная часть скрипта не меняется.

Пример 6 — баланс энергии дома

Цель: полная панель баланса энергии. Три модуля:

  • rbAmp №1 на основном вводе (STD — двунаправленный)
  • rbAmp #2 на выходе солнечного инвертора (BASIC подходит)
  • rbAmp №3 UI3 на трёх мощных нагрузках (ТН, кондиционер, EV)

Мастер использует broadcast_latch() для синхронных снимков и публикует сохраняемый баланс в MQTT каждую минуту.

Python
#!/usr/bin/env python3
"""Home energy balance via synchronous broadcast snapshot."""
import json
import time

import paho.mqtt.client as mqtt
from smbus2 import SMBus

from rbamp_io import (
    RbAmpIO, broadcast_latch,
    REG_PERIOD_VALID, REG_PERIOD_AVG_P0, REG_PERIOD_AVG_P1, REG_PERIOD_AVG_P2,
)

I2C_BUS    = 1
ADDR_MAINS = 0x50                # bidirectional (STD)
ADDR_SOLAR = 0x51                # generation only (BASIC ok)
ADDR_LOADS = 0x52                # UI3
MQTT_HOST  = "192.168.1.10"

# PERIOD_AVG_P_NEG register for the mains module — see the SKU datasheet
# of the STD product. Set to None on BASIC modules.
from typing import Optional
REG_PERIOD_AVG_P_NEG_MAINS: Optional[int] = None     # Optional[int] for Py 3.9+ compat

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION1, client_id="home-balance")
try:
    client.connect(MQTT_HOST, 1883, keepalive=60)
except OSError as e:
    print(f"MQTT broker unreachable at boot ({e}); will retry in loop_start()")
client.loop_start()


def safe_read_float(meter: RbAmpIO, reg: int) -> float:
    """Return 0.0 if the read fails (e.g. NACK from a BASIC module)."""
    try:
        return meter.read_float_le(reg)
    except OSError:
        return 0.0


totals = {
    "mains_in_wh":    0.0,
    "mains_out_wh":   0.0,
    "solar_total_wh": 0.0,
    "loads_wh":       [0.0, 0.0, 0.0],
}

with SMBus(I2C_BUS) as bus:
    mains = RbAmpIO(bus, ADDR_MAINS)
    solar = RbAmpIO(bus, ADDR_SOLAR)
    loads = RbAmpIO(bus, ADDR_LOADS)
    for m in (mains, solar, loads):
        m.wait_ready()

    gc_tick = 0
    if not broadcast_latch(bus, gc_tick):
        # GC NACK → fall back to per-module sequential snapshot.
        for m in (mains, solar, loads):
            m.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)
    gc_tick += 1
    t_prev = time.monotonic()
    print("Home balance started")

    while True:
        time.sleep(60)

        # Synchronous snapshot — all modules snapshot at the same instant.
        if not broadcast_latch(bus, gc_tick):
            for m in (mains, solar, loads):
                m.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)
        gc_tick = (gc_tick + 1) & 0xFFFF
        t_now = time.monotonic()
        time.sleep(0.05)
        dt_s = t_now - t_prev
        t_prev = t_now

        # ---- MAINS (bidirectional) ----
        if mains.read_u8(REG_PERIOD_VALID) & 0x01:
            p_consume = safe_read_float(mains, REG_PERIOD_AVG_P0)
            p_export  = (safe_read_float(mains, REG_PERIOD_AVG_P_NEG_MAINS)
                         if REG_PERIOD_AVG_P_NEG_MAINS is not None else 0.0)
            totals["mains_in_wh"]  += p_consume * dt_s / 3600.0
            totals["mains_out_wh"] += p_export  * dt_s / 3600.0

        # ---- SOLAR ----
        if solar.read_u8(REG_PERIOD_VALID) & 0x01:
            p = safe_read_float(solar, REG_PERIOD_AVG_P0)
            totals["solar_total_wh"] += p * dt_s / 3600.0

        # ---- LOADS (UI3) ----
        if loads.read_u8(REG_PERIOD_VALID) & 0x01:
            for i, reg in enumerate((REG_PERIOD_AVG_P0, REG_PERIOD_AVG_P1, REG_PERIOD_AVG_P2)):
                p = safe_read_float(loads, reg)
                totals["loads_wh"][i] += p * dt_s / 3600.0

        # Derived balance figures.
        total_consumed  = (totals["mains_in_wh"]
                           + totals["solar_total_wh"]
                           - totals["mains_out_wh"])
        solar_self_used = max(0.0, totals["solar_total_wh"] - totals["mains_out_wh"])

        print(f"MAINS  in={totals['mains_in_wh']:.2f}  out={totals['mains_out_wh']:.2f}")
        print(f"SOLAR  gen={totals['solar_total_wh']:.2f}  "
              f"self-used={solar_self_used:.2f}  exported={totals['mains_out_wh']:.2f}")
        print(f"LOADS  HP={totals['loads_wh'][0]:.2f}  "
              f"AC={totals['loads_wh'][1]:.2f}  EV={totals['loads_wh'][2]:.2f}")
        print(f"TOTAL  household consumed={total_consumed:.2f} Wh")

        payload = json.dumps({
            "mains_in":       round(totals["mains_in_wh"], 3),
            "mains_out":      round(totals["mains_out_wh"], 3),
            "solar":          round(totals["solar_total_wh"], 3),
            "self_used":      round(solar_self_used, 3),
            "total_consumed": round(total_consumed, 3),
            "hp":             round(totals["loads_wh"][0], 3),
            "ac":             round(totals["loads_wh"][1], 3),
            "ev":             round(totals["loads_wh"][2], 3),
        })
        client.publish("home/energy/balance", payload, qos=1, retain=True)

Пример 7 — обнаружение событий питания

Цель: по каждому фронту DRDY сравнивать мгновенную P со скользящим средним (EMA) и добавлять значимые отклонения в ротируемый файл журнала. Аппаратура: любой SBC + rbAmp, DRDY на GPIO 15. Журналирование: стандартный модуль logging Python с RotatingFileHandler — сохраняется между перезагрузками, без драйвера SD-карты.

Python
#!/usr/bin/env python3
"""Power-event detection with rotating-file logging."""
import logging
import logging.handlers
import time
from threading import Event

from gpiozero import Button
from smbus2 import SMBus

from rbamp_io import RbAmpIO, REG_P0_REAL

I2C_BUS  = 1
RB_ADDR  = 0x50
PIN_DRDY = 15

EMA_ALPHA = 0.05
EVENT_THRESHOLD_W = 200.0
LOG_PATH = "/var/log/rbamp/events.log"   # ensure the directory exists and is writeable

# Configure a rotating logger — 5 files × 1 MB.
handler = logging.handlers.RotatingFileHandler(
    LOG_PATH, maxBytes=1_000_000, backupCount=5)
handler.setFormatter(logging.Formatter("%(asctime)s  %(message)s",
                                       "%Y-%m-%dT%H:%M:%S"))
log = logging.getLogger("rbamp.events")
log.addHandler(handler)
log.setLevel(logging.INFO)

# Wrap the bus in a context manager so the /dev/i2c-N fd is released cleanly
# on any unhandled exception.
with SMBus(I2C_BUS) as bus:
    meter = RbAmpIO(bus, RB_ADDR)
    meter.wait_ready()

    # Seed the EMA with current power so the very first sample does not look like an event.
    p_ema = meter.read_float_le(REG_P0_REAL)

    drdy = Button(PIN_DRDY, pull_up=True, bounce_time=None)
    data_ready = Event()
    drdy.when_pressed = data_ready.set

    print("Event detector started; log:", LOG_PATH)

    while True:
        if not data_ready.wait(timeout=1.0):
            continue
        data_ready.clear()

        p = meter.read_float_le(REG_P0_REAL)
        delta = p - p_ema
        p_ema = (1 - EMA_ALPHA) * p_ema + EMA_ALPHA * p

        if abs(delta) > EVENT_THRESHOLD_W:
            event_type = "TURN_ON" if delta > 0 else "TURN_OFF"
            line = f"{event_type}  delta={delta:+.1f}W  P={p:.1f}W  EMA={p_ema:.1f}W"
            print(line)
            log.info(line)                          # MUST be inside the `if` —
                                                    # otherwise NameError when
                                                    # delta is below threshold.
Примечание

Каталог должен существовать с нужными правами:

Bash
sudo mkdir -p /var/log/rbamp && sudo chown $USER /var/log/rbamp
Или запишите в~/.local/state/rbamp/events.logесли вы не хотите использовать пути, управляемые root.


Пример 8 — Публикатор MQTT с автообнаружением Home Assistant

Цель: готовая интеграция с HA. SBC публикует конфигурации HA Auto-discovery (с сохранением) и каждую минуту отправляет JSON-состояние. Аппаратура: любой SBC, один rbAmp UI1 и брокер MQTT.

Python
#!/usr/bin/env python3
"""rbAmp MQTT publisher with Home Assistant Auto-discovery."""
import json
import time

import paho.mqtt.client as mqtt
from smbus2 import SMBus

from rbamp_io import (
    RbAmpIO,
    REG_COMMAND, REG_PERIOD_VALID, REG_PERIOD_AVG_P0,
    REG_U_RMS, REG_I0_RMS, REG_PF0, REG_Q0, REG_AC_FREQ,
    CMD_LATCH_PERIOD,
)

I2C_BUS     = 1
RB_ADDR     = 0x50
DEVICE_ID   = "rbamp_main"
DEVICE_NAME = "Mains rbAmp"
MQTT_HOST   = "192.168.1.10"
MQTT_USER   = None     # set to a string to enable basic auth
MQTT_PASS   = None

DEVICE_BLOCK = {
    "identifiers":  [DEVICE_ID],
    "name":         DEVICE_NAME,
    "manufacturer": "rbAmp",
    "model":        "rbAmp UI*",
}


def publish_discovery_sensor(client: mqtt.Client, key: str, friendly: str,
                             unit: str | None, dev_class: str | None,
                             state_class: str) -> None:
    """Publish one HA discovery config (retained)."""
    cfg = {
        "name":            f"{DEVICE_NAME} {friendly}",
        "unique_id":       f"{DEVICE_ID}_{key}",
        "state_topic":     f"rbamp/{DEVICE_ID}/state",
        "value_template":  "{{ value_json." + key + " }}",
        "state_class":     state_class,
        "device":          DEVICE_BLOCK,
    }
    if unit:      cfg["unit_of_measurement"] = unit
    if dev_class: cfg["device_class"] = dev_class
    client.publish(f"homeassistant/sensor/{DEVICE_ID}/{key}/config",
                   json.dumps(cfg), qos=1, retain=True)


def publish_discovery_all(client: mqtt.Client) -> None:
    """Publish the full HA discovery set for one rbAmp module."""
    publish_discovery_sensor(client, "voltage",        "Voltage",        "V",   "voltage",        "measurement")
    publish_discovery_sensor(client, "current",        "Current",        "A",   "current",        "measurement")
    publish_discovery_sensor(client, "power",          "Power",          "W",   "power",          "measurement")
    publish_discovery_sensor(client, "energy",         "Energy",         "Wh",  "energy",         "total_increasing")
    publish_discovery_sensor(client, "frequency",      "Frequency",      "Hz",  "frequency",      "measurement")
    publish_discovery_sensor(client, "power_factor",   "Power Factor",   None,  "power_factor",   "measurement")
    publish_discovery_sensor(client, "apparent_power", "Apparent Power", "VA",  "apparent_power", "measurement")
    publish_discovery_sensor(client, "reactive_power", "Reactive Power", "var", "reactive_power", "measurement")


def on_connect(client, userdata, flags, rc, properties=None):
    """Republish discovery on every (re)connect — retained, so HA picks it up."""
    print(f"MQTT connected rc={rc}")
    publish_discovery_all(client)


client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION1,
                     client_id=DEVICE_ID, protocol=mqtt.MQTTv5)
if MQTT_USER:
    client.username_pw_set(MQTT_USER, MQTT_PASS)
client.on_connect = on_connect
try:
    client.connect(MQTT_HOST, 1883, keepalive=60)
except OSError as e:
    print(f"MQTT broker unreachable at boot ({e}); will retry in loop_start()")
client.loop_start()

with SMBus(I2C_BUS) as bus:
    meter = RbAmpIO(bus, RB_ADDR)
    meter.wait_ready()

    meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)        # primer
    t_prev = time.monotonic()
    total_wh = 0.0

    while True:
        time.sleep(60)

        meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)
        t_now = time.monotonic()
        time.sleep(0.05)

        if (meter.read_u8(REG_PERIOD_VALID) & 0x01) == 0:
            t_prev = time.monotonic()
            continue

        avg_p = meter.read_float_le(REG_PERIOD_AVG_P0)
        dt_s  = t_now - t_prev
        total_wh += avg_p * dt_s / 3600.0
        t_prev = t_now

        # Live RT values for the state payload.
        u  = meter.read_float_le(REG_U_RMS)
        i_ = meter.read_float_le(REG_I0_RMS)
        pf = meter.read_float_le(REG_PF0)
        q  = meter.read_float_le(REG_Q0)
        freq = meter.read_u8(REG_AC_FREQ)

        payload = json.dumps({
            "voltage":        round(u, 1),
            "current":        round(i_, 3),
            "power":          round(avg_p, 1),
            "energy":         round(total_wh, 3),
            "frequency":      int(freq),
            "power_factor":   round(pf, 3),
            "apparent_power": round(u * i_, 1),
            "reactive_power": round(q, 1),
        })
        client.publish(f"rbamp/{DEVICE_ID}/state", payload, qos=0, retain=False)
        print(f"Published: {payload}")

После первой публикации Home Assistant автоматически создаёт устройство Mains rbAmp с восемью датчиками, включая сущность Energy, которая сразу попадает на панель Energy [Energy dashboard].


Пример 9 — Демон systemd с сохранением в SQLite

Примечание

Этот пример заменяет «регистратор с батарейным глубоким сном» из глав о микроконтроллерах. На Linux SBC работает постоянно, поэтому правильный шаблон — демон под управлением systemd с автоперезапуском при сбое и небольшой базой SQLite для сохранения данных между отключениями питания.

Цель: долгоживущий демон, который делает снимок периода каждую минуту, записывает результат в SQLite и публикует состояние в MQTT. Процесс корректно перезапускается после перезагрузки, подхватывая накопленный итог из базы данных. Аппаратура: любой SBC и один rbAmp UI1.

Демон (rbamp_daemon.py)

Python
#!/usr/bin/env python3
"""rbAmp daemon — periodic snapshot + SQLite persistence + MQTT."""
import json
import logging
import signal
import sqlite3
import sys
import time
from contextlib import closing

import paho.mqtt.client as mqtt
from smbus2 import SMBus

from rbamp_io import (
    RbAmpIO, REG_COMMAND, REG_PERIOD_VALID,
    REG_PERIOD_AVG_P0, CMD_LATCH_PERIOD,
)

# ----- Configuration -----
I2C_BUS    = 1
RB_ADDR    = 0x50
DB_PATH    = "/var/lib/rbamp/energy.db"
MQTT_HOST  = "192.168.1.10"
PERIOD_S   = 60

# ----- Logging -----
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s  %(levelname)s  %(message)s",
    stream=sys.stdout,                          # systemd captures stdout into the journal
)
log = logging.getLogger("rbamp.daemon")


# ----- SQLite persistence -----

def db_init(conn: sqlite3.Connection) -> None:
    """Create the schema if it does not exist."""
    conn.executescript("""
        CREATE TABLE IF NOT EXISTS energy_state (
            id          INTEGER PRIMARY KEY CHECK (id = 1),
            total_wh    REAL NOT NULL DEFAULT 0
        );
        INSERT OR IGNORE INTO energy_state(id, total_wh) VALUES (1, 0);

        CREATE TABLE IF NOT EXISTS energy_log (
            ts          INTEGER NOT NULL,
            dt_s        REAL    NOT NULL,
            avg_p_w     REAL    NOT NULL,
            e_wh        REAL    NOT NULL,
            total_wh    REAL    NOT NULL
        );
        CREATE INDEX IF NOT EXISTS idx_energy_log_ts ON energy_log(ts);
    """)
    conn.commit()


def db_load_total(conn: sqlite3.Connection) -> float:
    """Return the accumulated total_wh persisted across restarts."""
    row = conn.execute("SELECT total_wh FROM energy_state WHERE id = 1").fetchone()
    return float(row[0]) if row else 0.0


def db_record(conn: sqlite3.Connection, dt_s: float, avg_p: float,
              e_wh: float, total: float) -> None:
    """Append one period sample and update the running total atomically."""
    with conn:                                  # implicit BEGIN/COMMIT
        conn.execute("UPDATE energy_state SET total_wh = ? WHERE id = 1", (total,))
        conn.execute(
            "INSERT INTO energy_log(ts, dt_s, avg_p_w, e_wh, total_wh) "
            "VALUES (?, ?, ?, ?, ?)",
            (int(time.time()), dt_s, avg_p, e_wh, total),
        )


# ----- Signal handling for clean shutdown -----

_running = True

def _shutdown(signum, frame):
    """Handle SIGTERM (systemd stop) / SIGINT (Ctrl-C) gracefully."""
    global _running
    log.info("Shutdown signal %d received", signum)
    _running = False

signal.signal(signal.SIGTERM, _shutdown)
signal.signal(signal.SIGINT,  _shutdown)


# ----- Main -----

def main() -> int:
    client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION1, client_id="rbamp-daemon")
    try:
        client.connect(MQTT_HOST, 1883, keepalive=60)
    except OSError as e:
        log.warning("MQTT broker unreachable at boot (%s); paho will retry", e)
    client.loop_start()                        # paho's thread reconnects automatically

    with SMBus(I2C_BUS) as bus, closing(sqlite3.connect(DB_PATH)) as conn:
        db_init(conn)
        total_wh = db_load_total(conn)
        log.info("Resumed total_wh = %.3f Wh", total_wh)

        meter = RbAmpIO(bus, RB_ADDR)
        meter.wait_ready()

        meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)    # primer
        t_prev = time.monotonic()

        while _running:
            # Sleep in 1-second slices so we can respond to SIGTERM quickly.
            for _ in range(PERIOD_S):
                if not _running:
                    break
                time.sleep(1)
            if not _running:
                break

            meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)
            t_now = time.monotonic()
            time.sleep(0.05)

            if (meter.read_u8(REG_PERIOD_VALID) & 0x01) == 0:
                log.warning("Stale snapshot — skipping")
                t_prev = time.monotonic()
                continue

            avg_p = meter.read_float_le(REG_PERIOD_AVG_P0)
            dt_s  = t_now - t_prev
            e_wh  = avg_p * dt_s / 3600.0
            total_wh += e_wh
            t_prev = t_now

            db_record(conn, dt_s, avg_p, e_wh, total_wh)
            client.publish("rbamp/daemon/state",
                           json.dumps({
                               "dt_s": round(dt_s, 1),
                               "avg_p": round(avg_p, 1),
                               "energy_wh": round(total_wh, 3),
                           }),
                           qos=1, retain=True)
            log.info("avg_P=%+.1f W  E_period=%.3f Wh  total=%.3f Wh",
                     avg_p, e_wh, total_wh)

    log.info("Daemon stopped cleanly; total_wh = %.3f Wh", total_wh)
    client.loop_stop()
    client.disconnect()
    return 0


if __name__ == "__main__":
    sys.exit(main())

Юнит systemd (/etc/systemd/system/rbamp.service)

INI
[Unit]
Description=rbAmp energy daemon
After=network-online.target time-sync.target
Wants=network-online.target time-sync.target

[Service]
Type=simple
ExecStart=/home/pi/venv-rbamp/bin/python /opt/rbamp/rbamp_daemon.py
User=pi
Group=i2c
Restart=on-failure
RestartSec=5
# Pre-create the persistence directory so the daemon never sees ENOENT.
RuntimeDirectoryMode=0755
StateDirectory=rbamp
StateDirectoryMode=0755

[Install]
WantedBy=multi-user.target

Включить и запустить:

Bash
sudo systemctl daemon-reload
sudo systemctl enable --now rbamp.service
journalctl -fu rbamp.service                    # follow the log

Демон:

  • Перезапуск при сбое (Restart=on-failure).
  • Запускается после сети и синхронизации часов (After=network-online.target time-sync.target).
  • Переживает перезагрузки. База SQLite в /var/lib/rbamp/energy.db сохраняет текущий итог.
  • Реагирует на systemctl stop rbamp: перехватывает SIGTERM и записывает финальную запись состояния.

Это аналог на SBC для схемы «глубокий сон + сохраняемая память RTC»: вместо экономии мкА мы опираемся на ОС, которая держит нас в работе, и на батарейные часы RTC, которые ведут время.


Пример 10 — Тарификация по времени суток (TOU) с системными часами

Цель: учёт энергии по тарифному расписанию с разделением по времени суток. SBC использует системные часы (уже синхронизированные systemd-timesyncd), код SNTP не нужен. Аппаратура: любой SBC и один rbAmp UI1.

Python
#!/usr/bin/env python3
"""TOU tariff metering using the Linux system clock."""
import json
import time
from datetime import datetime, timezone
from zoneinfo import ZoneInfo               # stdlib since Python 3.9

import paho.mqtt.client as mqtt
from smbus2 import SMBus

from rbamp_io import (
    RbAmpIO, REG_COMMAND, REG_PERIOD_VALID, REG_PERIOD_AVG_P0,
    CMD_LATCH_PERIOD,
)

I2C_BUS   = 1
RB_ADDR   = 0x50
MQTT_HOST = "192.168.1.10"

# IANA timezone name — Python's stdlib handles DST automatically.
TZ = ZoneInfo("Europe/Berlin")
PEAK_START_HOUR = 8        # inclusive
PEAK_END_HOUR   = 22       # exclusive


def is_peak_hour(hour: int) -> bool:
    """Return True if `hour` (local) falls inside the peak window.

    For schedules that span midnight (peak = 22..6), change to
    ``return hour >= PEAK_START_HOUR or hour < PEAK_END_HOUR``.
    """
    return PEAK_START_HOUR <= hour < PEAK_END_HOUR


client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION1, client_id="rbamp-tou")
try:
    client.connect(MQTT_HOST, 1883, keepalive=60)
except OSError as e:
    print(f"MQTT broker unreachable at boot ({e}); will retry in loop_start()")
client.loop_start()

# Tariff buckets.
today = {"peak_wh": 0.0, "off_peak_wh": 0.0, "yday": -1}
lifetime = {"peak_wh": 0.0, "off_peak_wh": 0.0}


def accumulate(e_wh: float, now_local: datetime) -> None:
    """Add this period's energy to the right bucket and roll the day at midnight."""
    yday = now_local.timetuple().tm_yday
    if today["yday"] != yday:
        if today["yday"] >= 0:
            payload = json.dumps({
                "yday":        today["yday"],
                "peak_wh":     round(today["peak_wh"], 3),
                "off_peak_wh": round(today["off_peak_wh"], 3),
                "total_wh":    round(today["peak_wh"] + today["off_peak_wh"], 3),
            })
            client.publish("rbamp/tou/day_close", payload, qos=1, retain=True)
            print("Day closed:", payload)
        today["peak_wh"] = 0.0
        today["off_peak_wh"] = 0.0
        today["yday"] = yday

    if is_peak_hour(now_local.hour):
        today["peak_wh"]    += e_wh
        lifetime["peak_wh"] += e_wh
    else:
        today["off_peak_wh"]    += e_wh
        lifetime["off_peak_wh"] += e_wh


with SMBus(I2C_BUS) as bus:
    meter = RbAmpIO(bus, RB_ADDR)
    meter.wait_ready()
    meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)        # primer
    t_prev = time.monotonic()
    print(f"TOU started: peak {PEAK_START_HOUR:02d}:00..{PEAK_END_HOUR:02d}:00 local")

    while True:
        time.sleep(60)

        meter.write_u8(REG_COMMAND, CMD_LATCH_PERIOD)
        t_now = time.monotonic()
        time.sleep(0.05)

        if (meter.read_u8(REG_PERIOD_VALID) & 0x01) == 0:
            t_prev = time.monotonic()
            continue

        avg_p = meter.read_float_le(REG_PERIOD_AVG_P0)
        dt_s  = t_now - t_prev
        e_wh  = avg_p * dt_s / 3600.0
        t_prev = t_now

        # The Linux system clock is already authoritative — no SNTP code required.
        now_local = datetime.now(TZ)
        accumulate(e_wh, now_local)
        peak = is_peak_hour(now_local.hour)

        payload = json.dumps({
            "ts":                now_local.isoformat(timespec="seconds"),
            "tariff":            "peak" if peak else "off_peak",
            "avg_p":             round(avg_p, 1),
            "period_wh":         round(e_wh, 4),
            "today_peak_wh":     round(today["peak_wh"], 3),
            "today_off_peak_wh": round(today["off_peak_wh"], 3),
            "life_peak_wh":      round(lifetime["peak_wh"], 3),
            "life_off_peak_wh":  round(lifetime["off_peak_wh"], 3),
        })
        client.publish("rbamp/tou/state", payload, qos=0, retain=False)
        print(payload)

Notes:

  • zoneinfo — современный API часовых поясов стандартной библиотеки Python 3.9+. В Debian / Raspberry Pi OS данные IANA берутся из системного пакета tzdata, переходы на летнее время обрабатываются корректно.
  • Для более старых версий Python (3.8 и ранее) используйте pytz: import pytz; TZ = pytz.timezone("Europe/Berlin").
  • Метки времени ISO 8601 со смещением формирует datetime.isoformat(timespec="seconds"), например 2026-05-22T18:30:00+02:00.
  • Для двунаправленного учёта STD вызовите accumulate() дважды: один раз для потребления и один раз для выдачи, и публикуйте пиковую и внепиковую корзины.

Сравнение примеров

# Сложность Выход MQTT DRDY Несколько модулей Двунаправленный Сохранение Сценарий использования
1 минимальный Консоль — — — — — проверка работоспособности
2 низкий OLED — — — — RAM счётчик в корпусе
3 низкий Консоль — — да (3) — — домашний мониторинг
4 средний — да — — — RAM по каждому прибору в HA
5 средний Консоль — да — да (мастер) RAM солнечный дом на уровне BASIC
6 высокий — да — да (3) да RAM + MQTT (retained) полный баланс дома
7 средний Ротируемый файл журнала — да — — файловая система обнаружение событий
8 средний — да (+disco) — — необязательно RAM + MQTT HA Auto-discovery
9 средний journald + SQLite да — — — SQLite боевой демон
10 средний Консоль да — — необязательно RAM + MQTT (закрытие дня) TOU: пиковый / внепиковый тариф

Рекомендации

  • Запускайте скрипты от непривилегированного пользователя, входящего в группы i2c и gpio. Не используйте sudo python ...: это засоряет пути и ломает установку pip --user.
  • Используйте виртуальное окружение (python3 -m venv ...) вместо установки пакетов через sudo pip в систему.
  • Всегда перехватывайте OSError вокруг чтений I²C — кратковременный NACK или временно отключённое ведомое устройство проявляется как OSError(EREMOTEIO). Производственный код повторяет попытку; тестовый код намеренно падает, чтобы сбой был заметен.
  • Используйте time.monotonic() для главных часов. Это не зависит от того, что systemd-timesyncd сдвигает системные часы (например, при первой синхронизации после загрузки). Используйте time.time() / datetime только для меток времени.
  • PERIOD_VALID (0x07) нужно проверять после каждого CMD_LATCH_PERIOD. То же правило, что и на микроконтроллере — Linux не меняет протокол rbAmp.
  • Подождите ≥ 50 мс после снимка (time.sleep(0.05)), прежде чем читать 0xDC..0xEF.
  • Для систем из нескольких модулей broadcast_latch(bus, tick) через общий вызов обеспечивает точную синхронизацию. Приём GC включается по выбору для каждого модуля (FLEET_CONFIG.bit0, по умолчанию выключен). При NACK переходите к поочерёдной отправке CMD_LATCH_PERIOD каждому модулю.
  • Сохраняйте итоги в файловой системе: JSON, SQLite, InfluxDB. Файловая система на SBC заменяет «регистры резервной области RTC + NVM». Это дёшево и надёжно.
  • Оберните основной цикл обработчиками сигналов (SIGTERM, SIGINT), чтобы systemctl stop корректно останавливал демон с финальной записью состояния.
  • Выводите в stdout/stderr в демонах — journald захватывает это автоматически; вы получаете ротацию, фильтрацию и journalctl -u rbamp без дополнительных усилий.

Что дальше

После изучения этих десяти примеров: