rbAmp
DE
Shop

Projekt · · 14 Min. Lesezeit

Lokale Stromgrenze mit Arduino — einen Relais auslösen, bevor der Leitungsschutzschalter es tut, ohne Cloud

Lesen Sie den Strom eines Stromkreises mit einem rbAmp-Modul und lösen Sie lokal ein Relais aus, sobald er Ihren Grenzwert überschreitet — unter einer Sekunde, mit Hysterese und Einschaltstrom-Entprellung.

Sicherheit

⚠️ Lesen Sie dies zuerst — was das ist und was nicht. Das ist eine Komfort- und Bequemlichkeitsschicht, kein Schutzgerät. Ihr Leitungsschutzschalter bleibt das Sicherheitsgerät — dimensionieren Sie niemals einen Stromkreis oder eine Last in der Annahme, dass diese Automatisierung eingreift. Und das Relais, das Sie schalten, muss für die Last ausgelegt sein: Ein kleines Relais oder ein Smart-Schalter kann 30–50 A nicht direkt schalten. Für einen Stromkreis mit hohem Strom steuert das Relais mit niedrigem Strom ein passend dimensioniertes Schütz an. Für Arbeiten im Inneren eines Elektroverteilers sollten Sie eine qualifizierte Elektrofachkraft hinzuziehen.

Was Sie bauen werden

  • Ein rbAmp-Modul, das den Strom eines Stromkreises misst.
  • Ein Relais, das auslöst, wenn der Strom länger als LIMIT_ON Ampere über dem Grenzwert bleibt, und unterhalb von LIMIT_OFF wieder freigibt (Hysterese, damit es am Sollwert nicht flattert).

  • Einschaltstrom-Entprellung — eine kurze Verzögerung bei anhaltender Überlast, damit der Einschaltstoß eines Motors oder Wasserkochers keine Fehlauslösung verursacht.

  • Optionaler Summer / LED-Alarm. Alles lokal, in der Arduino-Schleife.

Stückliste

Position Menge Hinweise
rbAmp BASIC SCT-I1 1 nur Strom, I1 ist die schlanke Wahl — ein UI1 funktioniert ebenfalls (sein Spannungskanal bleibt ungenutzt) · Produkt
SCT-013-CT 1 Nennwert passend zum Stromkreis · Produkt
ESP32-Entwicklungsboard (Arduino-Framework) 1 das kompilierte Zielsystem (übertragbar auf andere Arduino-Boards)
Relaismodul 1 isoliert, für die Last ausgelegt — oder ein Schütz für hohe Ströme ansteuernd
Summer / LED (optional) 1 lokaler Alarm

Verdrahten

Das rbAmp-Modul sitzt am I²C-Bus (SDA→GPIO21, SCL→GPIO22, rbAmp VCC 5 V, gemeinsame Masse — warum 5 V-Versorgung, aber ein 3.3-V-Bus?). Der Steuereingang des Relaismoduls geht an GPIO26; stellen Sie RELAY_ACTIVE_HIGH im Sketch auf Ihre Platine ein (viele optoentkoppelte Platinen sind aktiv-LOW). Verdrahten Sie die Last über den Schließer-Kontakt des Relais, sodass ein stromloses Relais bedeutet, dass die Last AUS ist. Eine optionale LED/Summer an GPIO25 leuchtet im ausgelösten Zustand. Die CT-Zange legt sich um den Stromkreisleiter — berührungslos auf der Stromseite.

Die Logik: Schwellwert, Hysterese, Entprellung

Drei Ideen verhindern, dass es sich falsch verhält:

  • Hysterese — bei LIMIT_ON (z. B. 18 A) auslösen, aber erst unterhalb von LIMIT_OFF (z. B. 15 A) wieder freigeben. Ein einziger Sollwert würde jedes Mal flattern, wenn die Last nahe daran schwankt; die Lücke gibt ihr Raum zum Einpendeln.

  • Einschaltstrom-Entprellung — verlangen Sie, dass der Strom einige Sekunden über dem Grenzwert bleibt, bevor ausgelöst wird. Motoren, Pumpen und Wasserkocher ziehen einen großen Einschaltstoß, der nur einen Bruchteil einer Sekunde über dem Grenzwert liegt — darauf wollen Sie nicht auslösen.

  • Die rbAmp-Komponente liest das RMS-Stromregister des Moduls in jeder Schleife (das Modul berechnet den RMS intern mit etwa 5 Hz, sodass jeder Lesevorgang der neueste Fensterwert ist) — der Arduino vergleicht ihn mit den Grenzwerten und steuert das Relais an.

Der Sketch

Setzen Sie LIMIT_ON / LIMIT_OFF auf Ihre Ampere-Werte und MY_CT auf Ihre Zange, stimmen Sie RELAY_ACTIVE_HIGH auf Ihre Relaisplatine ab und flashen Sie. ESP32 (Arduino-Framework) mit 50 kHz; Relais an GPIO26, Alarm an 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;
    }
}

(Auf ESP32 mit Arduino-CLI kompiliert geprüft — Wire + RbAmp allein. Der Relais-Pin wird in setup() vor jedem Bus-Verkehr in den sicheren Zustand „Last ein“ gesteuert, daher bleibt er bei einem langsamen begin() nie schwebend.)

Was der Sketch macht

Das Herzstück ist eine Zustandsmaschine mit drei Zuständen — ARMED → OVER_PENDING → TRIPPED — die einmal pro Messung in loop() ausgewertet wird. Ein paar kleine Hilfsfunktionen halten sie übersichtlich.

Die standardmäßig sichere Ausgabe

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() verbirgt den Unterschied zwischen aktiv-high und aktiv-low hinter einem #define, sodass der restliche Code nur „Last ein“ oder „Last aus“ sagt. Und setup() ruft relayLoadOn(true) vor jedem I²C-Verkehr auf, damit ein langsames begin() nie einen schwebenden Relais-Pin hinterlassen kann.

Die Zustandsmaschine — 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;
}

Von oben nach unten:

  • ARMED — Last eingeschaltet, wird beobachtet. In dem Moment, in dem der Strom LIMIT_ON erreicht, wird der Übergang mit Zeitstempel versehen und in OVER_PENDING gewechselt. Es hat noch nicht ausgelöst.

  • OVER_PENDING — weiterhin unter Spannung, jetzt mit einer Stoppuhr. Fällt der Strom wieder unter LIMIT_OFF (ein vorübergehender Einschaltstoß klingt ab oder die Last lässt nach), kehrt es zu ARMED zurück — keine Auslösung. Bleibt er länger als OVERLOAD_MS über dem Grenzwert, schaltet er ab: Relais aus, Alarm an, → TRIPPED.

  • TRIPPED — Last abgeschaltet. Nach COOLDOWN_MS wird wieder scharf geschaltet; besteht die Überlast noch, löst es einfach erneut aus.

Das ist das gesamte sicherheitsrelevante Verhalten. Die Hysterese sind die zwei unterschiedlichen Schwellwerte (LIMIT_ON zum Auslösen, niedrigeres LIMIT_OFF zum Zurücksetzen); die Einschaltstrom-Entprellung ist die Wartezeit OVERLOAD_MS, über die der Einschaltstoß eines Motors oder Wasserkochers hinwegkommt. Ein vorübergehender NaN-Messwert hält den aktuellen Zustand und überspringt die Probe, sodass ein fehlerhafter Messwert niemals eine Fehlauslösung oder ein Fehlfreigeben verursachen kann. enter() protokolliert jeden Übergang mit Zeitstempel und aktuellem Strom auf Serial.

Wie schnell ist es?

Lokal und schnell. Das Modul aktualisiert seinen RMS-Strom etwa alle 200 ms (~5 Hz); der Arduino liest ihn in jedem Schleifendurchlauf, und sobald die Überlast die Entprellzeit überschritten hat, schaltet er das Relais im nächsten Schleifendurchlauf — deutlich unter einer Sekunde Entscheidungslatenz, ohne HA oder Cloud im Pfad. Das ist der Vorteil, Steuerung auf demselben Mikrocontroller auszuführen, der den Zähler liest.

Passen Sie es an Ihre Bedürfnisse an

  • Abstimmen — LIMIT_ON / LIMIT_OFF / OVERLOAD_MS / COOLDOWN_MS sind alle Konstanten am Anfang; setzen Sie sie für Ihren Stromkreis.

  • Manuelles Zurücksetzen — statt nach der Abkühlzeit automatisch wieder scharf zu schalten, auf einen Taster warten, damit ein Mensch die Auslösung quittiert.

  • Prioritäten — mehrere Stromkreise messen (der Mehrmodul-Aufbau) und zuerst die Last mit der niedrigsten Priorität abschalten, um unter einem Gesamthausgrenzwert zu bleiben.

  • Die Auslösungen protokollieren — jeden Übergang auf eine SD-Karte schreiben, damit Sie sehen, wann und wie oft er ausgelöst hat (der Logger-Aufbau).

  • Proportionale Regelung — statt eines harten Ein/Aus-Relais einen TRIAC-Dimmer ansteuern und mit einer PID-Regelschleife einen Zielstrom halten (ein größeres Projekt — ein Vorgeschmack für später).

Was immer Sie ergänzen, behalten Sie den obigen Rahmen bei: Das bleibt eine Komfortschicht, kein Schutzgerät.

Wie es weitergeht

  • Protokollieren, was passiert ist — die Auslöseereignisse und den periodischen Strom auf eine SD-Karte oder CSV über seriell schreiben (als Nächstes in dieser Reihe).

  • Lieber in Home Assistant? Die HA-Version — Schieber, Alarme, prioritätsbasiertes Abschalten über den gesamten Verteiler — ist Echtzeit-Laststeuerung mit rbAmp.


Als Nächstes lesen