rbAmp
RU
Магазин

Проект · · 11 мин чтения

Монитор энергии Raspberry Pi на Python: ватты в реальном времени, без облака

Считайте реальную мощность сети на Raspberry Pi в нескольких строках Python: вольты, амперы, ватты и кВт·ч с модуля rbAmp по I²C, выводимые в реальном времени. Без облака.

Что вы соберёте

  • Живые напряжение, ток, активная мощность и коэффициент мощности, выводимые в терминал примерно раз в секунду.
  • Накопительный итог энергии (Вт·ч), интегрированный на Pi по настенным часам.
  • Всё на шине I²C Raspberry Pi — четыре провода — на простом CPython.
  • Без службы Wi-Fi, без облака, без HA. Просто скрипт, который вы запускаете.

Спецификация

Позиция Кол-во Примечания
rbAmp BASIC SCT-UI1 1 напряжение + ток + активная мощность на чипе · продукт
Токовый трансформатор SCT-013 1 номинал под вашу цепь · продукт
Raspberry Pi 1 любая модель с 40-контактным разъёмом I²C
Перемычки — шина I²C (SDA / SCL / 5V / GND)

Включите I²C и установите библиотеку

На Pi один раз включите интерфейс I²C — sudo raspi-config → Interface Options → I2C → включить (или добавить dtparam=i2c_arm=on в /boot/firmware/config.txt и перезагрузить). Затем установите пакет:

Bash
pip install rbamp smbus2

(Встроенный драйвер I²C Raspberry Pi работает на 100 кГц по умолчанию и вполне совместим с модулем — обхода на 50 кГц здесь не нужно; это относится только к драйверу ESP-IDF на ESP32.)

Подключение

Модуль rbAmp подключается к выводам I²C Pi:

Text
Raspberry Pi header          rbAmp (0x50)
-------------------          ------------
pin 3  SDA (GPIO2) ────────── SDA
pin 5  SCL (GPIO3) ────────── SCL
pin 2  5V          ────────── VCC        (rbAmp wants 5 V)
pin 6  GND         ────────── GND
                              │
                              └── SCT-013 clamped around ONE mains conductor (arrow → load)
  • Шина I²C Pi — логика 3.3 В, а модуль rbAmp имеет встроенные подтяжки, так что для одного модуля внешние не нужны. Питайте модуль от 5 В (выводы 5 В Pi); линии шины в покое держатся на 3.3 В. (Почему питание 5 В при шине 3.3 В?)

  • Клещи SCT-013 охватывают изолированный проводник снаружи — со стороны тока вы никогда не режете и не зачищаете токоведущий провод. Вход напряжения переменного тока подключается к сети. Работы внутри электрощита поручите квалифицированному электрику.

Скрипт

Сохраните, задайте MY_CT (или передайте --ct) под свои клещи и запустите python tp1_standalone_pi_monitor.py:

Python
"""
T-P1 — Standalone Raspberry Pi energy monitor (no network, no HA).

One rbAmp UI1 module on the Raspberry Pi hardware I2C bus. Prints live
mains Voltage / Current / Power / Power Factor to the terminal every
second, and every 30 s latches a period snapshot to roll a host-side
Energy (Wh) total. Nothing is invented on-device: Wh is integrated on
the host from average power x wall-clock dt, which is what makes the
total honest.

Wiring (Raspberry Pi, hardware I2C):
    rbAmp SDA -> GPIO2  (Pi pin 3)
    rbAmp SCL -> GPIO3  (Pi pin 5)
    rbAmp GND -> any GND pin
    rbAmp VCC -> 5V     (Pi pin 2 or 4; 4.5-5.5 V -- below 4.5 V the ADC loses accuracy)

Enable I2C once on the Pi:
    sudo raspi-config    # Interface Options -> I2C -> Enable
                         # (equivalent to `dtparam=i2c_arm=on`)

The stock Raspberry Pi Broadcom I2C driver runs at 100 kHz and is
clean with rbAmp straight out of the box -- no `dtparam=i2c_arm_baudrate`
override is needed. (The 50 kHz workaround only applies to the ESP-IDF
i2c_master driver on ESP32.)

Install:
    pip install rbamp smbus2

Run:
    python tp1_standalone_pi_monitor.py
    # or with a non-default bus / address / CT model:
    #   python tp1_standalone_pi_monitor.py --bus 1 --addr 0x50 --ct 3

Set MY_CT below (or pass --ct) to match YOUR clamp before first run.
The value persists to the module's flash, so this script only re-writes
it when it actually differs -- no flash wear on every power-up.

Accuracy: per clamp rating — the class and the sensor's own tolerance are both in the accuracy table on the BASIC page.
Ctrl-C to stop.
"""

import argparse
import time

from smbus2 import SMBus

from rbamp import (
    RbAmp,
    RbAmpError,
    RbAmpStaleError,
    RbAmpSensorClass,
)

# ---- configuration --------------------------------------------------------
# CT model code (matches your clamp; persists to module flash):
#   1 = SCT-013-005 (5 A)     4 = SCT-013-050 (50 A)
#   2 = SCT-013-010 (10 A)    6 = SCT-013-020 (20 A)
#   3 = SCT-013-030 (30 A)
MY_CT = 3

LIVE_S   = 1.0    # refresh V/I/P/PF each second
ENERGY_S = 30.0   # latch a period + roll Wh every 30 s


def ensure_ct_preset(dev, ct_code):
    """Verify-then-set: only rewrite the CT preset if the module isn't
    already on it. set_sensor_class / set_ct_model_ch both persist to
    flash, so this avoids a needless flash write every power-up.
    """
    try:
        applied = dev.read_ct_model_ch(0)
    except RbAmpError:
        applied = -1
    if applied == ct_code:
        print(f"CT model already SCT_013 code={ct_code}; skipping flash write")
        return False
    print(f"configuring CT model SCT_013 code={ct_code} (persists to flash)...")
    dev.set_sensor_class(RbAmpSensorClass.SCT_013)
    dev.set_ct_model_ch(0, ct_code)
    return True


def read_live(dev, last, counters):
    """Read one live sample. A single transient hiccup keeps the previous
    plausible reading so the terminal keeps ticking (mirrors the Arduino
    T-A1 NaN-guard)."""
    try:
        v  = dev.voltage
        i  = dev.current[0]
        p  = dev.power[0]
        pf = dev.power_factor[0]
    except RbAmpError as e:
        counters["bad"] += 1
        print(f"read skipped: {type(e).__name__} -- {e}")
        return
    last["V"], last["I"], last["P"], last["PF"] = v, i, p, pf
    counters["ok"] += 1
    print(
        f"U={v:6.1f}V  I={i:6.3f}A  P={p:7.1f}W  PF={pf:+.2f}  "
        f"E={dev.energy.wh(0):8.4f}Wh  "
        f"[ok={counters['ok']} bad={counters['bad']}]"
    )


def roll_energy(dev):
    """Latch a metering period; the library rolls Wh from avg power x master
    dt on a successful valid snapshot. A stale / not-ready period is reported
    and skipped so the loop keeps running on the last live values."""
    try:
        snap = dev.read_period_snapshot()
    except RbAmpStaleError:
        print("  * period STALE (skipped)")
        return
    except RbAmpError as e:
        print(f"  * period skipped: {type(e).__name__} -- {e}")
        return
    print(
        f"  * period ok: avg_P0={snap.avg_p[0]:6.2f}W  "
        f"dt={snap.master_dt_ms:5d}ms  ->  E={dev.energy.wh(0):.4f}Wh"
    )


def run(bus, addr=0x50, ct_code=MY_CT,
        live_s=LIVE_S, energy_s=ENERGY_S, max_iters=None):
    """Core loop; broken out so a test harness can swap in a mock bus."""
    with RbAmp(bus, addr) as dev:
        print(
            f"rbAmp @ 0x{dev.address:02X}  fw=0x{dev.firmware_version:02X}  "
            f"topology={dev.topology_name}  channels={dev.channels}  "
            f"voltage_hw={'yes' if dev.has_voltage_hw else 'no'}"
        )
        ensure_ct_preset(dev, ct_code)
        print("Accuracy: per clamp rating — see the BASIC page. Ctrl-C to stop.\n")

        last = {"V": 0.0, "I": 0.0, "P": 0.0, "PF": 0.0}
        counters = {"ok": 0, "bad": 0}

        next_live_t   = time.monotonic()
        next_energy_t = next_live_t + energy_s
        iters = 0

        while True:
            now = time.monotonic()
            if now >= next_live_t:
                next_live_t = now + live_s
                read_live(dev, last, counters)
            if now >= next_energy_t:
                next_energy_t = now + energy_s
                roll_energy(dev)

            iters += 1
            if max_iters is not None and iters >= max_iters:
                return counters

            sleep_for = min(next_live_t, next_energy_t) - time.monotonic()
            if sleep_for > 0:
                time.sleep(sleep_for)


def main():
    ap = argparse.ArgumentParser(
        description="Standalone Raspberry Pi energy monitor for a single rbAmp UI1 module."
    )
    ap.add_argument("--bus",  type=int, default=1,
                    help="I2C bus number (Raspberry Pi default: 1)")
    ap.add_argument("--addr", type=lambda s: int(s, 0), default=0x50,
                    help="rbAmp I2C address (default: 0x50)")
    ap.add_argument("--ct",   type=int, default=MY_CT,
                    help="CT model code: 1=SCT-013-005, 2=-010, 3=-030, "
                         "4=-050, 6=-020 (default: 3 = 30 A)")
    args = ap.parse_args()

    with SMBus(args.bus) as bus:
        run(bus, addr=args.addr, ct_code=args.ct)


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\nstopped.")

(Проверено запуском на тестовом бэкенде библиотеки rbAmp для Python на CPython 3.12 — rbamp 1.3.0 + smbus2 0.6.1. set_ct_model_ch() сохраняет во флеш, поэтому скрипт переписывает пресет CT только тогда, когда он отличается — без износа флеша при каждом запуске. Ядро run() вынесено отдельно, чтобы его было легко тестировать и переиспользовать.)

Что делает скрипт

Вся библиотека rbAmp для Python умещается в пару блоков with и несколько чтений.

Контекстные менеджеры

Python
with SMBus(1) as bus:
    with RbAmp(bus, 0x50) as dev:
        ...

SMBus(1) открывает шину I²C Pi; RbAmp(bus, 0x50) привязывает библиотеку к модулю по адресу 0x50. Оба — контекстные менеджеры, так что шина и устройство очищаются автоматически при выходе из блока (или по Ctrl-C) — питоновская версия «откройте шину, опросите модуль».

Живые чтения

Python
v  = dev.voltage
i  = dev.current[0]
p  = dev.power[0]
pf = dev.power_factor[0]

Эти свойства возвращают реальные измерения модуля: dev.power[0] — это реальная активная мощность в ваттах, среднее из мгновенного напряжения × ток, а не ток × предполагаемое напряжение. (Форма-метод dev.read_power(0) полностью эквивалентна — берите то, что читается чище.) Кратковременное чтение может вызвать RbAmpError; скрипт перехватывает его и сохраняет предыдущие хорошие значения, а не падает.

Энергия — снимок за период

Python
snap = dev.read_period_snapshot()   # atomic LATCH: close the window, read avg power
print(dev.energy.wh(0))             # host-integrated watt-hours, honest over wall-clock time

read_period_snapshot() отправляет модулю атомарный LATCH — «закрыть окно измерения сейчас» — а библиотека продвигает накопленный на хосте итог Вт·ч по формуле average_power × elapsed_time. Pi владеет интервалом интегрирования, так что дрейфовать нечему — нет счётчика на устройстве; dev.energy.wh(0) — честный накопительный итог. Устаревшее окно вызывает RbAmpStaleError, и скрипт его просто пропускает.

Что вы увидите

В терминале — живое показание, следующее за нагрузкой: включите лампу или чайник и смотрите, как прыгнут ватты:

Text
rbAmp @ 0x50  fw=0x04  topology=SINGLE  channels=1  voltage_hw=yes
CT model already SCT_013 code=3; skipping flash write
Accuracy: per clamp rating — see the BASIC page. Ctrl-C to stop.

U= 231.2V  I= 4.874A  P= 1123.5W  PF=+1.00  E=  0.0000Wh  [ok=1 bad=0]
U= 231.2V  I= 4.874A  P= 1123.5W  PF=+1.00  E=  0.0000Wh  [ok=2 bad=0]
  * period ok: avg_P0=1119.40W  dt=   50ms  ->  E=0.0622Wh
U= 231.2V  I= 4.874A  P= 1123.5W  PF=+1.00  E=  0.0622Wh  [ok=3 bad=0]

Насколько он точный?

Для клещей SCT-013 класс и собственная погрешность клещей публикуются по каждому номиналу в таблице точности SCT-013. Модуль измеряет реальную активную мощность с фазовой компенсацией по каждому каналу — поэтому реактивные и нагрузки с низким коэффициентом мощности читаются честно. Почему так — см.: как на самом деле работает измерение энергии токовыми клещами.

Адаптируйте под себя

  • Записывайте в файл или SQLite — у Pi есть настоящая файловая система; дописывайте каждое показание в CSV или базу данных (это сборка журнала).

  • Раздайте наружу — Pi в сети: выведите показания как маленькую конечную точку Flask или публикуйте по MQTT на свой брокер — без облака.

  • Сводка по cron — запускайте скрипт по таймеру и присылайте себе суточный итог в кВт·ч.

  • Добавьте дисплей — небольшой OLED I²C на той же шине для показаний без головы (без экрана ПК).
  • Больше цепей — поставьте несколько модулей на шину и суммируйте их (это сборка с несколькими модулями).

Ничто из этого не затрагивает измерение — это то, что вы делаете с числами, которые уже дают чтения.

Что дальше

Этот один модуль в терминале — основа. Дальше серия Python развивается так:

  • Измеряйте несколько цепей — несколько модулей rbAmp на одной шине, считываемых и суммируемых Pi.
  • Действуйте по показаниям — отключайте GPIO-реле, когда цепь превышает предел тока.
  • Журналируйте — периодическая энергия в CSV или SQLite.

(Предпочитаете микроконтроллер вместо Pi? Тот же модуль работает на Arduino или в Home Assistant через ESPHome.)


Читать дальше