rbAmp
RU
Магазин

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

Локальное ограничение тока на Arduino — отключайте реле до автомата, без облака

Считывайте ток цепи модулем rbAmp и локально отключайте реле при превышении порога — за доли секунды, с гистерезисом и подавлением пускового броска.

Безопасность

⚠️ Сначала прочитайте, что это и чем не является. Это слой комфорта и удобства, а не защитное устройство. Ваш автомат защиты остаётся устройством безопасности — никогда не рассчитывайте сечение цепи или нагрузку, исходя из того, что эта автоматика сработает. А реле, которое вы коммутируете, должно быть рассчитано на нагрузку: маломощное реле или умный выключатель не разорвут 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:

C++
/**
 * 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(). Пара маленьких вспомогательных функций держит код аккуратным.

Безопасный по умолчанию вывод

C++
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()

C++
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.


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