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

04 · Câblage

Ce chapitre traite du raccordement physique du module rbAmp à un hôte compatible Arduino : brochage côté basse tension, exigences d'alimentation, compatibilité des niveaux I²C, longueur du bus et schémas de câblage pour des cartes Arduino précises (UNO, Mega, ESP32, ESP8266, STM32duino, RP2040).

Le côté basse tension (alimentation + I²C + DRDY facultative) est isolé des bornes secteur. Les bornes secteur et le câblage côté TC sont reliés au secteur — voir l'avertissement dans « Câblage côté secteur » ci-dessous.

Brochage côté basse tension

Le module fonctionne en logique I²C 3.3 V et tolère 5 V sur les lignes de signal. Toutes les broches basse tension sont entièrement isolées galvaniquement du secteur.

Broche Signal Fonction
VCC +5 V (4.5..5.5 V) Alimentation du module ; 4.5 V minimum pour un fonctionnement correct
GND Terre Partagé avec le maître — obligatoire
SDA SDA I²C Données I²C
SCL I²C SCL Horloge I²C
DRDY Données prêtes (facultatif) Drain ouvert, impulsion LOW d'environ 10 µs toutes les ~100 ms

Le connecteur basse tension du module rbAmp : VCC, GND, SDA, SCL et la broche DRDY facultative, avec ce dont chacune a besoin.

Puissance

Paramètres de VCC

  • Tension nominale : 5 V CC
  • Plage admissible : 4.5..5.5 V
  • Courant d'alimentation : ~15 mA typique, ~25 mA en pointe pendant les écritures en flash
  • Ondulation : < 50 mV crête à crête (pour la précision de mesure)

Le module embarque un régulateur, un filtre RC, des condensateurs céramiques et une perle de ferrite — aucun filtrage supplémentaire n'est requis de la part de l'utilisateur. Le module peut être alimenté depuis le rail +5V de n'importe quelle carte Arduino (UNO, ESP32 DevKitC, etc.).

Compatibilité des niveaux I²C

  • SDA / SCL fonctionnent en logique 3.3 V (les résistances de rappel intégrées tirent les lignes à 3.3 V).

  • Les lignes sont tolérantes 5 V : un maître 5 V (Arduino UNO / Nano) lit HIGH (~3.3 V) correctement et peut piloter le bus sans convertisseur de niveau.

  • Pour un bus fonctionnant entièrement en niveaux 5 V — désactivez les résistances de rappel intégrées (voir ci-dessous) et ajoutez des résistances de rappel externes vers +5 V côté maître.

Comportement à la mise sous tension

  • Démarrage à froid : ~250 ms jusqu'au premier résultat valide.
  • Après une réinitialisation (logicielle ou coupure de tension) : environ 250 ms pour reprendre.
  • Jusqu'au premier résultat valide, les registres lisent 0 et DATA_VALID = 0.

La bibliothèque attend que le module soit prêt à l'intérieur de dev.begin() — votre code appelle simplement begin() et poursuit.

Isolation

Le côté basse tension (I²C, alimentation, DRDY) est isolé des bornes secteur. Considérez les bornes secteur et le câblage côté TC comme sous tension.

  • La GND du module n'est pas reliée au secteur ni au neutre.
  • Ne touchez pas aux bornes L/N ni au conducteur de la pince tant que le circuit est sous tension.
Sécurité

⚠ N'ouvrez pas le boîtier du module — cela annule la calibration d'usine.

Résistances de rappel intégrées

Important : chaque module rbAmp est livré avec des résistances de rappel intégrées de 4.7 kΩ sur SDA et SCL vers 3.3 V. Pour un seul module sur le bus, les résistances de rappel externes ne sont pas nécessaires — connectez le maître directement.

Quand désactiver les résistances de rappel intégrées

Si le bus compte plusieurs modules rbAmp (ou d'autres appareils I²C avec leurs propres résistances de rappel), les connecter en parallèle donne une résistance effective trop faible, ce qui :

  • Augmente la consommation du bus
  • Peut dépasser le courant de puits maximal de l'étage de sortie du maître I²C (typiquement ≤ 3 mA en logique 3.3 V)

  • Ajoute une charge capacitive sur un long bus tout en améliorant peu l'immunité au bruit

Solution : sur la face inférieure de la carte, près des résistances de rappel, se trouvent des straps de pontage (sérigraphie Pull-Up). Coupez-les avec une lame fine pour désactiver une résistance de rappel :

  • Laissez les résistances de rappel activées sur un seul module (ou déplacez-les sur un point unique, près du maître).

  • Coupez les straps sur les modules restants.

  • Si des résistances de rappel sont déjà présentes sur la carte maître — coupez les straps sur tous les modules rbAmp.

Règle empirique

modules rbAmp sur le bus Résistances de rappel
1 À laisser tel quel (les 4.7 kΩ intégrées conviennent)
2 Laissez-en un branché, coupez l'autre
3 Coupées sur tous les modules, posez une paire externe de 2.7…3.3 kΩ près du maître
4…6 Coupées sur tous les modules, une paire externe de 2.2…2.7 kΩ près du maître
7…16 Coupées sur tous les modules, une paire externe de 1.5…2.2 kΩ près du maître ; vérifiez la capacité du bus (≤ 400 pF), abaissez la vitesse du bus si nécessaire

Les valeurs externes sont des valeurs recommandées (calculées à partir de la spécification I²C : courant absorbé ≤ 3 mA à 3.3 V, capacité du bus ≤ 400 pF). Reliez les résistances de rappel externes à 3.3 V (le niveau logique du bus), et non à l'alimentation VCC 5 V.

En cas de doute

: mesurez la résistance entre SDA et VCC, appareils hors tension. Elle doit être dans la plage 1.5..4.7 kΩ. Une valeur inférieure signifie trop de résistances de rappel actives en parallèle.

Combien de modules sont sur le bus et quelles résistances de rappel I²C restent : gardez les paires intégrées pour un à trois modules sur un bus d'au plus 15 cm ; à partir de quatre modules, ou sur un bus plus long, coupez-les toutes et utilisez une seule paire externe.

Paramètres du bus I²C

  • Adresse par défaut : 0x50 (7 bits)
  • Plage d'adresses : 0x08..0x77 (réaffectée par validation d'adresse en deux phases, adaptée à la production)
  • Vitesse : UNO / Mega / STM32 / RP2040 100 kHz ; ESP32 / ESP8266 50 kHz. N'utilisez pas 400 kHz.
  • Incrémentation automatique du pointeur : uniquement en lecture. Une lecture par rafale de + N octets renvoie N octets consécutifs à partir de addr. Les écritures ne sont PAS à incrémentation automatique : une écriture en rafale ignore les octets 1..N et seul le premier est écrit. Les registres multi-octets s'écrivent octet par octet, dans des transactions distinctes d'un octet. Voir 09 · Référence API — « Écritures multi-octets ».

Longueur du bus

I²C est un bus court (environ 15 cm par défaut). Beaucoup d'utilisateurs connectent les modules avec des fils de liaison de mauvaise qualité, qui captent beaucoup de bruit et perdent de nombreux transferts — d'où la limite courte. Topologies recommandées pour rbAmp :

Câble Longueur maximale Vitesse
JST standard / 4 conducteurs plats jusqu'à 0.15 m 100 kHz
Paire torsadée UTP (cat-5/5e/6) — SDA+GND et SCL+GND dans des paires séparées jusqu'à 1 m 100 kHz
Paire torsadée + tampon I²C (PCA9515 / TCA9617) jusqu'à 3 m 100 kHz
Bus différentiel (PCA9615 / LTC4332) jusqu'à 100 m 100 kHz
Sécurité

Pour des longueurs supérieures à 0.15 m, la paire torsadée est obligatoire : SDA et SCL doivent être dans des paires différentes, chacune avec sa propre masse (par exemple bleu + bleu-blanc pour SDA, vert + vert-blanc pour SCL). SDA et SCL dans une même paire créent une capacité de couplage croisé qui déforme les fronts.

⚠ Dans une armoire électrique, blindez le câble I2C. Les champs magnétiques intenses près des conducteurs secteur, des contacteurs et des transformateurs induisent du bruit dans un câble non blindé. Gardez le câble aussi court que possible et à l'écart du câblage secteur.

Câblage côté secteur (capteurs)

Sécurité

⚠ La tension du secteur peut tuer. Coupez et verrouillez le circuit avant de raccorder les bornes L/N ou de poser la pince ; faites faire le câblage secteur et tout travail dans un tableau par une personne qualifiée. Ne serrez qu'UN conducteur (L) — jamais le câble entier (L+N s'annulent à ~0). Protégez la dérivation L selon les règles locales.

Capteur de tension (variantes UI*)

La carte expose des bornes L (phase) et N (neutre). La polarité compte pour le signe de la puissance active :

  • Correct (L → L, N → N) : P > 0 signifie consommation (courant du réseau vers la charge), P < 0 signifie export vers le réseau (production).

  • Inversés (L et N permutés) : le signe de P s'inverse — la consommation est comptée comme puissance négative.

Câble et fusible. Un câble épais n'est pas nécessaire pour la connexion de tension : AWG26–22 suffit, car le capteur de tension consomme très peu de courant. Un fusible sur la ligne L est obligatoire, calibre jusqu'à 0.1 A.

La bonne polarité est essentielle pour :

  • Comptabilité correcte sur le niveau BASIC (BASIC ne compte que max(P, 0) ; avec une polarité inversée, le compteur d'énergie reste à zéro).

  • Séparation correcte de la consommation et de la production sur la ligne STANDARD (STD).

Contrôle rapide

: sur une charge purement résistive (bouilloire électrique, chauffage, lampe à incandescence) P > 0 et PF ≈ 1.0. Si P est négative sous une charge consommatrice — inversez L et N sur la carte.

Capteur de courant — pince SCT-013 à TC

Les pinces CT externes se raccordent au module par une prise jack de 3.5 mm. Le connecteur est détrompé — aucun choix de câblage n'est à faire.

Une flèche sur le corps de la pince indique le sens du courant pour l'orientation « normale ». Règles :

  • Serrez la pince autour du seul conducteur de phase (L) allant vers la charge.
  • La flèche sur la pince doit pointer dans le sens du courant vers la charge (depuis le disjoncteur vers la charge).

  • La pince doit se refermer complètement — sans aucun jeu entre les moitiés du noyau magnétique. Si les moitiés ne se verrouillent pas complètement, la précision est perdue.

Sécurité

⚠ Ne passez jamais L et N dans une même pince en même temps. Leurs flux magnétiques sont égaux et opposés : ils s'annulent — le capteur lira environ zéro même sous charge.

Pour choisir le modèle SCT-013 (5 A / 10 A / 30 A / 50 A / 100 A) et indiquer au module votre choix via dev.setCTModel(code) — voir 03_sensor_selection.md.

Sécurité

⚠ La polarité de la pince CT compte sur BASIC : si la flèche de la pince pointe à l'opposé de la charge (ou si L/N sont inversés aux bornes), P_real lit négatif en consommation — et le palier BASIC borne max(P, 0), donc le compteur de Wh reste à zéro. Retournez la pince physiquement sur le conducteur ; ne l'inversez pas dans le logiciel.

Raccordement côté secteur dans un tableau : pince sur le fil L après le disjoncteur d'arrivée, N à l'extérieur de la pince, dérivation L fusionnée et N pour la référence de tension.

DATA_READY (DRDY)

Broche facultative pour optimiser l'interrogation. Si l'application interroge le module au plus une fois toutes les 100 ms, DRDY peut rester non connectée.

Paramètres électriques

  • Type de sortie : drain ouvert (pas de rappel actif vers VCC)
  • Niveau de repos : HAUT (nécessite une résistance de rappel côté maître — celle intégrée au MCU ou une résistance externe)

  • Impulsion de disponibilité : LOW pendant ~10 µs après la mise à jour des registres RT (0x86..0xCF) avec des données fraîches

  • Fréquence d'impulsion : ~10 Hz (une impulsion par fenêtre RT d'environ 100 ms)

La bibliothèque peut utiliser la ligne pour vous : dev.setDrdyPin(pin) la rattache (résistance de rappel interne, interruption sur front descendant) et dev.waitDataReady() / dev.readAllReady() attendent le prochain instantané du module — voir 09 · Référence de l'API. Plusieurs modules peuvent partager une ligne DRDY (OU câblé) ; une ligne maintenue fixement à LOW signifie qu'un module a un événement masqué en attente (alarme). Sans ligne, les mêmes appels interrogent.

Sémantique

Un front descendant sur DRDY garantit que tous les registres RT sont synchronisés et publiés (le firmware met à jour les registres de façon atomique dans une ISR avant de tirer la broche vers le bas). Après le front descendant, le maître peut lire 0x86..0xCD sans risque de lire un échantillon scindé.

À utiliser sur Arduino

  • Interruption externe (attachInterrupt sur le front descendant) — réveille le maître et déclenche une lecture.

  • Résistance de rappel : soit INPUT_PULLUP sur le MCU, soit une résistance externe de 10 kΩ vers 3.3 V. Sur UNO / Nano (AVR), utilisez une résistance externe de 10 kΩ vers 3.3 V — la résistance de rappel intégrée (~40 kΩ) est trop faible pour les longues lignes DRDY.

C++
const int PIN_DRDY = 15;
volatile bool data_ready = false;

#if defined(ESP32) || defined(ESP_PLATFORM)
void IRAM_ATTR on_drdy() { data_ready = true; }   // ESP32 — ISR in IRAM
#else
void on_drdy() { data_ready = true; }             // AVR / STM32duino / RP2040 / SAMD
#endif

void setup() {
    Wire.begin();
    while (!dev.begin()) { delay(500); }

    // Raise the pull-up + attach the ISR AFTER dev.begin() — this
    // guarantees the module is already ready and the pull-up edge will not
    // cause a spurious interrupt before the first RT window is captured.
    // INPUT_PULLUP is fine for most cases; for long
    // lines or AVR hosts add an external 10 kΩ to 3.3 V.
    pinMode(PIN_DRDY, INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(PIN_DRDY), on_drdy, FALLING);
}

void loop() {
    if (!data_ready) return;     // sleep until the next RT window
    data_ready = false;
    float p = dev.readPower(0);
    // ...integration / transmit...
}

DRDY est facultatif — l'interrogation à toute cadence ≤ 10 Hz fonctionne sans lui. La bibliothèque ne dépend pas de DRDY ; setDrdyPin() / waitDataReady() sont des aides facultatives.

Connexion à différents hôtes Arduino

Le module fonctionne avec toute carte compatible Arduino via le Wire standard. Ci-dessous, les broches par défaut usuelles des variantes populaires.

Arduino UNO / Nano (logique 5 V)

rbAmp Broche Arduino
VCC +5V
GND GND
SDA A4
SCL A5
DRDY (facultatif) toute broche numérique, par ex. D2
C++
#include 
#include 

RbAmp dev(Wire, 0x50);

void setup() {
    Wire.begin();          // SDA=A4, SCL=A5 by default
    Wire.setClock(100000); // 100 kHz — no 50 kHz clamp needed on AVR
    while (!dev.begin()) { delay(500); }
}

L'UNO est un hôte 5 V, aucun convertisseur de niveau nécessaire (les lignes SDA/SCL du module tolèrent le 5 V). Les résistances de rappel intégrées du module tirent les lignes à 3.3 V, qu'un maître 5 V lit correctement comme HAUT.

Arduino Mega 2560 (logique 5 V)

rbAmp Broche Mega
VCC +5V
GND GND
SDA D20
SCL D21
DRDY (facultatif) toute entrée numérique, par exemple D18 (supporte les interruptions)

Identique à l'UNO en code, seules les broches physiques diffèrent. Aucun convertisseur de niveau nécessaire.

ESP32 / ESP32-S3 / ESP32-C3 (logique 3.3 V)

rbAmp Broche ESP32 DevKitC
VCC +5V (alimenté depuis USB-5V sur la DevKitC)
GND GND
SDA GPIO21
SCL GPIO22
DRDY (facultatif) n'importe quel GPIO libre, par exemple GPIO4
C++
#include 
#include 

RbAmp dev(Wire, 0x50);

void setup() {
    Wire.begin(21, 22);    // SDA=21, SCL=22 (or Wire.begin() with board defaults)
    Wire.setClock(50000);  // ESP32: 50 kHz
    while (!dev.begin()) { delay(500); }
}

L'ESP32 est un hôte en 3.3 V, connexion directe au module. L'alimentation VCC est prise sur la broche +5V de la DevKitC (reliée directement à USB-5V).

Remarque

Horloge 50 kHz sur ESP32 — le schéma recommandé. Au lieu d'un appel explicite Wire.setClock(50000), définissez la macro facultative avant l'inclusion — begin() appliquera la fréquence en interne :

C++
#define RBAMP_ESP32_CLAMP_HZ 50000
#include 

La macro est facultative (non activée par défaut) — afin que les appels explicites de l'utilisateur à Wire.setClock() (par exemple lorsqu'un OLED partage le bus) soient préservés. Les deux formes fonctionnent — choisissez celle qui se lit le mieux dans votre croquis.

Si votre carte ESP32 n'expose pas de broche 5 V (certains modules compacts ESP32-S3 / C3 se contentent de Vin ou n'ont pas de 5 V du tout), alimentez rbAmp depuis une source 5 V externe (par exemple un chargeur USB + carte d'adaptation), avec une masse commune avec l'ESP32.

Une remarque distincte sur la réinitialisation du module :

Remarque

Pour une réinitialisation logicielle du module, utilisez dev.reset() — la bibliothèque envoie la commande et le module redémarre en ~100 ms. Si vous avez besoin d'une réinitialisation matérielle (par exemple pour sortir d'un état de brique) — coupez l'alimentation VCC (déconnectez pendant 1 seconde ou plus).

ESP8266 (Wemos D1 mini / NodeMCU, logique 3.3 V)

rbAmp Broche ESP8266 (NodeMCU)
VCC Vin ou +5V
GND GND
SDA D2 (GPIO4)
SCL D1 (GPIO5)
DRDY (facultatif) D5 (GPIO14)
C++
#include 
#include 

RbAmp dev(Wire, 0x50);

void setup() {
    Wire.begin(D2, D1);      // SDA=GPIO4, SCL=GPIO5
    Wire.setClock(50000);    // ESP8266 software I²C: 50 kHz for consistency with ESP32
    while (!dev.begin()) { delay(500); }
}

L'ESP8266 est un hôte 3.3 V, connexion directe.

STM32duino (carte de développement STM32F1 F103 / Black Pill F411, logique 3.3 V)

rbAmp Broche STM32 (carte de développement STM32F1)
VCC +5V
GND GND
SDA PB7 (I²C1_SDA)
SCL PB6 (I²C1_SCL)
DRDY (facultatif) toute GPIO avec EXTI, par ex. PA0
C++
#include 
#include 

RbAmp dev(Wire, 0x50);

void setup() {
    Wire.begin();           // SDA=PB7, SCL=PB6 by default for I²C1
    Wire.setClock(100000);  // the STM32 HAL I²C needs no 50 kHz clamp
    while (!dev.begin()) { delay(500); }
}

STM32duino prend en charge plusieurs instances Wire (Wire1, Wire2 pour un second I²C). Si le bus principal est occupé — utilisez le second périphérique I²C.

RP2040 / SAMD (Raspberry Pi Pico, arduino-pico)

rbAmp Broche RP2040 (Pico)
VCC VBUS (5 V depuis USB) ou +5V
GND GND
SDA GP4
SCL GP5
DRDY (facultatif) tout GP
C++
#include 
#include 

RbAmp dev(Wire, 0x50);

void setup() {
    Wire.setSDA(4);
    Wire.setSCL(5);
    Wire.begin();
    Wire.setClock(100000);  // the RP2040 hardware I²C needs no 50 kHz clamp
    while (!dev.begin()) { delay(500); }
}

Le RP2040 est un hôte en 3.3 V, connexion directe. Sur les cartes SAMD (Arduino Zero, MKR), Wire.begin() avec les valeurs par défaut fonctionne de la même façon — les broches précises dépendent de la carte.

Remarque

Pico via VSYS (batterie / alimentation externe) : la broche VBUS n'est présente que lorsqu'il est alimenté par USB. Si le Pico fonctionne sur batterie ou sur une source externe via VSYS — VBUS ne transporte rien. Alimentez le VCC du module directement en 5 V depuis une source externe, la masse étant commune avec le Pico.

Schéma de câblage de référence (ESP32 + module unique)

Schéma de référence d'une carte ESP32 raccordée à un seul module rbAmp, avec la pince CT sur le fil L.

Dans cette configuration :

  • Les résistances de rappel externes sur l'I²C ne sont PAS nécessaires (elles sont intégrées au module).
  • DRDY est facultatif ; comme sur le schéma, utilisez une résistance de rappel externe de 10 kΩ vers 3.3 V (INPUT_PULLUP sur la broche ESP32 convient aussi pour les câbles courts).
  • La prise SCT-013 est entièrement enfoncée.
  • La pince est entièrement fermée sur le fil L, flèche vers la charge.

Schéma de câblage de référence (Arduino UNO + module unique)

Schéma de câblage de référence d'un Arduino UNO vers un module rbAmp unique, avec la pince CT sur le fil L.

Dans cette configuration :

  • Les résistances de rappel externes sur I²C ne sont PAS nécessaires.
  • L'UNO fonctionne en logique 5 V ; les SDA/SCL du module tolèrent le 5 V, aucun convertisseur de niveau n'est nécessaire.
  • DRDY a un niveau de 3.3 V — sur l'UNO, une entrée TTL la lit comme HIGH (VIH_TTL ≥ 2.0 V, 3.3 V > 2.0 V). Une résistance de rappel DRDY est recommandée spécifiquement vers 3.3 V par sécurité : si les circuits de protection internes de la broche DRDY ne tolèrent pas 5 V (indépendamment des lignes I²C, dont la tolérance 5 V est confirmée), un rappel vers 5 V créerait un petit courant de fuite à travers les diodes ESD vers le rail 3.3 V du module. Vers 3.3 V — jamais de problème.

Modèles multiphasés et la ligne STANDARD (STD)

Les références multi-canaux et multi-phases conservent le même brochage basse tension (VCC / GND / SDA / SCL / DRDY). Seul le côté secteur change — davantage de bornes L et davantage de connecteurs de prise CT.

Les modules STANDARD (STD) utilisent le même câblage I²C que les modules BASIC — mêmes quatre lignes de signal, mêmes règles de résistances de rappel et de bus que ci-dessus. Rien ne change au raccordement ; dev.begin() détecte la gamme branchée (dev.line()), et le même croquis sert les deux. Remarques :

  • Les appels qui n'existent que sur la ligne STD (la famille std*, puissances réactive et apparente) renvoient RB_ERR_NOT_IMPLEMENTED sur un module BASIC (sur BASIC, la puissance réactive n'est pas exposée par cette bibliothèque).

  • Certaines fonctions STD dépendent de la version de l'image du module : compteurs d'énergie à micro-résolution, courant de démarrage pour l'énergie, angles de phase de tension et séquence de phases exigent une image d'au moins 0x0001007B (dev.stdReadImageVersion()). Sur une image plus ancienne, elles sont signalées comme « non disponibles ».

  • Le nombre de canaux de tension et de courant vient du module (dev.stdInfo()) ; la bibliothèque expose jusqu'à RBAMP_MAX_CHANNELS (7) canaux de courant.

Bus multi-modules — la topologie principale

Le cas d'usage canonique de la bibliothèque est plusieurs modules rbAmp sur un même bus I²C, gérés par un seul Arduino / ESP32 via RbAmpFleet. Toutes les règles et optimisations ci-dessous sont conçues pour exactement cette topologie ; un module seul est un cas particulier (le même handle, mais les appels de flotte se réduisent à des appels triviaux).

Plusieurs modules rbAmp sur un bus I²C avec les résistances de rappel intégrées coupées et une paire de rappel externe au maître, plus les options DRDY.

Déploiements types

Scénario Configuration Nombre de modules
Canon des 80 % : arrivée domestique + sous-compteurs 1× UI1 (alimentation, énergie secteur) + 3-6× UI1/I1 (charges) 4-7
Sous-tableau avec répartition du courant 1× UI1 (alimentation) + 1 à 2× I2/I3 (courant par circuit) 3-5
Sous-comptage industriel 1× UI1 (arrivée) + N× I2/I3 (par machine, répartition du courant) jusqu'à environ 16

Limites électriques

  • Nombre de modules : jusqu'à ~16 (capacité totale du bus ≤ 400 pF à 100 kHz ; à 50 kHz, il y a plus de marge).
  • Résistances de rappel pour le bus de la flotte (important) : chaque module embarque 4.7 kΩ intégrées. Sur un bus multi-modules, N résistances en parallèle → le drain est surchargé et le bus ne peut pas être tiré à BAS. À partir de 4 modules (ou plus tôt sur un bus de plus de 15 cm), coupez les résistances intégrées de tous les modules sauf un — avec 2 à 3 modules sur un bus de 15 cm au plus, laissez-les en place, ce cas est mesuré (ou coupez-les sur tous et ne gardez que des résistances externes (2.7…3.3 kΩ pour 3 modules, plus faibles pour les bus plus longs — voir le tableau ci-dessus) reliées à 3.3 V en un point unique du bus — recommandé pour les longs parcours / le bruit / l'ESP32 comme maître).
  • Les résistances de rappel internes de l'ESP32 (~45 kΩ) sont trop faibles pour un bus multi-modules avec des longueurs de câble réelles — des résistances de rappel externes sont nécessaires (valeurs : voir le tableau ci-dessus). Cela fait partie de la protection à trois niveaux contre le blocage du bus sur un bus marginal — voir 10 · Dépannage, la section « Le croquis ESP32 se bloque ».

Adressage — provisionnement et remplacement à chaud (compatible production)

L'adresse d'usine par défaut est 0x50. Chaque module neuf ou de remplacement passe par le provisionnement (une fois) : réaffectation de 0x50 vers une adresse de travail + sauvegarde facultative de la configuration (modèles de TC, group_id, étiquette) en flash. Le mode usine n'est pas requis — le changement d'adresse fonctionne directement en production via le commit d'adresse en deux phases.

Le provisionnement adresse un module vierge à la fois : branchez un module à 0x50, lancez l'appel de provisionnement, vérifiez à la nouvelle adresse, puis branchez le suivant.

C++
RbAmp* dev = nullptr;
if (RbAmpFleet::provision(Wire, /*desired=*/0x52, /*save=*/true, dev)) {
    fleet.add(dev);   // ready handle, now in the fleet
}

Un seul appel scanne 0x50, effectue la validation d'adresse en deux phases, redémarre, cherche le module à sa nouvelle adresse dans la fenêtre de démarrage et (facultativement) émet SAVE_USER_CONFIG pour la persistance. Renvoie false en cas de violation de la discipline (voir ci-dessous) ou d'échec de transport.

Méthode 2 — prepare/commitAddressChange bas niveau (forme manuelle)

C++
dev.prepareAddressChange(0x52);   // candidate in RAM
dev.commitAddressChange();        // arms 0xA5 + COMMIT_ADDR + reset
delay(300);                        // boot window

Le même mécanisme de validation en deux phases que dans provision(), sans l'enveloppe de flotte. Utilisé lorsque RbAmpFleet n'a pas été créé.

Protocole filaire sous le capot (pour référence)

Text
1. write candidate_addr → REG_I2C_ADDRESS (0x30, in RAM)
2. write 0xA5 → REG_ADDR_COMMIT_MAGIC (0x31, armed)
3. issue CMD_COMMIT_ADDR (opcode 0x30 in REG_COMMAND)
4. wait ~700 ms (flash erase + write)
5. issue CMD_RESET (opcode 0x01) — CMD_COMMIT_ADDR does not auto-reset
6. wait ~300 ms; the module responds at the new address
Sécurité

✅ REG_I2C_ADDRESS (0x30) lit l'adresse active au démarrage (v1.3 addr-boot-sync). Après le redémarrage consécutif à la validation, la lecture de 0x30 affiche la nouvelle adresse active. Le comportement d'écho de préparation persiste jusqu'à CMD_COMMIT_ADDR + réinitialisation.

⚠ Discipline de provisionnement — UN SEUL module vierge à la fois, OBLIGATOIREMENT.

La cause la plus courante d'échec de provisionnement est d'avoir plus d'un module à l'adresse d'usine 0x50 sur le bus. Il est physiquement impossible de les distinguer sur I²C (bus à drain ouvert : les deux modules acquittent de la même façon, et les données relues sont « collées »).

La règle est donc stricte (un MUST normatif, pas une recommandation) : au moment où vous appelez RbAmpFleet::provision() (ou prepareAddressChange()), il doit y avoir exactement un module à 0x50 (un neuf, ou un remis aux réglages d'usine par un outil de banc séparé). Pas de « je suis sûr que ces deux modules sont différents — je vais simplement les séparer maintenant » — cela ne fonctionnera pas ; la collision apparaît plus tard, une fois que vous pensez déjà que la flotte est propre.

Voie de récupération en cas de suspicion de non-respect de la discipline : 1. Coupez l'alimentation de tous les modules. 2. Déconnectez physiquement tous les modules « vierges » sauf un. 3. Appelez RbAmpFleet::provision() sur le bus à un seul module. 4. Ajoutez les modules restants un par un, en provisionnant chacun séparément.

Budget de puissance du bus

À 50 kHz, une transaction de lecture ≈ 200-400 µs. Un bloc RT complet d'un canal (U + I + P + FP) ≈ 5-8 ms par canal.

Configuration Bus par cycle À 50 kHz Cadence d'interrogation maximale
1× UI1, bloc RT ~5 ms < 5 ms 100+ Hz (mais le module se met à jour à 10 Hz)
1× UI3, bloc RT + période ~25 ms ~25 ms jusqu'à 10 Hz
5× UI1, bloc RT ~25 ms ~25 ms jusqu'à 10 Hz
16× UI3, RT + période ~400 ms 400 ms > 100 ms ne suit pas le module (10 Hz) ; ~2 Hz au mieux
Remarque

Les chiffres sont des estimations (200-400 µs par transaction selon le MCU). Ils sont estimatifs et dépendent du MCU hôte.

Règle : à 50 kHz, les limites confortables sont 8-10× UI3 ou 15-16× UI1 pour une interrogation à 5 Hz (toutes les deux fenêtres de module), et environ la moitié à la pleine cadence de 10 Hz.

Synchronisation de période

Synchronisation de période entre modules : instantané séquentiel avec un léger décalage, ou une seule trame General-Call à l'adresse 0x00.

Pour le comptage tarifaire, tous les modules doivent prendre leur instantané sur le même intervalle. Deux stratégies :

Stratégie 1 — instantané séquentiel + stabilisation commune (tout firmware) :

C++
RbAmp meters[N];   // array of initialized modules

void period_cycle() {
    // Phase 1: sequential snapshot
    for (auto& m : meters) m.latchPeriod();

    // Phase 2: common settle (≥ 50 ms)
    delay(50);

    // Phase 3: read the snapshots with skip_latch=true
    for (auto& m : meters) {
        RbAmpSnapshot snap;
        m.readPeriodSnapshot(snap, /*skip_latch=*/true);
    }
}

Décalage entre modules : 16 modules × ~1 ms/instantané = ~16 ms sur une période de 60 s. Négligeable pour les totaux d'énergie.

Stratégie 2 — instantané diffusé General-Call (nécessite l'activation) :

Tous les modules prennent leur instantané avec une seule trame I²C à l'adresse 0x00 :

Text
addr=0x00 | A5 27      (5 bytes)

Décalage = 0 (atomique). Préconfiguration (une fois sur chaque module de la flotte) :

  1. Définissez REG_FLEET_CONFIG.bit0 = 1 via CMD_SAVE_USER_CONFIG.
  2. CMD_RESET — la réception General Call est activée au démarrage.
  3. Après la réinitialisation, le maître envoie la trame de 5 octets sur 0x00.
  4. Témoin : pour chaque module attendu, lisez REG_V03_PERIOD_VALID (0x07). !=1 → repli sur la stratégie 1.

Lequel utiliser :

  • < 8 modules : stratégie 1 (plus simple, aucune activation requise).
  • ≥ 8 modules ou synchronisation serrée : stratégie 2.

Filtrage par groupe GC (bus multi-locataires)

REG_GROUP_ID (0x28) permet d'avoir plusieurs domaines GC sur un même bus :

  • group = 0x00 → appel général (all-call) : tous les modules dont le GC est activé prennent un instantané.
  • group = N → seuls les modules avec REG_GROUP_ID = N prennent un instantané.

Cas d'usage : séparer des groupes tarifaires (jour et nuit) sur un bus partagé.

Modes de défaillance

Symptôme Cause Que faire
i2c bus scan montre plusieurs modules à une même adresse après un ajout sur le terrain Un nouveau module à 0x50 entre en conflit avec un module déjà adressé Réadressez le nouveau module séparément avant de l'ajouter
Un module répond NACK plus souvent que les autres Défaut de câble / chute de VCC Vérifiez la VCC sous charge
Les Wh d'un module divergent de façon constante L'horloge propre du module diffère de celle du maître L'énergie est intégrée sur l'horloge du maître ; comparez avec master_dt_ms, et non latch_ms
Après une trame GC, un module ne prend pas d'instantané FLEET_CONFIG.bit0 = 0 ou groupe non concordant Vérifiez REG_FLEET_CONFIG et REG_GROUP_ID

Notes de conception du bus

  • Étirement d'horloge : la pause de l'instantané du module ne dure que quelques microsecondes ; SCL n'est pas étiré de façon significative. Pour le Raspberry Pi BCM283x (bogue matériel connu sur l'étirement) : la précaution standard est 50 kHz + reprises.
  • Longueur au-delà de 4 modules : envisagez un tampon I²C (PCA9515) à partir de 8 modules + une longueur > 1 m.

Scénarios multi-modules détaillés — dans 06 · Exemples.

Suite


Source et problèmes : rb-amp/rbamp-arduino · cette page dans le dépôt : docs/04_hardware.md (v1.6.2)