rbAmp
ES
Tienda

Proyecto · · 14 min de lectura

Limitación local de corriente con Arduino: dispare un relé antes del interruptor automático, sin nube

Lea la corriente de un circuito con un módulo rbAmp y dispare un relé localmente cuando supere su límite: menos de un segundo, con histéresis y antirrebote de arranque.

Seguridad

⚠️ Lea esto primero: qué es y qué no es. Esto es una capa de comodidad y conveniencia, no un dispositivo de protección. Su interruptor automático sigue siendo el dispositivo de seguridad: nunca dimensione un circuito o una carga suponiendo que esta automatización actuará. Y el relé que conmuta debe estar dimensionado para la carga: un relé pequeño o un interruptor inteligente no pueden cortar 30–50 A directamente. Para un circuito de alta corriente, use el relé de baja corriente para accionar un contactor de calibre adecuado. Para trabajar dentro de un cuadro eléctrico, llame a un electricista cualificado.

Lo que va a construir

  • Un módulo rbAmp que mide la corriente de un circuito.
  • Un relé que dispara cuando la corriente se mantiene por encima de LIMIT_ON amperios y se libera por debajo de LIMIT_OFF (histéresis, para que no oscile en el punto de consigna).

  • Antirrebote de arranque: un breve retardo de sobrecarga sostenida, para que la punta de arranque de un motor o un hervidor no provoque un disparo molesto.

  • Alerta opcional con zumbador / LED. Todo local, en el bucle de Arduino.

Lista de materiales

Elemento Cant. Notas
rbAmp BASIC SCT-I1 1 la I1 de solo corriente es la opción ligera; un UI1 también sirve (su canal de tensión simplemente no se usa) · producto
CT SCT-013 1 calibre según el circuito · producto
Placa de desarrollo ESP32 (framework Arduino) 1 el objetivo verificado por compilación (portable a otras placas Arduino)
Módulo de relé 1 aislado, dimensionado para la carga, o accionando un contactor para alta corriente
Zumbador / LED (opcional) 1 alerta local

Conéctelo

El módulo rbAmp va en el bus I²C (SDA→GPIO21, SCL→GPIO22, VCC del rbAmp a 5 V, masa común; ¿por qué alimentación de 5 V con un bus de 3.3 V?). La entrada de control del módulo de relé va a GPIO26; ajuste RELAY_ACTIVE_HIGH en el boceto según su placa (muchas placas optoaisladas son activas en BAJO). Cablee la carga por el contacto NO del relé, de modo que un relé desenergizado signifique carga APAGADA. Un LED/zumbador opcional en GPIO25 se enciende mientras está disparado. Las CT se colocan alrededor del conductor del circuito: no invasivas en el lado de corriente.

La lógica: umbral, histéresis, antirrebote

Tres ideas evitan que se comporte mal:

  • Histéresis: dispare en LIMIT_ON (por ejemplo, 18 A) pero libere solo por debajo de LIMIT_OFF (por ejemplo, 15 A). Un único punto de consigna oscilaría cada vez que la carga se queda cerca de él; el hueco le da un margen para asentarse.

  • Antirrebote de arranque: exija que la corriente se mantenga por encima del límite durante unos segundos antes de disparar. Los motores, bombas y hervidores extraen una gran punta de arranque que supera el límite durante una fracción de segundo; no quiere disparar por eso.

  • El componente rbAmp lee el registro RMS de corriente del módulo en cada bucle (el módulo calcula el RMS internamente a unos 5 Hz, así que cada lectura es el valor de ventana más reciente): el Arduino lo compara con los límites y acciona el relé.

El boceto

Configure LIMIT_ON / LIMIT_OFF con sus amperios y MY_CT con su pinza, ajuste RELAY_ACTIVE_HIGH según su placa de relés, y grabe. ESP32 (framework Arduino) a 50 kHz; relé en GPIO26, alerta en 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 compilación en ESP32 con Arduino-CLI: solo Wire + RbAmp. El pin del relé se lleva al estado seguro de carga encendida en setup() antes de cualquier tráfico de bus, así que un begin() lento nunca lo deja flotando.)

Lo que hace el boceto

El núcleo es una máquina de tres estados (ARMED → OVER_PENDING → TRIPPED), evaluada una vez por muestra en loop(). Un par de pequeños auxiliares la mantienen limpia.

La salida segura por defecto

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() oculta la diferencia entre activo en alto y en bajo tras un único #define, de modo que el resto del código solo dice «carga encendida» o «carga apagada». Y setup() llama a relayLoadOn(true) antes de cualquier tráfico I²C, así que un begin() lento nunca puede dejar el pin del relé flotando.

La 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 arriba abajo:

  • ARMED: carga alimentada y vigilada. En cuanto la corriente alcanza LIMIT_ON, marca el momento del cruce y pasa a OVER_PENDING. Todavía no ha disparado.

  • OVER_PENDING: sigue alimentado, ahora en un cronómetro. Si la corriente vuelve a bajar de LIMIT_OFF (pasa una punta de arranque, o la carga se relaja) regresa a ARMED, sin disparo. Si sigue por encima del límite durante OVERLOAD_MS, desconecta: relé apagado, alerta activada, → TRIPPED.

  • TRIPPED: carga desconectada. Tras COOLDOWN_MS se rearma y vuelve a cerrar; si la sobrecarga sigue, simplemente dispara de nuevo.

Ese es todo el comportamiento relevante para la seguridad. La histéresis son los dos umbrales distintos (LIMIT_ON para disparar, y LIMIT_OFF, más bajo, para liberar); el antirrebote de arranque es la espera de OVERLOAD_MS, que la punta de arranque de un motor o de un hervidor supera sin problema. Una lectura transitoria de NaN mantiene el estado actual y omite la muestra, de modo que lectura errónea nunca puede provocar un disparo ni una liberación falsos. enter() registra cada transición en Serial con una marca de tiempo y la corriente actual.

¿Qué tan rápido es?

Local y rápido. El módulo actualiza su RMS de corriente unos cada 200 ms (~5 Hz); el Arduino la lee en cada bucle y, una vez que la sobrecarga se ha mantenido más allá de la ventana de antirrebote, conmuta el relé en la siguiente pasada del bucle: bastante menos de un segundo de latencia de decisión, sin HA ni nube en el camino. Esa es la ventaja de hacer el control en el mismo microcontrolador que lee el medidor.

Adáptelo a su instalación

  • Ajústelo: LIMIT_ON / LIMIT_OFF / OVERLOAD_MS / COOLDOWN_MS son constantes al principio; configúrelas para su circuito.

  • Rearme manual: en lugar de rearmarse automáticamente tras el enfriamiento, espere a un pulsador para que una persona despeje el disparo.

  • Prioridades: mida varios circuitos (la versión multimódulo) y desconecte primero la carga de menor prioridad para mantenerse por debajo de un límite de toda la vivienda.

  • Registre los disparos: escriba cada transición en una tarjeta SD para ver cuándo y con qué frecuencia se activó (la versión de registro).

  • Control proporcional: en lugar de un relé on/off duro, accione un dimmer TRIAC y mantenga una corriente objetivo con un bucle PID (un proyecto más grande: un avance para más adelante).

Lo que añada, mantenga el encuadre de arriba: esto sigue siendo una capa de conveniencia, no un dispositivo de protección.

Qué sigue

  • Registre lo ocurrido: escriba los eventos de disparo y la corriente periódica en una tarjeta SD o en CSV por puerto serie (próximo en esta serie).

  • ¿Lo quiere en Home Assistant? La versión de HA (deslizadores, alertas, desconexión por prioridad en todo el cuadro) es el control de carga en tiempo real con rbAmp.


Lea a continuación