rbAmp
RU
Магазин

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

Монитор энергии на Arduino с клещами SCT-013: ватты на OLED, без сети

Без Wi-Fi, без облака и без Home Assistant — только Arduino, модуль rbAmp и небольшой OLED, показывающий реальные вольты, амперы, ватты и киловатт-часы. Начальная точка для библиотеки rbAmp для Arduino.

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

  • Живые напряжение, ток, реальная мощность и коэффициент мощности на OLED 128×64, обновляются примерно раз в секунду.
  • Накопленная энергия (Вт·ч) на том же экране — реальные ватт-часы, интегрированные на хосте по настенным часам.
  • Всё по одной шине I²C, общей для модуля rbAmp и дисплея, — всего четыре сигнальных провода.
  • Без Wi-Fi, без облака, без HA. Зеркало последовательного порта для отладки; весь интерфейс — OLED.

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

Позиция Кол-во Примечания
rbAmp BASIC SCT-UI1 1 напряжение + ток + активная мощность на чипе · продукт
Токовый трансформатор SCT-013 1 номинал под вашу цепь · продукт
Отладочная плата ESP32 (фреймворк Arduino) 1 проверенная компиляцией цель — ESP32 даёт честные долгосрочные Вт·ч (64-битные double) и запас ОЗУ для дисплея
OLED SSD1306 128×64 I²C 1 дисплей (I²C адрес 0x3C, использует общую шину)
Перемычки — общая шина I²C (SDA / SCL / VCC / GND)
Примечание

Подходит любая плата, совместимая с Arduino. Скетч — это обычный C++ для Arduino: он работает на Uno, Nano, STM32, RP2040 или ESP32. Здесь мы использовали ESP32, потому что он дешёвый, доступный везде и с запасом для честных долгосрочных итогов энергии. Одно, что меняется от платы к плате, — скорость шины I²C: ESP32 требует Wire.setClock(50000) (50 кГц, настройка его драйвера), тогда как большинство плат не-ESP32 работают с модулем на 100 кГц.

Подключение

Модуль rbAmp и OLED-дисплей находятся на одной и той же двухпроводной шине I²C — у них разные адреса (0x50 для rbAmp, 0x3C для OLED), поэтому они работают вместе без конфликтов:

Text
Arduino                     rbAmp (0x50)        OLED (0x3C)
-------                     ------------        -----------
SDA  ───────────────┬────── SDA ───────┬─────── SDA
SCL  ───────────────┼────── SCL ───────┼─────── SCL
5V   ───────────────┼────── VCC        └─(3.3V) VCC   *(check your OLED's voltage)*
GND  ───────────────┴────── GND ──────────────── GND
                            │
                            └── SCT-013 clamped around ONE mains conductor (arrow → load)
  • Шина работает на логике 3.3 В (линии I²C модуля терпят 5 В, но в покое держатся на 3.3 В хоста). Модуль rbAmp несёт встроенные подтяжки 4.7 кОм к 3.3 В, которых хватает для этой шины «один модуль плюс OLED» — внутренние слабые подтяжки ESP32 включать не нужно. Обратите внимание на уровни: VCC rbAmp = 5 В, VCC OLED = 3.3 В, общая земля — сама шина I²C работает на логике 3.3 В. (Почему rbAmp питается от 5 В при шине 3.3 В?)

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

Установите библиотеку

Arduino IDE: Sketch → Include Library → Manage Libraries… — скетч → подключить библиотеку → управлять библиотеками… [Sketch → Include Library → Manage Libraries…], найдите RbAmp, установите. Или через arduino-cli:

Text
arduino-cli lib install RbAmp

Понадобится также драйвер OLED — установите Adafruit SSD1306 (v2.5.14) из Менеджера библиотек [Library Manager]; он автоматически подтянет Adafruit GFX и Adafruit BusIO.

Скетч

Вставьте это, задайте MY_CT под свои клещи и прошейте. Рассчитано на ESP32 (фреймворк Arduino) на 50 кГц (настройка драйвера ESP-IDF I²C; хост не на ESP32, например Uno/Nano, будет использовать 100 кГц), с OLED Adafruit SSD1306:

C++
/**
 * StandaloneMonitor.ino — a standalone Arduino energy monitor (no network, no HA).
 *
 * One rbAmp UI1 module + an ESP32 + a 128x64 SSD1306 I2C OLED on the same two-wire
 * bus. Shows Voltage / Current / Power / Power Factor live (~1 s) and a
 * host-integrated Energy (Wh) total. Wh is integrated on the master from avg power
 * x wall-clock dt — that's what makes the total honest.
 *
 * Board:  ESP32 (Arduino framework)  -- esp32:esp32:esp32
 * Bus:    I2C @ 50 kHz  (Wire.setClock(50000)) -- required on ESP32-Arduino (its
 *         Wire wraps the ESP-IDF i2c driver). On a non-ESP32 host use 100 kHz.
 * OLED:   Adafruit_SSD1306 + Adafruit_GFX (addr 0x3C, shares SDA/SCL with rbAmp).
 *
 * Wiring:
 *   SDA -> GPIO21           (both devices)
 *   SCL -> GPIO22           (both devices)
 *   rbAmp VCC -> 5 V        (4.5-5.5 V; below 4.5 V the ADC loses accuracy)
 *   OLED  VCC -> 3.3 V
 *   GND       -> GND        (common ground, both devices)
 *   ~4.7 kOhm pull-ups on SDA and SCL to 3.3 V (host logic level)
 *   OLED 0x3C, rbAmp 0x50
 *
 * Accuracy: per clamp rating — the class and the sensor's own tolerance are both in the accuracy table on the BASIC page.
 */
#include 
#include 
#include 
#include 

/* ---- configuration -------------------------------------------------------- */
static const uint8_t      RBAMP_ADDR = 0x50;
static const uint8_t      OLED_ADDR  = 0x3C;
static const uint16_t     OLED_W     = 128;
static const uint16_t     OLED_H     = 64;
static const uint32_t     I2C_HZ     = 50000;   /* ESP32-Arduino: 50 kHz */

/* Match this to your clamp: Sct013_005 / _010 / _030 / _050 / _020. */
static const RbAmpCTModel MY_CT      = RbAmpCTModel::Sct013_030;

static const uint32_t     LIVE_MS    = 1000;    /* refresh V/I/P/PF each second */
static const uint32_t     ENERGY_MS  = 30000;   /* latch a period + roll Wh every 30 s */

/* ---- objects -------------------------------------------------------------- */
static Adafruit_SSD1306 oled(OLED_W, OLED_H, &Wire, -1);
static RbAmp            dev(Wire, RBAMP_ADDR, RbAmpTopology::Single);

static bool     oled_ok        = false;
static uint32_t next_live_ms   = 0;
static uint32_t next_energy_ms = 0;

/* Last-good live values: a single transient read hiccup should not blank the
 * display, so we hold the previous plausible reading. */
static float lastV = NAN, lastI = NAN, lastP = NAN, lastPF = NAN;
static uint32_t reads_ok = 0, reads_bad = 0;

/* ---- helpers -------------------------------------------------------------- */
static void banner(const __FlashStringHelper* l1, const char* l2) {
    if (!oled_ok) return;
    oled.clearDisplay();
    oled.setTextSize(1);
    oled.setTextColor(SSD1306_WHITE);
    oled.setCursor(0, 0);
    oled.println(l1);
    oled.println(l2);
    oled.display();
}

/* Apply the CT model only if the module isn't already on it (setCTModel()
 * persists to flash, so we avoid rewriting the same value every boot). */
static void ensureCtModel() {
    uint8_t applied = 0;
    if (dev.readCTModelCh(0, applied) && applied == static_cast(MY_CT)) {
        Serial.println(F("CT model already set; skipping flash write"));
        return;
    }
    Serial.println(F("configuring CT model (persists to flash)..."));
    if (!dev.setSensorClass(RbAmpSensorClass::Sct013) || !dev.setCTModel(MY_CT)) {
        Serial.print(F("CT config failed: "));
        Serial.println(RbAmp::errorString(dev.lastError()));
    }
}

static void drawLive() {
    if (!oled_ok) return;
    oled.clearDisplay();
    oled.setTextColor(SSD1306_WHITE);

    /* Power headline, big. */
    oled.setTextSize(2);
    oled.setCursor(0, 0);
    oled.print(isnan(lastP) ? 0.0f : lastP, 0);
    oled.println(F(" W"));

    /* V / I / PF row. */
    oled.setTextSize(1);
    oled.setCursor(0, 20);
    oled.print(isnan(lastV) ? 0.0f : lastV, 1);  oled.print(F("V  "));
    oled.print(isnan(lastI) ? 0.0f : lastI, 3);  oled.print(F("A  PF"));
    oled.println(isnan(lastPF) ? 0.0f : lastPF, 2);

    /* Energy total. */
    oled.setCursor(0, 36);
    oled.print(F("Energy: "));
    oled.print(dev.energy().wh(0), 3);
    oled.println(F(" Wh"));

    /* Health line. */
    oled.setCursor(0, 52);
    oled.print(F("ok="));  oled.print(reads_ok);
    oled.print(F(" bad=")); oled.print(reads_bad);
    oled.display();
}

static void readLive() {
    float v  = dev.readVoltage();
    float i  = dev.readCurrent(0);
    float p  = dev.readPower(0);
    float pf = dev.readPowerFactor(0);

    if (!isnan(v))  lastV  = v;
    if (!isnan(i))  lastI  = i;
    if (!isnan(p))  lastP  = p;
    if (!isnan(pf)) lastPF = pf;

    if (isnan(v) && isnan(i) && isnan(p)) reads_bad++; else reads_ok++;

    Serial.print(F("V="));   Serial.print(lastV, 1);
    Serial.print(F(" I="));  Serial.print(lastI, 3);
    Serial.print(F(" P="));  Serial.print(lastP, 1);
    Serial.print(F(" PF=")); Serial.print(lastPF, 2);
    Serial.print(F(" Wh=")); Serial.println(dev.energy().wh(0), 3);

    drawLive();
}

/* 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 display keeps running on the last live values. */
static void rollEnergy() {
    RbAmpPeriodSnapshot snap;
    if (!dev.readPeriodSnapshot(snap)) {
        Serial.print(F("period skipped: "));
        Serial.println(RbAmp::errorString(dev.lastError()));
        return;
    }
    Serial.print(F("period ok: avg_P0="));
    Serial.print(snap.avg_p[0], 2);
    Serial.print(F("W dt="));
    Serial.print(snap.master_dt_ms);
    Serial.print(F("ms -> Wh="));
    Serial.println(dev.energy().wh(0), 4);
}

/* ---- lifecycle ------------------------------------------------------------ */
void setup() {
    Serial.begin(115200);
    while (!Serial && millis() < 2000) {}

    Wire.begin();
    Wire.setClock(I2C_HZ);

    oled_ok = oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
    if (oled_ok) {
        banner(F("rbAmp monitor"), "booting...");
    } else {
        Serial.println(F("OLED init failed - running headless on Serial"));
    }

    dev.setLogStream(&Serial);
    uint8_t tries = 0;
    while (!dev.begin()) {
        const char* why = RbAmp::errorString(dev.lastError());
        Serial.print(F("rbAmp begin failed: "));
        Serial.println(why);
        banner(F("no rbAmp - retry"), why);
        if (++tries % 5 == 0)
            Serial.println(F("check wiring: SDA/SCL/power/GND + pull-ups"));
        delay(1000);
    }
    Serial.println(F("rbAmp online"));
    ensureCtModel();

    uint32_t now   = millis();
    next_live_ms   = now;
    next_energy_ms = now + ENERGY_MS;
}

void loop() {
    uint32_t now = millis();

    if (static_cast(now - next_live_ms) >= 0) {
        next_live_ms = now + LIVE_MS;
        readLive();
    }
    if (static_cast(now - next_energy_ms) >= 0) {
        next_energy_ms = now + ENERGY_MS;
        rollEnergy();
    }

    delay(5);
}

(Проверено компиляцией для ESP32 через Arduino-CLI — Adafruit SSD1306 v2.5.14 + Adafruit GFX. setCTModel() пишет во флеш, поэтому скетч переписывает пресет CT только тогда, когда он действительно меняется — без износа флеша при каждой загрузке.)

Что делает скетч

Вся библиотека rbAmp для Arduino умещается в несколько вызовов. Две функции делают основную работу — readLive() каждую секунду и rollEnergy() каждые 30 секунд — управляются loop() с двумя частотами. Вот каждая часть.

Настройка — привязка, опрос, конфигурация

C++
RbAmp dev(Wire, 0x50, RbAmpTopology::Single);   // bus, address, topology
...
while (!dev.begin()) { /* print errorString(), retry */ }
ensureCtModel();

RbAmp dev(Wire, 0x50, RbAmpTopology::Single) привязывает библиотеку к шине I²C и модулю по адресу 0x50; Single означает одноканальный UI1 (UI2/UI3 передали бы SplitPhase / ThreePhase). begin() опрашивает модуль и читает его возможности — крутите цикл, пока он не вернёт true, выводя RbAmp::errorString(dev.lastError()), чтобы ошибка проводки была очевидна. ensureCtModel() читает сохранённый пресет CT модуля и записывает его только если он отличается (setCTModel() сохраняет во флеш) — так флеш не изнашивается при каждой загрузке.

readLive() — показание раз в секунду

C++
float v  = dev.readVoltage();
float i  = dev.readCurrent(0);
float p  = dev.readPower(0);
float pf = dev.readPowerFactor(0);
if (!isnan(v)) lastV = v;   // hold last-good on a transient miss

Эти четыре чтения берут реальные измерения модуля: readPower(0) — это реальная активная мощность в ваттах, среднее из мгновенного напряжения × ток, а не ток × предполагаемое напряжение. Любое чтение может изредка вернуть NaN (кратковременный сбой шины); скетч оставляет предыдущее хорошее значение (lastV, lastI, …), чтобы дисплей никогда не мигал нулём, и увеличивает счётчик ok=/bad=, который вы видите на экране. Затем вызывается drawLive(), чтобы вывести OLED.

rollEnergy() — честный итог энергии

C++
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) { /* stale/not-ready: report + skip */ return; }
// dev.energy().wh(0) has now advanced for this window

Энергия работает иначе, чем живые чтения. readPeriodSnapshot() отправляет модулю атомарный LATCH — «закрыть текущее окно измерения сейчас» — ждёт установления и читает среднюю мощность этого окна. Затем библиотека продвигает накопленный на хосте итог Вт·ч: energy = average_power × elapsed_wall-clock_time. Поскольку интервал интегрирования ведёт хост, нет счётчика на устройстве, который бы квантовал или дрейфовал — dev.energy().wh(0) — честный накопительный итог. Если период возвращается устаревшим или не готовым, функция сообщает об этом и выходит; дисплей продолжает работать на последних живых значениях.

loop() с двумя частотами

C++
if (now - next_live_ms   >= 0) { next_live_ms   += LIVE_MS;   readLive();   }   // 1 s
if (now - next_energy_ms >= 0) { next_energy_ms += ENERGY_MS; rollEnergy(); }   // 30 s

Два независимых таймера: живой дисплей обновляется каждые LIVE_MS (1 с) для отзывчивого показания, а более тяжёлое энергетическое защёлкивание выполняется только каждые ENERGY_MS (30 с). Разделение держит экран быстрым, не защёлкивая модуль 60 раз в минуту. Меняйте любую из констант по вкусу.

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

На OLED — живое показание, следующее за нагрузкой: включите лампу или чайник и смотрите, как прыгнут ватты. В мониторе порта [Serial Monitor] (115200 бод) те же значения выводятся для отладки:

Text
V=230.4 I=0.211 P=48.2 PF=0.97 Wh=12.345

[скриншот / фото — слот медиа: OLED с живым показанием на стенде]

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

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

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

Несколько небольших дополнений, когда всё заработает:

  • Сбрасываемый счётчик срабатываний — ведите свою переменную double kwh_session рядом с общим накоплением и обнуляйте её кнопкой на свободном GPIO, чтобы получить показание «с момента нажатия».

  • Больше показаний — модуль также сообщает частоту; добавьте трекер минимума/максимума мощности или строку кВт·ч (wh / 1000.0).

  • Мягкий сигнал — мигание OLED или светодиода, когда мощность переходит порог (реле не нужно для предупреждения только на дисплее).

  • Отправляйте наружу — вы на ESP32, значит, есть WiFi: публикуйте показания по MQTT на свой брокер или поднимите маленькую веб-страницу — без отказа от локального OLED.

  • Медленнее или быстрее — уменьшите LIVE_MS для более живого графика или увеличьте ENERGY_MS, если шаг энергии в 30 с устраивает.

Ничто из этого не затрагивает измерение — это лишь то, что вы делаете с числами, которые уже отдают readLive() и rollEnergy().

Что дальше

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

  • Измеряйте несколько цепей сразу — несколько модулей rbAmp на одной шине, считываемых и суммируемых одним Arduino.
  • Действуйте по показаниям — отключайте реле или включайте зуммер, когда цепь превышает предел тока; всё локально, без сети.

  • Журналируйте — периодически записывайте энергию на SD-карту или передавайте CSV на ПК.

(Предпочитаете Home Assistant? Тот же модуль подходит к ESPHome.)


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