⚠️ 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_ONamperes, e liberta abaixo deLIMIT_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 deLIMIT_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:
/**
* 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
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()
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 aOVER_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 duranteOVERLOAD_MS, corta: relé desligado, alerta ativo, → TRIPPED. -
TRIPPED — carga cortada. Após
COOLDOWN_MSvolta 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_MSsã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.