⚠️ Lisez ceci d'abord — ce que c'est et ce que ce n'est pas. Il s'agit d'une couche de confort et de commodité, pas d'un dispositif de protection. Votre disjoncteur reste l'appareil de sécurité — ne dimensionnez jamais un circuit ni une charge en supposant que cette automatisation agira. Et le relais que vous commutez doit être dimensionné pour la charge : un petit relais ou un interrupteur connecté ne peut pas couper directement 30–50 A. Pour un circuit à fort courant, utilisez le relais à faible courant pour piloter un contacteur correctement dimensionné. Pour toute intervention dans un tableau électrique, faites appel à un électricien qualifié.
Ce que vous allez construire
- Un module rbAmp mesurant le courant d'un circuit.
-
Un relais qui se déclenche lorsque le courant reste au-dessus de
LIMIT_ONA et se relâche sousLIMIT_OFF(hystérésis, pour ne pas battre au niveau de consigne). -
Anti-rebond d'appel de courant — un court délai de surcharge durable pour qu'un appel au démarrage d'un moteur ou d'une bouilloire ne provoque pas de déclenchement intempestif.
- Alerte optionnelle par buzzer / LED. Tout est local, dans la boucle Arduino.
Nomenclature
| Élément | Qté | Remarques |
|---|---|---|
| rbAmp BASIC SCT-I1 | 1 | le courant seul I1 est le choix économique — un UI1 fonctionne aussi (sa voie de tension restera inutilisée) · produit |
| TC SCT-013 | 1 | calibre adapté au circuit · produit |
| Carte de développement ESP32 (framework Arduino) | 1 | la cible vérifiée à la compilation (portable sur d'autres cartes Arduino) |
| Module relais | 1 | isolé, dimensionné pour la charge — ou pilotant un contacteur pour les forts courants |
| Buzzer / LED (facultatif) | 1 | alerte locale |
Câblage
Le module rbAmp se place sur le bus I²C (SDA→GPIO21, SCL→GPIO22, VCC rbAmp 5 V, masse commune — pourquoi une alimentation 5 V avec un bus 3.3 V ?). L'entrée de commande du module relais va sur GPIO26 ; réglez RELAY_ACTIVE_HIGH dans le croquis pour correspondre à votre carte (beaucoup de cartes à isolation optique sont à état bas actif). Câblez la charge via le contact NO du relais, de sorte qu'un relais désénergisé signifie que la charge est ÉTEINTE. Une LED/buzzer optionnelle sur GPIO25 s'allume pendant le déclenchement. Les pinces TC se placent autour du conducteur du circuit — non invasives côté courant.
La logique : seuil, hystérésis, anti-rebond
Trois idées l'empêchent de mal se comporter :
-
Hystérésis — déclenchement à
LIMIT_ON(disons 18 A) mais relâchement seulement sousLIMIT_OFF(disons 15 A). Un seul seuil ferait battre la charge chaque fois qu'elle oscille autour de lui ; l'écart lui laisse de la place pour se stabiliser. -
Anti-rebond d'appel de courant — exige que le courant reste au-dessus de la limite pendant quelques secondes avant de déclencher. Les moteurs, pompes et bouilloires tirent un gros appel au démarrage, au-dessus de la limite pendant une fraction de seconde — vous ne voulez pas déclencher là-dessus.
-
Le composant rbAmp lit le registre RMS de courant du module à chaque boucle (le module calcule le RMS en interne à environ 5 Hz, donc chaque lecture est la dernière valeur fenêtrée) — l'Arduino compare la valeur aux limites et pilote le relais.
Le croquis
Réglez LIMIT_ON / LIMIT_OFF sur vos ampères et MY_CT sur votre pince, alignez RELAY_ACTIVE_HIGH sur votre carte relais, puis flashez. ESP32 (framework Arduino) à 50 kHz ; relais sur GPIO26, alerte sur 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;
}
}
(Compilation vérifiée sur ESP32 avec Arduino-CLI — Wire + RbAmp seulement. La broche du relais est pilotée à l'état sûr de charge ALLUMÉE dans setup() avant tout trafic sur le bus, de sorte qu'un begin() lent ne la laisse jamais flotter.)
Ce que fait le croquis
Le cœur du dispositif est une machine à trois états — ARMED → OVER_PENDING → TRIPPED — évaluée à chaque échantillon dans loop(). Quelques petites fonctions auxiliaires gardent le code clair.
La sortie sûre par défaut
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() masque la différence active-haute/active-basse derrière un seul #define, de sorte que le reste du code dit simplement « charge on » ou « charge off ». Et setup() appelle relayLoadOn(true) avant tout trafic I²C, pour qu'un begin() lent ne laisse jamais la broche du relais flotter.
La machine d'états — 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 haut en bas :
-
ARMED — charge alimentée, surveillance active. Dès que le courant atteint
LIMIT_ON, il horodate le franchissement et passe àOVER_PENDING. Il n'a pas encore déclenché. -
OVER_PENDING — toujours alimenté, désormais chronomètre en marche. Si le courant repasse sous
LIMIT_OFF(un appel de courant qui passe, ou la charge qui diminue), il revient à ARMED — pas de déclenchement. S'il reste au-dessus de la limite pendantOVERLOAD_MS, il délestage : relais coupé, alerte activée, → TRIPPED. -
TRIPPED — charge délestée. Après
COOLDOWN_MS, il se réarme et se referme ; si la surcharge persiste, il se déclenche à nouveau.
Voilà tout le comportement lié à la sécurité. L'hystérésis correspond aux deux seuils distincts (LIMIT_ON pour déclencher, LIMIT_OFF plus bas pour lever) ; l'anti-rebond d'appel de courant est l'attente OVERLOAD_MS, que l'appel de courant au démarrage d'un moteur ou d'une bouilloire traverse sans effet. Une lecture NaN passagère conserve l'état actuel et ignore l'échantillon : une mauvaise lecture ne peut donc jamais provoquer un déclenchement ou un relâchement erroné. enter() consigne chaque transition sur Serial avec un horodatage et le courant.
Quelle est sa rapidité ?
Local et rapide. Le module rafraîchit son RMS de courant environ toutes les 200 ms (~5 Hz) ; l'Arduino le lit à chaque boucle et, une fois le dépassement maintenu au-delà de la fenêtre d'anti-rebond, fait basculer le relais au passage suivant de la boucle — nettement moins d'une seconde de latence de décision, sans HA ni cloud dans le chemin. C'est l'avantage d'exécuter le contrôle sur le même microcontrôleur qui lit le compteur.
Adaptez-le à votre installation
-
Réglez-le —
LIMIT_ON/LIMIT_OFF/OVERLOAD_MS/COOLDOWN_MSsont tous des constantes en tête de fichier ; fixez-les pour votre circuit. -
Réarmement manuel — au lieu d'un réarmement automatique après le temps de refroidissement, attendez un bouton-poussoir pour qu'un humain lève le déclenchement.
-
Priorités — mesurez plusieurs circuits (le montage multimodule) et délestez d'abord la charge de plus basse priorité pour rester sous une limite de l'ensemble du logement.
-
Journalisez les déclenchements — écrivez chaque transition sur une carte SD pour voir quand et à quelle fréquence elle s'est produite (le montage d'enregistrement).
-
Régulation proportionnelle — au lieu d'un relais marche/arrêt strict, pilotez un gradateur TRIAC et maintenez un courant cible avec une boucle PID (un projet plus ambitieux — un avant-goût pour plus tard).
Quoi que vous ajoutiez, gardez le cadre ci-dessus : ceci reste une couche de confort, pas un dispositif de protection.
Pour aller plus loin
-
Journalisez ce qui s'est passé — écrivez les événements de déclenchement et le courant périodique sur une carte SD ou en CSV via le série (prochain de cette série).
-
Vous voulez plutôt l'avoir dans Home Assistant ? La version HA — curseurs, alertes, délestage prioritaire sur tout un tableau — est le contrôle de charge en temps réel avec rbAmp.