⚠️ Сначала прочитайте, что это и чем не является. Это слой комфорта и удобства, а не защитное устройство. Ваш автомат защиты остаётся устройством безопасности — никогда не рассчитывайте сечение цепи или нагрузку, исходя из того, что эта автоматика сработает. А реле, которое вы коммутируете, должно быть рассчитано на нагрузку: маломощное реле или умный выключатель не разорвут 30–50 А напрямую. Для цепи большого тока используйте маломощное реле для управления надлежащим образом рассчитанным контактором. Работы внутри электрощита поручите квалифицированному электрику.
Что вы соберёте
- Модуль rbAmp, измеряющий ток одной цепи.
-
Реле, которое срабатывает, когда ток остаётся выше
LIMIT_ONА, и отпускает нижеLIMIT_OFF(гистерезис, чтобы не дребезжало на уставке). -
Подавление пускового броска — короткая задержка на длительную перегрузку, чтобы пусковой скачок мотора или чайника не вызывал ложного срабатывания.
- Необязательный сигнал зуммером / светодиодом. Всё локально, в цикле Arduino.
Спецификация
| Позиция | Кол-во | Примечания |
|---|---|---|
| rbAmp BASIC SCT-I1 | 1 | только ток I1 — экономичный выбор; UI1 тоже подходит (его канал напряжения просто не используется) · продукт |
| Клещи SCT-013 CT | 1 | номинал под цепь · продукт |
| Отладочная плата ESP32 (фреймворк Arduino) | 1 | проверенная компиляцией цель (переносится на другие платы Arduino) |
| Модуль реле | 1 | изолированное, рассчитанное на нагрузку — либо управляющее контактором для большого тока |
| Зуммер / светодиод (необязательно) | 1 | локальный сигнал |
Подключение
Модуль rbAmp подключён к шине I²C (SDA→GPIO21, SCL→GPIO22, VCC rbAmp 5 В, общая земля — почему питание 5 В при шине 3.3 В?). Управляющий вход модуля реле идёт на GPIO26; задайте RELAY_ACTIVE_HIGH в скетче под вашу плату (многие оптоизолированные платы работают по LOW). Нагрузку коммутируйте через контакт реле NO, чтобы обесточенное реле означало, что нагрузка ВЫКЛ. Необязательный светодиод/зуммер на GPIO25 горит, пока срабатывание активно. CT охватывает снаружи проводник цепи — со стороны тока установка бесконтактная.
Логика: порог, гистерезис, подавление дребезга
Три идеи, которые не дают ему работать неправильно:
-
Гистерезис — срабатывание на
LIMIT_ON(допустим, 18 А), но снятие только нижеLIMIT_OFF(допустим, 15 А). Одна уставка заставляла бы дребезжать каждый раз, когда нагрузка колеблется рядом с ней; разрыв даёт ей место, чтобы устояться. -
Подавление пускового броска — требовать, чтобы ток оставался выше предела несколько секунд, прежде чем срабатывать. Моторы, насосы и чайники дают большой пусковой скачок, который выше предела лишь долю секунды — на него срабатывать не нужно.
-
Компонент rbAmp читает регистр действующего тока модуля на каждом цикле (модуль вычисляет RMS внутри примерно на 5 Гц, так что каждое чтение — последнее оконное значение) — Arduino сравнивает его с пределами и управляет реле.
Скетч
Задайте LIMIT_ON / LIMIT_OFF в своих амперах, MY_CT — под свои клещи, соответствие RELAY_ACTIVE_HIGH — под вашу плату реле, и прошейте. ESP32 (фреймворк Arduino) на 50 кГц; реле на GPIO26, сигнал на GPIO25:
/**
* LoadLimitRelay.ino — local current-limit -> relay / alert (standalone, no network).
*
* One rbAmp current module meters a circuit; when the current stays over a limit
* for a sustained interval, the Arduino trips a relay to shed the load and lights
* an alert. Everything runs in the loop, so the reaction is sub-second once the
* overload is confirmed — no network, no HA round-trip.
*
* =========================== SAFETY — READ FIRST ===========================
* * The relay/switch MUST be rated for the load. A small hobby relay or
* smart-plug CANNOT break 30-50 A directly. Switch a high-current circuit
* with a properly rated CONTACTOR that this low-current relay drives.
* * This is a COMFORT / CONVENIENCE layer, NOT a protection device. The circuit
* BREAKER remains the safety device. Never size a circuit or a load assuming
* this automation will act. For a hard cut-off use a hardware overcurrent
* device (breaker / fuse / thermal cut-out).
* * The relay reaction is deliberately delayed by OVERLOAD_MS to ride through
* inrush — it is NOT instantaneous overcurrent protection.
* ===========================================================================
*
* Module: a current-only rbAmp I-module (I1) at the default address 0x50. Only
* current is needed, so no voltage-sensing variant is required;
* readCurrent(0) is the metered channel. (A UI1 works too — its voltage
* channel simply goes unused.)
*
* Board: ESP32 (Arduino framework); I2C @ 50 kHz. Non-ESP32 host = 100 kHz.
* Wiring: SDA->GPIO21, SCL->GPIO22; rbAmp VCC->5 V; common GND; ~4.7 kOhm
* pull-ups to 3.3 V; RELAY_PIN(GPIO26)->opto-isolated relay IN;
* ALERT_PIN(GPIO25)->LED(+resistor)/buzzer. Wire the load through the
* relay NO contact so de-energised = load OFF.
*
* Accuracy: per clamp rating — the class and the sensor's own tolerance are both in the accuracy table on the BASIC page.
*/
#include
#include
/* ---- configuration — the reader edits these ------------------------------ */
static const uint8_t RBAMP_ADDR = 0x50;
static const uint8_t METER_CH = 0; /* current channel on the module */
static const uint32_t I2C_HZ = 50000; /* ESP32-Arduino: 50 kHz */
/* Match to your clamp: Sct013_005 / _010 / _030 / _050 / _020. */
static const RbAmpCTModel MY_CT = RbAmpCTModel::Sct013_030;
/* Threshold with hysteresis (amps). Trip when the current stays at/above
* LIMIT_ON; a pending overload clears only when it falls below LIMIT_OFF, so
* the relay does not chatter around the setpoint. Keep LIMIT_OFF < LIMIT_ON. */
static const float LIMIT_ON = 10.0f;
static const float LIMIT_OFF = 8.0f;
/* Debounce / timing. */
static const uint32_t SAMPLE_MS = 200; /* current sample cadence */
static const uint32_t OVERLOAD_MS = 3000; /* sustained over-limit before trip (rides inrush) */
static const uint32_t COOLDOWN_MS = 10000; /* stay shed before an auto re-arm attempt */
/* ---- relay / alert GPIO -------------------------------------------------- */
static const uint8_t RELAY_PIN = 26;
static const uint8_t ALERT_PIN = 25;
#define RELAY_ACTIVE_HIGH 1 /* 1: HIGH energises. Set 0 for active-LOW opto modules. */
static inline void relayLoadOn(bool on) {
bool level = (RELAY_ACTIVE_HIGH ? on : !on);
digitalWrite(RELAY_PIN, level ? HIGH : LOW);
}
static inline void alertOn(bool on) {
digitalWrite(ALERT_PIN, on ? HIGH : LOW);
}
/* ---- state machine ------------------------------------------------------- */
enum LoadState { ARMED, OVER_PENDING, TRIPPED };
static LoadState state = ARMED;
static RbAmp dev(Wire, RBAMP_ADDR, RbAmpTopology::Single);
static uint32_t next_sample_ms = 0;
static uint32_t over_since_ms = 0; /* when the current first crossed LIMIT_ON */
static uint32_t tripped_at_ms = 0;
static uint32_t trip_count = 0;
static uint32_t bad_reads = 0;
/* Apply the CT model only if it differs (setCTModel() persists to flash). */
static void ensureCtModel() {
uint8_t applied = 0;
if (dev.readCTModelCh(METER_CH, applied) && applied == static_cast(MY_CT)) {
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()));
}
}
/* Params are uint8_t (not LoadState) so the Arduino .ino auto-prototype
* generator — which inserts prototypes above the enum definition — compiles. */
static const char* stateName(uint8_t s) {
switch (s) {
case ARMED: return "ARMED";
case OVER_PENDING: return "OVER_PENDING";
case TRIPPED: return "TRIPPED";
}
return "?";
}
static void enter(uint8_t s, float a) {
Serial.print(F("["));
Serial.print(millis());
Serial.print(F("ms] "));
Serial.print(stateName(state));
Serial.print(F(" -> "));
Serial.print(stateName(s));
Serial.print(F(" (I="));
Serial.print(a, 3);
Serial.println(F(" A)"));
state = static_cast(s);
}
/* ---- lifecycle ----------------------------------------------------------- */
void setup() {
Serial.begin(115200);
while (!Serial && millis() < 2000) {}
/* Drive the outputs to the SAFE armed state FIRST (load powered, no alert),
* before any bus traffic, so a slow begin() never leaves the pin floating. */
pinMode(RELAY_PIN, OUTPUT);
pinMode(ALERT_PIN, OUTPUT);
relayLoadOn(true);
alertOn(false);
Wire.begin();
Wire.setClock(I2C_HZ);
dev.setLogStream(&Serial);
uint8_t tries = 0;
while (!dev.begin()) {
Serial.print(F("rbAmp begin failed: "));
Serial.println(RbAmp::errorString(dev.lastError()));
if (++tries % 5 == 0)
Serial.println(F("check wiring: SDA/SCL/5V/GND + external pull-ups"));
delay(1000);
}
Serial.println(F("rbAmp online"));
ensureCtModel();
Serial.print(F("armed: trip>="));
Serial.print(LIMIT_ON, 1);
Serial.print(F("A for "));
Serial.print(OVERLOAD_MS / 1000.0f, 1);
Serial.print(F("s, clear<"));
Serial.print(LIMIT_OFF, 1);
Serial.println(F("A"));
next_sample_ms = millis();
}
void loop() {
uint32_t now = millis();
if (static_cast(now - next_sample_ms) < 0) {
delay(2);
return;
}
next_sample_ms = now + SAMPLE_MS;
float a = dev.readCurrent(METER_CH);
/* Graceful: a transient bad/NaN read must not cause a false trip or a false
* release. Hold the current state and skip this sample. */
if (isnan(a)) {
bad_reads++;
if (bad_reads % 10 == 1) {
Serial.print(F("read failed ("));
Serial.print(RbAmp::errorString(dev.lastError()));
Serial.println(F(") - holding state"));
}
return;
}
switch (state) {
case ARMED:
/* Load powered; watch for the current crossing the trip limit. */
if (a >= LIMIT_ON) {
over_since_ms = now;
enter(OVER_PENDING, a);
}
break;
case OVER_PENDING:
/* Load still powered. Clear on a drop below the release threshold
* (inrush/transient passed); trip on sustained overload. */
if (a < LIMIT_OFF) {
enter(ARMED, a);
} else if (static_cast(now - over_since_ms) >= static_cast(OVERLOAD_MS)) {
relayLoadOn(false);
alertOn(true);
tripped_at_ms = now;
trip_count++;
enter(TRIPPED, a);
Serial.print(F(" LOAD SHED (trip #"));
Serial.print(trip_count);
Serial.println(F(")"));
}
break;
case TRIPPED:
/* Load shed (current is ~0 now). Hold for the cooldown, then re-arm
* and re-close; if the overload persists it will trip again. */
if (static_cast(now - tripped_at_ms) >= static_cast(COOLDOWN_MS)) {
relayLoadOn(true);
alertOn(false);
enter(ARMED, a);
Serial.println(F(" cooldown elapsed - load re-energised"));
}
break;
}
}
(Проверено компиляцией на ESP32 через Arduino-CLI — только Wire + RbAmp. Вывод реле переводится в безопасное состояние «нагрузка вкл» в setup() до любого трафика шины, так что медленный begin() никогда не оставит его висящим.)
Что делает скетч
Суть — это конечный автомат из трёх состояний — ARMED → OVER_PENDING → TRIPPED — который вычисляется один раз на каждый отсчёт в loop(). Пара маленьких вспомогательных функций держит код аккуратным.
Безопасный по умолчанию вывод
static inline void relayLoadOn(bool on) {
bool level = (RELAY_ACTIVE_HIGH ? on : !on); // one #define handles both board polarities
digitalWrite(RELAY_PIN, level ? HIGH : LOW);
}
relayLoadOn() прячет различие active-high/active-low за одним #define, так что остальной код просто говорит «нагрузка вкл» или «нагрузка выкл». А setup() вызывает relayLoadOn(true) до любого трафика I²C, так что медленный begin() никогда не оставит вывод реле висящим.
Конечный автомат — loop()
float a = dev.readCurrent(METER_CH);
if (isnan(a)) { /* hold state, skip this sample */ return; }
switch (state) {
case ARMED: if (a >= LIMIT_ON) { over_since_ms = now; enter(OVER_PENDING, a); } break;
case OVER_PENDING: if (a < LIMIT_OFF) enter(ARMED, a);
else if (now - over_since_ms >= OVERLOAD_MS) { relayLoadOn(false); enter(TRIPPED, a); } break;
case TRIPPED: if (now - tripped_at_ms >= COOLDOWN_MS) { relayLoadOn(true); enter(ARMED, a); } break;
}
Сверху вниз:
-
ARMED — нагрузка под напряжением, идёт наблюдение. Как только ток достигает
LIMIT_ON, фиксируется момент пересечения и происходит переход вOVER_PENDING. Отключения ещё не было. -
OVER_PENDING — по-прежнему под питанием, но уже с секундомером. Если ток падает ниже
LIMIT_OFF(пусковой бросок проходит или нагрузка спадает), устройство возвращается в ARMED — без отключения. Если он остаётся выше предела дольшеOVERLOAD_MS, происходит сброс: реле выключается, сигнал включается, → TRIPPED. -
TRIPPED — нагрузка сброшена. По истечении
COOLDOWN_MSустройство снова армируется и замыкает цепь; если перегрузка сохраняется, оно просто сработает ещё раз.
Вот и всё поведение, важное для безопасности. Гистерезис — это два разных порога (LIMIT_ON для отключения, меньший LIMIT_OFF для снятия); подавление пускового броска — это ожидание OVERLOAD_MS, через которое проходит пусковой скачок мотора или чайника. Кратковременное считывание NaN сохраняет текущее состояние и пропускает отсчёт, так что одна плохая выборка никогда не вызовет ложного отключения или ложного снятия. enter() записывает каждый переход в Serial с временной меткой и током.
Насколько он быстрый?
Локально и быстро. Модуль обновляет действующий ток примерно каждые 200 мс (~5 Гц); Arduino читает его на каждом цикле и, как только превышение продержалось дольше окна подавления, переключает реле на следующем проходе цикла — заметно меньше секунды задержки решения, без HA и облака в пути. В этом преимущество управления на том же микроконтроллере, который считывает счётчик.
Адаптируйте под себя
-
Настройте —
LIMIT_ON/LIMIT_OFF/OVERLOAD_MS/COOLDOWN_MS— всё это константы в начале; задайте их под свою цепь. -
Ручной сброс — вместо автоматического повторного взведения после охлаждения ожидайте кнопку, чтобы человек снял отключение.
-
Приоритеты — измеряйте несколько цепей (сборка с несколькими модулями) и сначала сбрасывайте нагрузку с наименьшим приоритетом, чтобы оставаться под пределом всего дома.
-
Журналируйте срабатывания — записывайте каждый переход на SD-карту, чтобы видеть, когда и как часто оно срабатывало (сборка журнала).
-
Пропорциональное управление — вместо жёсткого реле вкл/выкл управляйте симисторным диммером и удерживайте целевой ток ПИД-регулятором (проект побольше — тизер на будущее).
Что бы вы ни добавляли, сохраните рамку выше: это остаётся слоем комфорта, а не защитным устройством.
Что дальше
-
Журналируйте события — записывайте события срабатывания и периодический ток на SD-карту или CSV по последовательному порту (далее в этой серии).
-
Хотите это в Home Assistant? Версия HA — ползунки, сигналы, сброс нагрузки по приоритетам по всему щиту — это управление нагрузкой в реальном времени с rbAmp.