rbAmp
FR
Boutique
Docs
Mis à jour le · Modifier sur GitHub [Edit on GitHub]

03 · Choix du capteur de courant

Ce chapitre répond à deux questions :

  1. Quel capteur de courant choisir pour une charge donnée.
  2. Comment indiquer au module rbAmp votre choix afin que l'étalonnage d'usine pour cette combinaison se charge automatiquement.

Le raccordement physique du capteur (sens de la pince, vérification de la polarité L/N) est traité dans 04_hardware.md. Ce chapitre porte sur le choix du modèle et sur les appels d'API.

Comment la pince SCT-013 se monte sur le conducteur de phase, avec la flèche vers la charge.

Classe de capteur

Les modules rbAmp fonctionnent avec des pinces CT de la famille SCT-013. Vous devez indiquer une fois au module la classe du capteur, avec rbamp_set_sensor_class(dev, RBAMP_SENSOR_SCT013), avant de choisir un modèle précis de pince CT avec rbamp_set_ct_model().

Choisir le modèle SCT-013

Arbre de décision pour choisir le modèle SCT-013 à partir du plus fort courant attendu plus une marge de 30 pour cent.

La famille SCT-013 compte sept modèles qui diffèrent par le courant maximal du circuit primaire. Les sept codes {1, 2, 3, 4, 5, 6, 7} sont tous pris en charge.

code Modèle Plage de courant Statut Usage typique
1 SCT-013-005 0…5 A ✅ caractérisé Petites charges — lampes, électronique basse consommation, un simple interrupteur
2 SCT-013-010 0…10 A ✅ caractérisé Un appareil unique de puissance moyenne — réfrigérateur, lave-linge, climatiseur jusqu'à 2 kW
3 SCT-013-030 0…30 A ✅ caractérisé Entrée de service d'un logement de taille moyenne — jusqu'à ~7 kW
4 SCT-013-050 0…50 A ✅ caractérisé Grande entrée de service — chauffage électrique, borne de recharge VE, maison avec pointes de charge
5 SCT-013-100 0…100 A ✅ caractérisé Entrée de service principale d'une maison ou d'un petit bureau
6 SCT-013-020 0…20 A ✅ caractérisé Entrée de service moyenne — appareils de 3 à 4 kW, gros équipements domestiques
7 SCT-013-060 0…60 A ✅ caractérisé Sous-compteur industriel
Remarque

Codes acceptés — {1, 2, 3, 4, 5, 6, 7}. Un code hors de cet ensemble (par exemple 0 ou 8) passé à rbamp_set_ct_model_ch renvoie ESP_ERR_INVALID_ARG + REG_ERROR = 0xFE (ERR_PARAM). Voir 09 · Référence de l'API, section « Error model v1.3 », pour le détail de la façon dont le composant renvoie cette erreur.

Comment choisir le bon modèle

La règle de base :

  1. Déterminez le courant maximal susceptible de circuler dans le circuit (d'après la plus forte charge + une marge de 30 %).

  2. Choisissez le plus petit calibre supérieur à cette valeur.

  3. Ne surdimensionnez pas de plus de 5×. Une pince SCT-013-100 sur un circuit de 5 A maximum fonctionnera, mais avec une faible résolution et une grande erreur aux valeurs typiques.

Marge

Une pince SCT-013 fonctionne sans saturation dans sa plage nominale. Les pointes brèves (démarrage du compresseur, charge inductive) peuvent dépasser le calibre de 5 à 7× — c'est normal, la pince le supporte physiquement, mais la mesure devient non linéaire au-dessus du calibre.

Si votre charge a un courant de crête supérieur au calibre de la pince, choisissez la taille supérieure. Par exemple, pour un lave-linge avec un courant d'appel de 12 A (alors que son courant de fonctionnement est de 2–3 A) : 12 A × 1.3 = 15.6 A, donc la plus petite pince de calibre supérieur est la SCT-013-020 (code 6) — mieux que la SCT-013-005.

Comment indiquer votre choix au module

Deux appels sont obligatoires, dans le bon ordre : d'abord rbamp_set_sensor_class(), puis rbamp_set_ct_model(). Si vous appelez rbamp_set_ct_model() avant rbamp_set_sensor_class(), le composant renvoie ESP_ERR_INVALID_STATE et le préréglage n'est PAS chargé.

Remarque

Un modèle de CT est un préréglage fonctionnel, pas une étiquette. Écrire le modèle de CT applique immédiatement le plancher de bruit NF, le gain et le facteur de forme au circuit de mesure du module ; les lectures de courant changent. Modifier sensor_class remet le modèle de CT à sa valeur par défaut (0) et exige de le régler à nouveau.

C
#include "driver/i2c_master.h"
#include "rbamp.h"

void setup_sensor(rbamp_handle_t dev) {
    /* Step 1: select the sensor family.
     * MANDATORY before rbamp_set_ct_model(). */
    esp_err_t err = rbamp_set_sensor_class(dev, RBAMP_SENSOR_SCT013);
    if (err != ESP_OK) {
        ESP_LOGE("app", "set_sensor_class: %s", rbamp_err_to_str(err));
        return;
    }

    /* Step 2: select the model within the family.
     * 1 = SCT-013-005, 2 = SCT-013-010, 3 = SCT-013-030,
     * 4 = SCT-013-050, 5 = SCT-013-100, 6 = SCT-013-020, 7 = SCT-013-060. */
    err = rbamp_set_ct_model(dev, 3);   /* e.g. SCT-013-030 */
    if (err != ESP_OK) {
        /* Possible causes:
         *   ESP_ERR_INVALID_STATE — rbamp_set_sensor_class() was not called
         *                            before rbamp_set_ct_model()
         *   ESP_ERR_INVALID_ARG   — code not in {1,2,3,4,5,6,7}
         *   ESP_FAIL              — communication error (NACK after retry)
         */
        ESP_LOGE("app", "set_ct_model: %s", rbamp_err_to_str(err));
        return;
    }
}
Remarque

Le composant n'appelle délibérément PAS rbamp_set_sensor_class() à votre place. Si cette étape est sautée, rbamp_set_ct_model() renvoie ESP_ERR_INVALID_STATE sans rien écrire en flash. C'est fait pour garder un comportement prévisible et explicite — pas de « magie » dans l'API publique.

Après ces deux appels :

  • Le module enregistre les deux valeurs en flash — le réglage survit à une réinitialisation, à une coupure d'alimentation et à un reflashage du firmware.

  • Les coefficients de calibration pour cette combinaison précise (classe de capteur + modèle) sont chargés depuis la table de préréglages d'usine. Vous n'avez pas à toucher aux registres de calibration manuels.

  • L'appel suivant rbamp_read_current(dev, 0, &i) renvoie déjà une valeur en ampères, correctement mise à l'échelle.

Temps total pour les deux appels : environ 1.4 seconde (deux opérations d'écriture en flash × ~700 ms chacune, limitées par le temps d'effacement de la page flash). Cela se fait une seule fois à la première installation ; le réglage est stocké en flash et n'est jamais répété.

Remarque

Si vous avez déjà sélectionné le capteur au premier démarrage et que vous redémarrez simplement l'ESP32, vous n'avez pas besoin de répéter les appels rbamp_set_sensor_class() et rbamp_set_ct_model() — le module conserve le choix précédent. Cela ne pose toutefois aucun problème : un nouvel appel avec la même valeur réécrit simplement le même octet.

Vérifier la configuration

Un simple contrôle de cohérence après rbamp_set_ct_model() :

C
#include 
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

static const char *TAG = "rbamp_check";

void sanity_check(rbamp_handle_t dev) {
    ESP_LOGI(TAG, "Ready. Connect a purely resistive load "
                  "(e.g. an incandescent lamp).");
    ESP_LOGI(TAG, "Expect a stable PF ~= 1.0 and positive P.");

    while (1) {
        float u = NAN, i = NAN, p = NAN, pf = NAN;
        rbamp_read_voltage(dev, 0, &u);
        rbamp_read_current(dev, 0, &i);
        rbamp_read_power(dev, 0, &p);
        rbamp_read_power_factor(dev, 0, &pf);

        ESP_LOGI(TAG, "U=%.1f V  I=%.2f A  P=%.1f W  PF=%.2f",
                 (double)u, (double)i, (double)p, (double)pf);
        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

Sur une charge purement résistive (lampe à incandescence, bouilloire électrique, élément chauffant), vous devez attendre :

  • U ≈ 220–240 V (pour un secteur 230 V)
  • I ≈ correspond à la puissance de la charge (P / U)
  • P > 0 et stable
  • PF ≈ 1.0 (nettement positif)

Si quelque chose ne colle pas, voir 10_troubleshooting.md.

Modules à plusieurs canaux de courant

Gamme de références — ce qui convient à la tâche

SKU I-channels Canal U Usage typique
UI1 1 oui Une charge unique avec calcul de puissance complet (P, PF, Q, Wh) — le compteur secteur typique
UI2 2 oui Deux charges indépendantes sur une même phase avec une puissance par canal (1 U + 2 I)
UI3 3 oui Trois charges sur une phase avec puissance par canal (1 U + 3 I)
I1 1 non Sous-compteur sans calcul de puissance (courant seulement) — lorsque le comptage secteur est assuré par un UI1 séparé
I2 2 non Sous-compteur de courant à deux canaux — répartition par circuit
I3 3 non Sous-compteur de courant à trois canaux — répartition par circuit / topologie à double TC

Ce que mesure chaque canal

  • Voie U (UI seulement) : U_rms, U_peak, fréquence. Une* par module (liée à la phase d'entrée).
  • I-channels:
  • sur les variantes UI — chaque canal fournit I_rms, I_peak, P (puissance active), PF, avg_p sur la période.
  • sur les variantes I — courant seul (I_rms, I_peak). La puissance active et le PF ne sont pas calculés : ils exigent une tension, dont la variante I est dépourvue. Les registres power[]/power_factor[] sur les variantes I renvoient 0.
  • Multiphasé ou multi-points : le module ne distingue PAS la phase à laquelle chaque canal I est raccordé. Cette sémantique relève du côté maître.

Modèle de CT par canal — étalonnage indépendant par canal

Sur les modules multicanaux (I2, I3), chaque canal de courant a un choix indépendant de modèle de pince SCT-013. Vous pouvez par exemple connecter une SCT-013-005 au canal 0 (une seule prise), une SCT-013-030 au canal 1 (le circuit de la cuisinière électrique) et une SCT-013-020 au canal 2 (un chauffe-eau ou une chaudière).

L'API de sélection par canal est rbamp_set_ct_model_ch(dev, channel, code) :

C
rbamp_set_sensor_class(dev, RBAMP_SENSOR_SCT013);   /* once for all */

/* v1.3: channel binding order is arbitrary. */
rbamp_set_ct_model_ch(dev, 0, 1);   /* channel 0: SCT-013-005 */
rbamp_set_ct_model_ch(dev, 1, 3);   /* channel 1: SCT-013-030 */
rbamp_set_ct_model_ch(dev, 2, 6);   /* channel 2: SCT-013-020 */
Remarque

✅ L'ordre de liaison est indifférent (canon v1.3). Écrire REG_CT_MODEL (0x05) met la valeur en attente mais ne l'applique à aucun canal automatiquement. L'application se fait uniquement via CMD_SET_CT_MODEL_CHn par canal, qui prend la valeur actuellement en attente et l'écrit sur son propre canal. Les canaux peuvent être configurés dans n'importe quel ordre (ch0 d'abord, en dernier, entrelacés — cela ne change rien) ; aucun écrasement ne se produit. Toute mention de « croissant / décroissant / lier ch0 en dernier » dans les anciens documents et codes se rapporte au comportement d'avant la v1.3 — elle peut être supprimée.

Chaque canal se lie en deux étapes : (1) écrire le modèle dans REG_CT_MODEL (préparation), (2) CMD_SET_CT_MODEL_CHn (liaison). La validation (classe, modèle) est effectuée par le firmware à l'étape de liaison.

Si plusieurs canaux reçoivent le même modèle, vous pouvez appeler avec le même code — l'application répétée est idempotente :

C
rbamp_set_sensor_class(dev, RBAMP_SENSOR_SCT013);
rbamp_set_ct_model_ch(dev, 0, 1);
rbamp_set_ct_model_ch(dev, 1, 1);
rbamp_set_ct_model_ch(dev, 2, 1);

Une alternative pour le cas typique I2/I3 est rbamp_configure_channels(dev, class, models[], n) : une seule opération configure la classe + tous les canaux + enregistre le tout en flash avec un seul CMD_SAVE_USER_CONFIG terminal (ménagé pour la flash — un cycle d'effacement au lieu de N). Voir le chapitre 09 · Référence de l'API, section « Multi-channel configuration ».

La forme à paramètre unique rbamp_set_ct_model(dev, code) est une forme pratique pour les références à canal unique (appliquée au canal 0). Sur les modules multi-canaux, elle équivaut à rbamp_set_ct_model_ch(dev, 0, code).

Configuration avancée : deux pinces de calibres différents sur un même fil

Remarque

⚙ Un motif supplémentaire, non de base. Cette section décrit une technique facultative pour améliorer la résolution aux faibles courants. Pour la plupart des installations, une seule pince dimensionnée à la plage de charge suffit. N'utilisez le double CT que si vous avez une exigence de précision précise pour des courants < 1 A.

Quand ça s'applique

  • Modules multi-canaux I2 / I3 (matériel actuel).
  • Le même fil doit être mesuré à la fois pour les petites charges (≤ 1 A) et pour les pointes (≥ 5 A) avec une qualité égale.

  • Un exemple type : l'entrée de service d'un appartement, où l'on a 50–100 W de veille le jour et l'appel de courant d'une bouilloire ou d'une plaque électrique de 3 kW et plus le soir.

L'idée

Deux pinces SCT-013 de calibres différents sont montées sur le même fil :

Deux pinces de calibres différents installées sur le même conducteur d'un module.

  • Canal 0 — la petite pince (par exemple SCT-013-005, 5 A) : perçoit les petits courants avec une meilleure résolution et un plancher de bruit plus bas.

  • Canal 1 — la grande pince (par ex. SCT-013-030 ou plus) : elle traite les courants au-dessus du point de surcharge de la petite pince sans saturation.

Le maître choisit lui-même le canal à utiliser selon la valeur du courant — tant que la petite pince est dans sa plage linéaire, sa lecture est plus précise ; au-delà, il bascule sur la grande.

Configuration

La classe de capteur une fois, puis les modèles par canal dans l'ordre souhaité (v1.3 préparation pure, l'ordre n'a pas d'importance) :

C
rbamp_set_sensor_class(dev, RBAMP_SENSOR_SCT013);   /* once */

rbamp_set_ct_model_ch(dev, 0, 1);   /* ch0 = SCT-013-005 (0..5 A)  — small clamp */
rbamp_set_ct_model_ch(dev, 1, 3);   /* ch1 = SCT-013-030 (0..30 A) — large clamp */

État final : ch0 = SCT-013-005, ch1 = SCT-013-030. ✓

Une alternative via rbamp_configure_channels() — une opération au lieu de deux :

C
uint8_t models[2] = { 1, 3 };   /* ch0=5A, ch1=30A */
rbamp_configure_channels(dev, RBAMP_SENSOR_SCT013, models, 2);

Logique d'agrégation côté maître

Le modèle le plus simple consiste à commuter sur un seuil :

C
float read_combined_current(rbamp_handle_t dev) {
    float i_low  = NAN;
    float i_high = NAN;
    esp_err_t err_low  = rbamp_read_current(dev, 0, &i_low);   /* small */
    esp_err_t err_high = rbamp_read_current(dev, 1, &i_high);  /* large */

    /* While the small clamp is far from saturation, it gives better
     * accuracy at small currents. Switch to the large one as it
     * approaches the overload point.
     *
     * The 4.5 A threshold for the SCT-013-005 is an example value;
     * figures for low-current dual-CT use are not published. */
    if (err_low == ESP_OK && i_low < 4.5f) {
        return i_low;
    }
    return (err_high == ESP_OK) ? i_high : NAN;
}
Remarque

Deux pinces sur un même fil sont physiquement possibles sur la plupart des câbles de calibre domestique, mais elles demandent un peu de place dans le tableau.

⚙ Chiffres du double CT. Les chiffres pour un usage en double CT à faible courant (comportement près du seuil, divergence des deux pinces dans la plage de recouvrement) ne sont pas publiés. Considérez le double CT comme un schéma pilote ; pour les applications critiques, une seule pince dimensionnée à la plage de charge haute est préférable.

Modules multi-canaux — I2 et I3 (courant seul)

Les modules à courant seul pour la topologie multicanal sont I2 (deux canaux de courant) et I3 (trois canaux de courant). Les deux modules n'ont pas de voie U, donc le calcul de P / PF / Q côté module est impossible — ils fournissent le courant par canal (I_rms, I_peak sur chaque canal) et rien de plus.

UI2 et UI3 ajoutent le canal U (1 U + 2 I / 1 U + 3 I), si bien que la puissance par canal est calculée sur le module. Lorsque seule une répartition du courant est nécessaire, utilisez les I2/I3 comme sous-compteurs de courant, avec un UI1 séparé à l'entrée de service, qui fournit l'énergie et la tension du secteur.

Lecture des canaux (I2 / I3)

C
float i0, i1, i2;
rbamp_read_current(dev, 0, &i0);   /* ch0 */
rbamp_read_current(dev, 1, &i1);   /* ch1 */
rbamp_read_current(dev, 2, &i2);   /* ch2 — I3 only */

/* On an I variant rbamp_read_power(...) returns 0 — this is by design. */
float p_dummy; rbamp_read_power(dev, 0, &p_dummy); /* = 0.0f */

Si vous avez besoin de la puissance active sur chaque sous-ligne, placez un UI1 à l'entrée de service et répartissez sa puissance totale proportionnellement au courant par canal I[k] fourni par les I2/I3. C'est le déploiement domestique typique :

C
/* Pseudo-pattern: UI1 on mains, I3 on 3 sub-lines */
float p_mains_total, i0, i1, i2;
rbamp_read_power(mains_ui1, 0, &p_mains_total);
rbamp_read_current(loads_i3, 0, &i0);
rbamp_read_current(loads_i3, 1, &i1);
rbamp_read_current(loads_i3, 2, &i2);
float i_sum = i0 + i1 + i2;
if (i_sum > 0.01f) {
    float p0 = p_mains_total * i0 / i_sum;   /* approximation */
    /* ... */
}
Remarque

C'est une approximation : la répartition par courant fonctionne lorsque le facteur de puissance est à peu près le même pour toutes les charges. Pour une comptabilité précise de la puissance par charge, utilisez une variante UI (UI1 / UI2 / UI3 / UI5 / UI7) sur chaque ligne.

Applications de I2 / I3

  • Sous-comptage de courant : répartition du courant par circuit, un seul point d'installation au tableau au lieu d'un module par ligne.

  • Désagrégation avec un UI1 : l'UI1 fournit l'énergie / la puissance du secteur, et les I2/I3 répartissent la consommation par branche (voir chapitre 06, scénario 1).

  • Surveillance du courant sans comptabilisation de puissance : contrôle de surcharge, détection de mise en marche / arrêt de charge, profil I(t).

  • Double CT + un troisième canal (I3) : une grosse pince sur le canal 0 pour une large plage, une petite sur le canal 1 pour la précision aux faibles courants, le troisième canal pour une ligne auxiliaire distincte. Voir la section « Advanced setup: two clamps of different ratings » (configuration avancée : deux pinces de calibres différents) ci-dessus.

Calcul de la puissance côté maître :

C
float i;
rbamp_read_current(dev, ch, &i);

/* If the voltage is known (from a UI module upstream or fixed) */
const float U_nominal = 230.0f;
float p_estimated = U_nominal * i;   /* without PF — guaranteed overestimate */

Pour une comptabilisation précise de la puissance, utilisez un module UI (avec un canal U).

Approches pour améliorer la sensibilité aux faibles courants

Si votre charge a une grande plage dynamique (par ex. 1 W de veille pour un routeur contre un chauffe-eau de 2000 W sur la même prise), une seule pince dimensionnée pour la limite haute perd les courants faibles dans le bruit.

Trois stratégies, par ordre de complexité croissante :

  1. Dimensionnez la pince au maximum, pas « avec de la marge ». L'erreur la plus courante est de mettre une SCT-013-100 (100 A) sur une prise domestique dont la consommation typique est de 0.5 à 10 A. Le signal se situe dans les 1 à 10 % inférieurs de la plage du capteur — là où le bruit devient comparable au signal. Pour le scénario domestique (prise de 16 A), la SCT-013-030 est optimale ; pour raccorder un seul appareil (≤ 5 A), la SCT-013-005.

  2. Topologie à double CT (nécessite une référence I2/I3 — deux canaux de courant sur un même module) : une petite pince pour la plage basse + une grande pour la plage haute, le maître sélectionnant selon un seuil. Voir la section « Topologie à double CT » ci-dessus — le motif est un pilote ; les chiffres pour l'usage en double CT à faible courant ne sont pas publiés.

  3. Plancher de bruit (côté fabrication) : la calibration du module en tient déjà compte. Côté utilisateur, il n'y a rien à faire au-delà de setSensorClass() + setCTModel(). Les précisions chiffrées aux faibles courants ne sont pas publiées.

Mode production et mode usine (référence de persistance)

Le module rbAmp fonctionne selon deux modes qui diffèrent par ce qui est exactement enregistré en flash. Le mode en cours est lu dans le registre d'état correspondant du module.

Commande (opcode) Production Persiste
CMD_SAVE_USER_CONFIG (0x32) ✅ OK ct_model / sensor_class / fleet_config / group_id / label
CMD_COMMIT_ADDR (0x30, armé par magic) ✅ OK Adresse I²C (voir 04 · Câblage — changement d'adresse)
CMD_RESET (0x01) ✅ OK — (réinitialisation logicielle)
CMD_LATCH_PERIOD (0x27) ✅ OK — (instantané de période)
CMD_CLEAR_ERROR ✅ OK —
CMD_SAVE_GAINS ❌ BLOQUÉ en production (renvoie ERR_PARAM) gains / NF / phase (calibration d'usine)
CMD_FACTORY_RESET ❌ BLOQUÉ en production —

En mode production, les écritures de la calibration d'usine (CMD_SAVE_GAINS, CMD_FACTORY_RESET) sont rejetées par le firmware — cela protège contre l'effacement accidentel des coefficients d'usine. Le passage en mode usine est une opération côté fabricant ; les utilisateurs finaux n'en ont pas besoin.

Relecture ≠ persistance

La garde de production accepte une écriture en RAM (une lecture ultérieure renvoie la valeur écrite), mais la sauvegarde en flash peut être rejetée. Après un redémarrage, la valeur revient à l'état antérieur à l'écriture. La seule façon valide de confirmer la persistance est de redémarrer le module via CMD_RESET puis de relire :

C
rbamp_set_ct_model(dev, code);
rbamp_reset(dev);                       // CMD_RESET 0x01, works in production
vTaskDelay(pdMS_TO_TICKS(400));         // boot complete
uint8_t check; rbamp_read_ct_model(dev, 0, ✓);
assert(check == code);                  // ONLY now is persistence confirmed

Renvoi : 09 · Référence API — détails sur des opcodes précis ; 10 · Diagnostic — que faire si la persistance n'est pas confirmée.

Suite


Source et problèmes : rb-amp/rbamp-esp-idf · cette page dans le dépôt : docs/03_sensor_selection.md (v1.7.3)