rbAmp
PT
Loja

Projeto · · 14 min de leitura

Limite de corrente local com Arduino — dispare um relé antes do disjuntor, sem nuvem

Leia a corrente de um circuito com um módulo rbAmp e dispare um relé localmente quando passar o seu limite — em menos de um segundo, com histerese e anti-ressalto de arranque.

Segurança

⚠️ Leia isto primeiro — o que é e o que não é. Isto é uma camada de conforto e conveniência, não um dispositivo de proteção. O seu disjuntor continua a ser o dispositivo de segurança — nunca dimensione um circuito ou uma carga a contar que esta automação vai atuar. E o relé que comuta tem de ser dimensionado para a carga: um relé pequeno ou um interruptor inteligente não consegue interromper 30–50 A diretamente. Para um circuito de corrente elevada, use o relé de baixa corrente para acionar um contactor devidamente dimensionado. Para trabalhos dentro de um quadro elétrico, chame um eletricista qualificado.

O que vai construir

  • Um módulo rbAmp a medir a corrente de um circuito.
  • Um relé que dispara quando a corrente se mantém acima de LIMIT_ON amperes, e liberta abaixo de LIMIT_OFF (histerese, para não oscilar no ponto de regulação).

  • Anti-ressalto de arranque — um atraso curto de sobrecarga sustentada para que um pico de arranque de motor ou de chaleira não cause um disparo indesejado.

  • Buzzer / LED opcional para alerta. Tudo local, no ciclo do Arduino.

Lista de materiais

Item Qtd. Notas
rbAmp BASIC SCT-I1 1 o I1 só de corrente é a escolha leve — um UI1 também funciona (o seu canal de tensão fica simplesmente sem uso) · produto
TC SCT-013 1 classificação adequada ao circuito · produto
Placa de desenvolvimento ESP32 (framework Arduino) 1 o alvo verificado por compilação (portável para outras placas Arduino)
Módulo de relé 1 isolado, dimensionado para a carga — ou a acionar um contactor para corrente elevada
Buzzer / LED (opcional) 1 alerta local

Ligue tudo

O módulo rbAmp fica no barramento I²C (SDA→GPIO21, SCL→GPIO22, VCC do rbAmp 5 V, massa comum — porquê alimentação de 5 V com um barramento de 3.3 V?). A entrada de controlo do módulo de relé vai para o GPIO26; defina RELAY_ACTIVE_HIGH no esboço para corresponder à sua placa (muitas placas com isolamento ótico são ativas em nível BAIXO). Ligue a carga através do contacto NO do relé, para que um relé desenergizado signifique carga DESLIGADA. Um LED/buzzer no GPIO25 opcional acende enquanto disparado. A TC envolve à volta do condutor do circuito — não invasiva do lado da corrente.

A lógica: limiar, histerese, anti-ressalto

Três ideias evitam que se comporte mal:

  • Histerese — dispare em LIMIT_ON (por exemplo 18 A) mas só liberte abaixo de LIMIT_OFF (por exemplo 15 A). Um único ponto de ajuste oscilaria sempre que a carga pairasse perto dele; a diferença dá-lhe onde assentar.

  • Anti-ressalto de arranque — exija que a corrente se mantenha acima do limite durante alguns segundos antes de disparar. Motores, bombas e chaleiras puxam um grande pico de arranque que fica acima do limite durante uma fração de segundo — não quer disparar por causa disso.

  • O componente rbAmp lê o registo de RMS de corrente do módulo a cada ciclo (o módulo calcula o RMS internamente a cerca de 5 Hz, por isso cada leitura é o valor de janela mais recente) — o Arduino compara-o com os limites e aciona o relé.

O esboço

Defina LIMIT_ON / LIMIT_OFF para as suas amperagens e MY_CT para a sua pinça, faça corresponder RELAY_ACTIVE_HIGH à sua placa de relés, e carregue o firmware. ESP32 (framework Arduino) a 50 kHz; relé no GPIO26, alerta no 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;
    }
}

(Verificado por compilação em ESP32 com Arduino-CLI — apenas Wire + RbAmp. O pino do relé é conduzido ao estado seguro de carga ligada em setup(), antes de qualquer tráfego no barramento, por isso um begin() lento nunca o deixa a flutuar.)

O que o esboço faz

O cerne é uma máquina de três estados — ARMED → OVER_PENDING → TRIPPED — avaliada por amostra em loop(). Algumas pequenas funções auxiliares mantêm-no limpo.

A saída segura por defeito

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() esconde a diferença entre ativo em nível alto e baixo atrás de um único #define, por isso o resto do código apenas diz "carga ligada" ou "carga desligada". E setup() chama relayLoadOn(true) antes de qualquer tráfego I²C, para que um begin() lento nunca deixe o pino do relé a flutuar.

A máquina de estados — 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;
}

De cima para baixo:

  • ARMED — carga alimentada, em observação. No momento em que a corrente atinge LIMIT_ON, regista a hora do cruzamento e passa a OVER_PENDING. Ainda não disparou.

  • OVER_PENDING — ainda alimentada, agora com cronómetro. Se a corrente voltar a descer abaixo de LIMIT_OFF (passa um pico de arranque, ou a carga alivia) volta a ARMED — sem disparo. Se se mantiver acima do limite durante OVERLOAD_MS, corta: relé desligado, alerta ativo, → TRIPPED.

  • TRIPPED — carga cortada. Após COOLDOWN_MS volta a armar e a fechar; se a sobrecarga persistir, dispara de novo.

Esse é todo o comportamento relevante para a segurança. A histerese são os dois limiares diferentes (LIMIT_ON para disparar, LIMIT_OFF, mais baixo, para desarmar); o anti-ressalto de arranque é a espera de OVERLOAD_MS, que atravessa o pico de arranque de um motor ou de uma chaleira. Uma leitura NaN transitória mantém o estado atual e salta a amostra, por isso uma leitura má nunca pode causar disparo ou desarme falsos. enter() regista em Serial cada transição, com carimbo temporal e a corrente atual.

Quão rápido é?

Local e rápido. O módulo atualiza a sua RMS de corrente cerca de a cada 200 ms (~5 Hz); o Arduino lê-a em cada ciclo e, quando a sobrecarga se mantém para lá da janela de anti-ressalto, inverte o relé no passo seguinte — bem abaixo de um segundo de latência de decisão, sem HA nem nuvem no caminho. É a vantagem de fazer controlo no mesmo microcontrolador que lê o medidor.

Personalize-o

  • Ajuste-o — LIMIT_ON / LIMIT_OFF / OVERLOAD_MS / COOLDOWN_MS são todas constantes no topo; defina-as para o seu circuito.

  • Reposição manual — em vez de re-armar automaticamente após o período de arrefecimento, aguarde um botão de pressão para que uma pessoa limpe o disparo.

  • Prioridades — meça vários circuitos (a construção multimódulo) e corte primeiro a carga de menor prioridade para ficar abaixo de um limite da casa inteira.

  • Registe os disparos — escreva cada transição num cartão SD para ver quando e com que frequência disparou (a construção do registador).

  • Controlo proporcional — em vez de um relé liga/desliga, acione um dimmer TRIAC e mantenha uma corrente alvo com uma malha PID (um projeto maior — uma antevisão para mais tarde).

Seja o que for que acrescente, mantenha o enquadramento acima: isto continua a ser uma camada de conveniência, não um dispositivo de proteção.

O que se segue

  • Registe o que aconteceu — escreva os eventos de disparo e a corrente periódica num cartão SD ou em CSV pela série (a seguir nesta série).

  • Quer no Home Assistant? A versão HA — deslizadores, alertas, corte de carga por prioridade em todo o quadro — é controlo de carga em tempo real com rbAmp.


Leia a seguir