Что вы соберёте
- Живые напряжение, ток, реальная мощность и коэффициент мощности на 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), поэтому они работают вместе без конфликтов:
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:
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:
/**
* 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() с двумя частотами. Вот каждая часть.
Настройка — привязка, опрос, конфигурация
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() — показание раз в секунду
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() — честный итог энергии
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() с двумя частотами
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 бод) те же значения выводятся для отладки:
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.)