Примеры
Эта глава описывает 11 сценариев (10 в таблице ниже и Сценарий 11) — от минимального «hello world» до продуктивного развёртывания. У большинства сценариев есть параллельные реализации на MicroPython (в examples_upy/) и CPython (в examples_cpython/). Код ниже — выжимка ключевой логики, а не полный скрипт; полные версии — в соответствующих файлах примеров.
| # | Сценарий | MicroPython | CPython |
|---|---|---|---|
| 1 | Быстрое чтение | 01_quick_read.py |
01_quick_read.py |
| 2 | Периодический счётчик + локальный дисплей | 02_oled_period.py |
02_period_meter.py |
| 3 | Мониторинг 3 модулей на одной шине | 03_multi_module.py |
03_multi_module_broadcast.py |
| 4 | UI3 + MQTT по каналам | 04_mqtt.py |
04_mqtt_publisher.py |
| 5 | Двунаправленный учёт на стороне мастера | 07_bidirectional_energy.py |
05_bidirectional_energy.py |
| 6 | Баланс энергии всего дома (несколько модулей + MQTT) | 08_home_energy_balance.py |
07_home_energy_balance.py |
| 7 | Журнал обнаружения событий (EMA) | 09_event_detection_logger.py |
нет файла |
| 8 | Локальный ротируемый регистратор | нет файла | 08_rotating_file_logger.py |
| 9 | Батарейный регистратор с глубоким сном | 06_deep_sleep.py |
(не применимо) |
| 10 | Асинхронная потоковая передача через stream_period |
05_async_streaming.py |
файла нет (код в сценарии 10) |
Все сценарии предполагают, что класс датчика и модель CT уже заданы через dev.set_sensor_class() + dev.set_ct_model() (см. 05 · Quickstart, шаг 4). Это делается один раз при установке — настройки сохраняются во flash модуля и переживают сброс.
Сценарий 1 — Быстрое чтение
Цель: печатать U / I / P / PF / частоту раз в секунду. Тот же «hello world», что в 05 · Quickstart, но с dev.read_all() — однократным чтением всего RT-блока в одну структуру RbAmpSnapshot.
Версия CPython
import time
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpError
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
while True:
try:
s = dev.read_all()
except RbAmpError as e:
print("read fail:", e)
time.sleep(1)
continue
line = f"U={s.voltage:.1f} V f={s.frequency} Hz "
for ch in range(s.channels):
line += f"I{ch}={s.current[ch]:.2f}A P{ch}={s.power[ch]:.1f}W "
print(line)
time.sleep(1)
MicroPython, версия
import time
from machine import I2C, Pin
from rbamp import RbAmp, RbAmpError
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)
with RbAmp(i2c, 0x50) as dev:
while True:
try:
s = dev.read_all()
except RbAmpError as e:
print("read fail:", e)
time.sleep(1)
continue
print("U={:.1f} V f={} Hz".format(s.voltage, s.frequency))
for ch in range(s.channels):
print(" I{}={:.2f}A P{}={:.1f}W".format(
ch, s.current[ch], ch, s.power[ch]))
time.sleep(1)
Что происходит на шине: dev.read_all() на UI3 выполняет примерно 53 транзакции по байтам (13 значений float × 4 байта + 1 байт частоты). При 50 кГц с запасом на повторы это порядка 25–30 мс. Если нужны не все значения, используйте поштучные аксессоры (dev.voltage, dev.read_current(ch)).
Сценарий 2 — периодический счётчик с локальным дисплеем
Цель: счётчик Wh, обновляемый раз в минуту, на локальном дисплее. На MicroPython — OLED SSD1306 на той же шине I²C. На CPython — текстовый вывод в stdout (можно подключить символьный LCD через GPIO или веб-страницу — см. Сценарий 6).
Версия MicroPython (OLED SSD1306)
import time
from machine import I2C, Pin
from ssd1306 import SSD1306_I2C
from rbamp import RbAmp, RbAmpStaleError, RbAmpSensorClass
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)
oled = SSD1306_I2C(128, 64, i2c) # OLED on the same bus, addr 0x3C
with RbAmp(i2c, 0x50) as dev:
snapshots_ok = 0
snapshots_bad = 0
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
snapshots_ok += 1
except RbAmpStaleError:
snapshots_bad += 1
continue
oled.fill(0)
oled.text("rbAmp Energy Meter", 0, 0)
oled.text("{:.1f} W".format(snap.avg_p[0]), 0, 16, 1)
oled.text("Wh: {:.4f}".format(dev.energy.wh(0)), 0, 32)
oled.text("ok={} bad={}".format(snapshots_ok, snapshots_bad), 0, 48)
oled.show()
Версия CPython (измеритель периода, без дисплея)
import time
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpStaleError
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
snapshots_ok = 0
snapshots_bad = 0
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
snapshots_ok += 1
except RbAmpStaleError:
snapshots_bad += 1
print("stale snapshot — skipping")
continue
print(f"P = {snap.avg_p[0]:.2f} W "
f"Wh = {dev.energy.wh(0):.4f} "
f"ok={snapshots_ok} bad={snapshots_bad} "
f"dt={snap.master_dt_ms} ms")
Обработка устаревших снимков. dev.read_period_snapshot() выбрасывает RbAmpStaleError, если модуль не успел подготовить новый снимок к моменту чтения. Пакет сохраняет предыдущую метку времени, поэтому следующий успешный снимок покрывает весь интервал, и Wh остаётся точным. Обычный шаблон try/except в Python.
Сценарий 3 — мониторинг 3 модулей на одной шине
Цель: опросить 3 модуля по адресам 0x50 / 0x51 / 0x52 и снять снимок согласованно, чтобы их мощности по каналам суммировались в одном периоде сети.
один кадр General-Call (A5 27 ) заставляет каждый модуль, подключённый через fleet.enable_gc_all(), сделать свой снимок — рассинхронизация флота < 10 мкс, поэтому итоги складываются. fleet.gc_latch() отправляет кадр и возвращает широковещательный tick; fleet.check_sync() читает обратно засвидетельствованный tick каждого модуля, чтобы отметить тот, что пропустил кадр. (На прошивке v1.0/v1.1 General-Call был недоступен, и этот сценарий переходил на последовательные снимки по устройствам.) См. 09 · API Reference для RbAmpFleet.
Версия CPython
import time
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpFleet, RbAmpError, RbAmpStaleError
ADDRS = [0x50, 0x51, 0x52]
GC_GROUP = 0
with SMBus(1) as bus:
fleet = RbAmpFleet(bus)
for addr in ADDRS:
try:
dev = RbAmp(bus, addr); dev.begin()
except RbAmpError as exc:
print(f"skip 0x{addr:02X}: {exc}"); continue
fleet.add(dev)
# one-time: persist the General-Call snapshot opt-in on every module
fleet.enable_gc_all(group=GC_GROUP)
while True:
time.sleep(60)
tick = fleet.gc_latch(group=GC_GROUP) # one all-call frame snapshots the bus
time.sleep(0.050) # single shared settle
sync = fleet.check_sync(expected_tick=tick)
for dev, s in zip(fleet, sync):
if not s.in_sync: # this module missed the frame
print(f" 0x{s.addr:02X} MISSED tick 0x{tick:04X}")
continue
try:
snap = dev.read_period_snapshot(settle_ms=0, skip_latch=True)
except RbAmpStaleError:
continue
print(f" 0x{dev.address:02X} P={snap.avg_p[0]:.0f} W "
f"Wh={dev.energy.wh(0):.3f}")
print(f" fleet ΣWh={fleet.total_energy_wh():.3f} "
f"in_sync={sum(s.in_sync for s in sync)}/{len(sync)}")
MicroPython, версия
import time
from machine import I2C, Pin
from rbamp import RbAmp, RbAmpFleet, RbAmpError, RbAmpStaleError
ADDRS = [0x50, 0x51, 0x52]
GC_GROUP = 0
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)
fleet = RbAmpFleet(i2c)
for addr in ADDRS:
try:
dev = RbAmp(i2c, addr); dev.begin()
except RbAmpError as exc:
print("skip 0x{:02X}:".format(addr), exc); continue
fleet.add(dev)
fleet.enable_gc_all(group=GC_GROUP) # one-time, persisted
while True:
time.sleep(60)
tick = fleet.gc_latch(group=GC_GROUP) # one all-call frame
time.sleep_ms(50) # single shared settle
sync = fleet.check_sync(expected_tick=tick)
for dev, s in zip(fleet, sync):
if not s.in_sync:
print(" 0x{:02X} MISSED tick".format(s.addr))
continue
try:
snap = dev.read_period_snapshot(settle_ms=0, skip_latch=True)
except RbAmpStaleError:
continue
print(" 0x{:02X} P={:.0f} W Wh={:.3f}".format(
dev.address, snap.avg_p[0], dev.energy.wh(0)))
Сценарий 4 — UI3 + MQTT по каналам
Цель: модуль UI3 с 3 токовыми клещами на трёх независимых линиях. Поканальные счётчики Wh, публикуемые в MQTT раз в минуту. Показывает, что dev.energy.wh(ch) работает по каждому каналу независимо — не нужен ручной массив total_wh[3] на стороне мастера.
CPython (через paho-mqtt; установка: pip install paho-mqtt)
import time, json
from smbus2 import SMBus
import paho.mqtt.client as mqtt_client
from rbamp import RbAmp, RbAmpStaleError, RbAmpSensorClass
CH_NAMES = ["main", "heatpump", "lights"]
mqtt = mqtt_client.Client(mqtt_client.CallbackAPIVersion.VERSION2, "rbamp-ui3")
mqtt.connect("192.168.1.10", 1883, keepalive=60)
mqtt.loop_start()
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
continue
for ch in range(dev.channels):
payload = json.dumps({
"power": round(snap.avg_p[ch], 1),
"energy": round(dev.energy.wh(ch), 4),
})
mqtt.publish(f"rbamp/{CH_NAMES[ch]}/state",
payload, qos=1, retain=True)
MicroPython (через umqtt.simple)
import time, ujson
from machine import I2C, Pin
from umqtt.simple import MQTTClient
from rbamp import RbAmp, RbAmpStaleError, RbAmpSensorClass
CH_NAMES = [b"main", b"heatpump", b"lights"]
mqtt = MQTTClient(b"rbamp-ui3", b"192.168.1.10",
port=1883, keepalive=60)
mqtt.connect()
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)
with RbAmp(i2c, 0x50) as dev:
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
continue
for ch in range(dev.channels):
payload = ujson.dumps({
"power": round(snap.avg_p[ch], 1),
"energy": round(dev.energy.wh(ch), 4),
})
topic = b"rbamp/" + CH_NAMES[ch] + b"/state"
mqtt.publish(topic, payload.encode(), qos=1, retain=True)
На MicroPython umqtt.simple — синхронный блокирующий клиент. Для асинхронного варианта используйте mqtt_as (асинхронный MQTT-клиент на asyncio) — см. также сценарий 10.
Для полного автообнаружения HA поверх этого шаблона см. 07 · DIY integrations.
Сценарий 5 — двунаправленный учёт на стороне мастера
Цель: разделить знаковую мгновенную мощность на валовое потребление и валовый экспорт. Используйте этот шаблон на линейке модулей BASIC, где прошивка обрезает отрицательные значения в snap.avg_p[ch] (усреднённая за период мощность) — снимайте dev.read_power(0) (мгновенная мощность, знаковая на всех линейках модулей) с 10 Гц на стороне мастера и распределяйте значения по корзинам самостоятельно.
Версия CPython
import time
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpIOError
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
consume_wh = 0.0
export_wh = 0.0
t_prev = time.monotonic()
last_print = t_prev
while True:
time.sleep(0.1) # 10 Hz, matches the RT cadence
t_now = time.monotonic()
dt_s = t_now - t_prev
t_prev = t_now
try:
p = dev.read_power(0)
except RbAmpIOError:
continue
dwh = p * dt_s / 3600.0
if p >= 0:
consume_wh += dwh
else:
export_wh += -dwh
# Print once per second
if t_now - last_print >= 1.0:
last_print = t_now
print(f"P={p:.1f} W "
f"cons={consume_wh:.4f} Wh exp={export_wh:.4f} Wh "
f"net={consume_wh - export_wh:.4f} Wh")
MicroPython, версия
import time
from machine import I2C, Pin
from rbamp import RbAmp, RbAmpIOError
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)
with RbAmp(i2c, 0x50) as dev:
consume_wh = 0.0
export_wh = 0.0
t_prev = time.ticks_ms()
while True:
time.sleep_ms(100)
t_now = time.ticks_ms()
dt_s = time.ticks_diff(t_now, t_prev) / 1000
t_prev = t_now
try:
p = dev.read_power(0)
except RbAmpIOError:
continue
dwh = p * dt_s / 3600.0
if p >= 0:
consume_wh += dwh
else:
export_wh += -dwh
На STANDARD (STD) модуле вызовы периодов работают без изменений, а энергия нетто (экспорт вычитается); собственные счётчики импорта и экспорта модуля находятся в read_std_energy() (сценарий 11). Такое разделение на стороне мастера нужно только на модулях BASIC для раздельного отчёта валового потребления и валового экспорта.
Сценарий 6 — баланс энергии всего дома
Цель: 3 модуля — сеть (двунаправленный), солнечная панель (только генерация), нагрузки (UI3 для каждого прибора). Сводная панель публикуется раз в минуту.
(Нужен pip install paho-mqtt.)
import time, json
from smbus2 import SMBus
import paho.mqtt.client as mqtt_client
from rbamp import (RbAmp, RbAmpFleet, RbAmpError,
RbAmpStaleError, RbAmpSensorClass)
GC_GROUP = 0
with SMBus(1) as bus:
mains = RbAmp(bus, 0x50) # bidirectional mains
solar = RbAmp(bus, 0x51) # generation only
loads = RbAmp(bus, 0x52) # UI3 — per-appliance
devs = [mains, solar, loads]
for d in devs:
d.begin()
fleet = RbAmpFleet(bus)
for d in devs:
fleet.add(d)
fleet.enable_gc_all(group=GC_GROUP) # one-time, persisted
mqtt = mqtt_client.Client(mqtt_client.CallbackAPIVersion.VERSION2, "home-balance")
mqtt.connect("192.168.1.10", 1883, keepalive=60)
mqtt.loop_start()
while True:
time.sleep(60)
# One coherent all-call snapshot for the whole bus (see Scenario 3)
tick = fleet.gc_latch(group=GC_GROUP)
time.sleep(0.050) # single shared settle
sync = fleet.check_sync(expected_tick=tick)
try:
sm = mains.read_period_snapshot(settle_ms=0, skip_latch=True)
ss = solar.read_period_snapshot(settle_ms=0, skip_latch=True)
sl = loads.read_period_snapshot(settle_ms=0, skip_latch=True)
except RbAmpStaleError:
continue
payload = {
"mains": round(mains.energy.wh(0), 3),
"solar": round(solar.energy.wh(0), 3),
"hp": round(loads.energy.wh(0), 3),
"ac": round(loads.energy.wh(1), 3),
"ev": round(loads.energy.wh(2), 3),
}
mqtt.publish("home/energy/balance",
json.dumps(payload), qos=1, retain=True)
# let a dashboard alarm on a partial fleet (a module that missed the frame)
in_sync = sum(s.in_sync for s in sync)
mqtt.publish("home/energy/sync/in_sync",
f"{in_sync}/{len(sync)}", qos=1, retain=True)
На модулях BASIC экспорт не учитывается в energy.wh(), поэтому показатели solar и mains выше — только потребление. Для явного разделения на валовое потребление / валовый экспорт на сети совместите это с шаблоном Сценария 5 (отдельный цикл 10 Гц по mains.read_power(0) в фоновом threading.Thread на CPython или uasyncio.create_task на MicroPython).
Сценарий 7 — журнал событий обнаружения (EMA)
Цель: на каждом окне RT 100 мс сравнивать мгновенную мощность с экспоненциальной скользящей средней. Записывать значимые отклонения — нагрузки вроде микроволновки, чайника или фена «появляются» в журнале как события включения / выключения.
import time
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpIOError
EMA_ALPHA = 0.05
EVENT_THRESHOLD_W = 200.0
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
try:
p_ema = dev.read_power(0) # seed so the first read isn't an event
except RbAmpIOError:
p_ema = 0.0
while True:
time.sleep(0.1)
try:
p = dev.read_power(0)
except RbAmpIOError:
continue
delta = p - p_ema
p_ema = (1 - EMA_ALPHA) * p_ema + EMA_ALPHA * p
if abs(delta) > EVENT_THRESHOLD_W:
action = "TURN_ON" if delta > 0 else "TURN_OFF"
print(f"{time.time():.0f} {action} delta={delta:.0f} W "
f"P={p:.0f} W EMA={p_ema:.0f}")
На MicroPython примените те же замены: time.sleep → time.sleep_ms, а time.time() → time.time() (есть на большинстве портов) или time.ticks_ms().
Совместите это с публикацией MQTT из сценария 4 для автоматизаций на стороне HA.
Сценарий 8 — локальный логгер с ротацией (CPython)
Цель: записывать снимок периода в ротируемый CSV-файл раз в минуту через стандартный logging.handlers.RotatingFileHandler. Полезно для автономных развёртываний без WiFi / MQTT или как буфер для отложенной синхронизации с облаком.
import time, logging
from logging.handlers import RotatingFileHandler
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpStaleError
log = logging.getLogger("rbamp.csv")
log.setLevel(logging.INFO)
handler = RotatingFileHandler("rbamp.csv", maxBytes=1_000_000, backupCount=5)
handler.setFormatter(logging.Formatter("%(asctime)s,%(message)s",
datefmt="%Y-%m-%dT%H:%M:%S"))
log.addHandler(handler)
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
log.warning("stale")
continue
log.info(f"{snap.avg_p[0]:.1f},{dev.energy.wh(0):.4f},"
f"{snap.master_dt_ms}")
На MicroPython стандартный модуль logging.handlers недоступен — для локального лога используйте простой with open("log.csv", "a") и ручную ротацию через os.stat() + os.rename(). Полный пример — в examples_upy/09_event_detection_logger.py.
Для отложенной синхронизации с облаком (локальный лог, отправка раз в час) см. раздел «Hybrid: local storage + sync» в 08 · Cloud integrations.
Сценарий 9 — батарейный логгер с deep sleep (только MicroPython)
Цель: ESP32 (MicroPython) просыпается раз в 10 минут, делает один снимок периода, публикует через WiFi+MQTT и возвращается в deep sleep. Энергия сохраняется между циклами сна в RTC-памяти.
⚠ Важное замечание о глубоком сне и прошивке v1.0/v1.1. На текущей прошивке dev.begin() выполняет праймер CMD_LATCH_PERIOD, который сбрасывает накопитель периода прошивки. Поэтому после пробуждения из глубокого сна нельзя просто вызвать read_period_snapshot() по умолчанию — этот вызов снимет ещё один снимок и вернёт почти нулевые данные, охватывающие лишь ~50 мс после праймера. Правильный шаблон ниже использует skip_latch=True, чтобы считать данные, накопленные за интервал сна, и известную длительность сна (machine.deepsleep(SLEEP_MS)) как dt — time.ticks_ms() после пробуждения может быть ненадёжным источником.
import time, machine
from machine import I2C, Pin
from rbamp import RbAmp, RbAmpSensorClass
# Publishing stub. Replace with real WiFi+MQTT logic —
# see Scenario 4 (mqtt_publisher) for a template. In a deep-sleep
# scenario, the WiFi stack is brought up/torn down on every wake,
# which eats up the bulk of the energy budget.
def publish_via_wifi(power_w, total_wh, dt_s):
print("P=%.1f W Wh=%.4f dt=%.1f s" % (power_w, total_wh, dt_s))
SLEEP_MS = 10 * 60 * 1000 # 10 minutes — fixed interval
RTC_MAGIC = b"\xCA\xFE\xFE\xED"
# RTC slow memory: persisted across deep-sleep wakes
rtc = machine.RTC()
state = rtc.memory() # bytes; empty on cold boot
def save_state(magic, wh_total, primer_done):
# Simple layout: 4 bytes magic + 8 bytes float wh + 1 byte primer_done
import struct
rtc.memory(magic + struct.pack("dB", wh_total, 1 if primer_done else 0))
def load_state():
import struct
if len(state) < 4 + 8 + 1 or state[:4] != RTC_MAGIC:
return False, 0.0, False
wh_total, primer_done_byte = struct.unpack("dB", state[4:4+9])
return True, wh_total, bool(primer_done_byte)
valid, rtc_total_wh, primer_done = load_state()
if not valid:
rtc_total_wh = 0.0
primer_done = False
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)
with RbAmp(i2c, 0x50) as dev: # __enter__ automatically calls begin() — the snapshot primer
dev.energy.disable() # the master owns Wh persistence itself
if not primer_done:
# First wake: the primer snapshot just discarded the "dirty" data.
# Save the flag and go straight back to sleep — the next wake,
# SLEEP_MS later, will get a full accumulator for the interval.
save_state(RTC_MAGIC, rtc_total_wh, primer_done=True)
machine.deepsleep(SLEEP_MS)
# skip_latch=True reads what the begin() primer snapshot captured —
# i.e. the accumulator for the elapsed sleep interval.
snap = dev.read_period_snapshot(settle_ms=0, skip_latch=True)
# Use the KNOWN sleep duration as dt
dt_s = SLEEP_MS / 1000
rtc_total_wh += snap.avg_p[0] * dt_s / 3600.0
publish_via_wifi(snap.avg_p[0], rtc_total_wh, dt_s) # stub
save_state(RTC_MAGIC, rtc_total_wh, primer_done=True)
machine.deepsleep(SLEEP_MS)
Полный скетч (с настройкой WiFi, публикацией MQTT, защитой RTC-маркером) — в examples_upy/06_deep_sleep.py.
Бюджет энергии (ESP32-WROOM на Li-ion 2000 мАч, интервал 10 минут):
- Активный цикл: ~3 с (WiFi + MQTT + I²C) при ~80 мА → ~0.07 мАч на пробуждение
- Сон: ~10 µA (RTC + сохраняемые домены)
- ~10 мАч в сутки → 2000 мАч хватает примерно на 6 месяцев
Хосты CPython (Raspberry Pi и т. п.) обычно работают 24/7 от блока питания — глубокий сон к ним не применим. Для батарейной работы CPython см. раздел об энергопотреблении и suspend через systemd в 08 · Облачные интеграции.
Сценарий 10 — асинхронная потоковая передача через stream_period (функция только для Python)
Цель: встроить в существующий цикл событий asyncio / uasyncio. Пакет даёт асинхронный генератор dev.stream_period(interval_s=...), который инкапсулирует периодический снимок и автоматическую обработку устаревших.
CPython (через asyncio + paho-mqtt-asyncio, или плоско)
import asyncio
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpSensorClass
async def main():
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
# Once per minute, skip_stale=True (default) — stale snapshots are
# automatically skipped without raising RbAmpStaleError
async for snap in dev.stream_period(interval_s=60.0):
print(f"P={snap.avg_p[0]:.2f} W, Wh={dev.energy.wh(0):.4f}")
asyncio.run(main())
MicroPython (через uasyncio)
import uasyncio as asyncio
from machine import I2C, Pin
from rbamp import RbAmp, RbAmpSensorClass
async def reader(dev):
async for snap in dev.stream_period(interval_s=60.0):
print("P={:.2f} W, Wh={:.4f}".format(snap.avg_p[0], dev.energy.wh(0)))
async def main():
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)
with RbAmp(i2c, 0x50) as dev:
# Run reader + other async tasks in parallel
await asyncio.gather(
reader(dev),
# other_async_task(),
)
asyncio.run(main())
Параметры stream_period(interval_s=, skip_stale=):
interval_s— период между снимками (рекомендуется ≥ 30 с)-
skip_stale=True(по умолчанию) — устаревшие снимки пропускаются автоматически; генератор просто переходит к следующему интервалу -
skip_stale=False— устаревшие снимки выдаются сsnap.valid=False, а решение, что с ними делать, — за вызывающим кодом
Полные примеры — examples_upy/05_async_streaming.py (MicroPython) и асинхронный аналог в примерах CPython.
Сценарий 11 — энергия STD на устройстве (CPython)
Цель: на модуле STANDARD (STD) считать собственные счётчики энергии модуля за весь срок службы и сообщать, сколько израсходовано за каждый интервал. Отдельного примера для этого сценария нет; приведённый ниже код полный.
Учёт энергии на устройстве проверен на CPython (smbus2). Путь MicroPython 16 бит реализован, но ещё не проверен на железе — для этого сценария предпочтителен CPython.
import time
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpNotSupportedError
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
if not dev.is_std:
raise SystemExit("not an STD module")
try:
prev = dev.read_std_energy()
except RbAmpNotSupportedError:
raise SystemExit("this module does not provide on-device energy")
while True:
time.sleep(60)
now = dev.read_std_energy()
delta, restarted = RbAmp.std_energy_delta(prev, now)
if delta is None:
print("energy generation changed - readings not comparable")
else:
print("import %d Wh, export %d Wh, net %d Wh%s" % (
delta.act_import_wh, delta.act_export_wh, delta.act_net_wh,
" (module restarted)" if restarted else ""))
prev = now
std_energy_delta() устойчив к отключению питания: счётчик, который после него оказался чуть ниже, считается приростом ноль. Поканальные значения — в now.ch_import_uwh[ch] / ch_export_uwh[ch] для ch < now.channels.
Вызовы периодов на модуле STD
Вызовы периодов из сценария 2 работают на модуле STD так же, как на BASIC; энергия нетто (экспорт вычитается):
import time
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpStaleError
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
continue # nothing to report for this period; the next one covers it
print("avg %.1f W, net %.4f Wh, total %.4f Wh%s" % (
snap.avg_p_total, snap.wh_net, dev.energy.wh(0),
" (module restarted)" if snap.module_restarted else ""))
begin() выбирает источник периода по тому, что сообщает модуль: его счётчики энергии (период — разность двух показаний; команда latch не отправляется) или, если на модуле только банки latch, банк latch 0. Банки latch доступны и напрямую — см. «Банки latch» в 09 · Справочник API.
Сводная таблица сценариев
| # | LOC | Среда выполнения | шина I²C | Период? | DRDY? | MQTT? | Сохранение |
|---|---|---|---|---|---|---|---|
| 1 | ~25 | оба | выделенный | нет | нет | нет | нет |
| 2 | ~35 | оба (OLED на uPy) | совместно с OLED (uPy) | да | нет | нет | RAM |
| 3 | ~50 | оба | общая, 3 модуля | да | нет | нет | RAM |
| 4 | ~50 | оба | выделенный | да | нет | да | retained MQTT |
| 5 | ~40 | оба | выделенный | нет (RT) | нет | нет | ОЗУ (принадлежит мастеру) |
| 6 | ~60 | оба | общая, 3 модуля | да | нет | да | retained MQTT |
| 7 | ~40 | оба | выделенный | нет (RT) | нет | нет | RAM |
| 8 | ~30 | CPython | выделенный | да | нет | нет | файл ротируемого журнала |
| 9 | ~50 | Только MicroPython | выделенный | да | нет | да | Память RTC + MQTT |
| 10 | ~25 | оба (asyncio/uasyncio) | выделенный | да | нет | (optional) | RAM |
| 11 | ~20 | CPython (модуль STD) | выделенный | нет (на устройстве) | нет | нет | счётчики энергии модуля за весь срок службы |
Промышленное развёртывание (только CPython)
Для долгосрочной работы 24/7 на Linux SBC рекомендуется сервис systemd. Полный пример — в examples_cpython/10_systemd_service.py (он включает помощник --install, который генерирует файл юнита /etc/systemd/system/rbamp.service).
Базовая структура:
#!/usr/bin/env python3
# /usr/local/bin/rbamp_daemon.py (make it executable: sudo chmod +x /usr/local/bin/rbamp_daemon.py)
import sys, signal, time, logging
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpSensorClass
logging.basicConfig(level=logging.INFO,
format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("rbamp")
shutdown = False
def on_signal(sig, frame):
global shutdown
log.info("Received signal %d, shutting down gracefully", sig)
shutdown = True
signal.signal(signal.SIGTERM, on_signal)
signal.signal(signal.SIGINT, on_signal)
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
log.info("rbAmp daemon started")
while not shutdown:
try:
snap = dev.read_period_snapshot()
log.info("P=%.1f W, Wh=%.4f", snap.avg_p[0], dev.energy.wh(0))
except Exception as e:
log.warning("snapshot failed: %s", e)
time.sleep(60)
log.info("rbAmp daemon stopped")
И сам модуль:
# /etc/systemd/system/rbamp.service
[Unit]
Description=rbAmp I2C AC sensor daemon
After=network.target
[Service]
Type=simple
ExecStart=/usr/local/bin/rbamp_daemon.py
Restart=on-failure
RestartSec=5
# the user must be in the i2c group: sudo usermod -aG i2c pi
User=pi
[Install]
WantedBy=multi-user.target
Чтобы запустить: sudo systemctl enable --now rbamp. Логи: journalctl -u rbamp -f.
Что дальше
-
07 · DIY integrations — Home Assistant / Node-RED / OpenHAB, построенные на этих сценариях
-
08 · Cloud integrations — AWS IoT / Azure / GCP / InfluxDB Cloud / общий webhook
-
09 · Справочник API — каждый публичный класс, метод, свойство и исключение
-
10 · Устранение неполадок — когда сценарии работают некорректно на вашем стенде
← Быстрый старт | Содержание | Интеграции DIY →
Исходники и задачи: rb-amp/rbamp-python · эта страница в репозитории: docs/06_examples.md
Исходники и задачи: rb-amp/rbamp-python · эта страница в репозитории: docs/06_examples.md (v1.6.1)