03 · Interrogation temps réel
Interrogation temps réel — lecture des valeurs instantanées de U, I, P, PF, du sens du flux et des grandeurs associées à intervalles réguliers (typiquement une fois par fenêtre de mesure, ~100 ms). Elle sert à :
- Tableaux de bord en direct (puissance, tension actuelles)
- Alarmes de seuil
- Détection d'événements (mise en marche / arrêt d'une charge)
- Surveillance de la qualité du secteur (fréquence, PF)
- Détermination du sens du courant — consommation ou injection (d'après le signe de P_real)
Pour l'accumulation d'énergie tarifaire (Wh sur une période), utilisez le mécanisme d'instantané de période décrit dans period-metering.md.
La fenêtre de mesure (100 ms)
Qu'est-ce que c'est
Le module mesure en continu et publie un jeu de résultats toutes les ~100 ms (images du firmware antérieures à la v1.2 : toutes les ~200 ms) :
- RMS de la tension et des courants
- Valeurs de crête de U et I
- Puissance active P, calculée comme
mean(u(t) · i(t))— signée, le signe indiquant le sens du flux : P > 0— la charge consomme depuis le réseau (mode normal)P < 0— la charge injecte vers le réseau (onduleur solaire, charge régénérative)- Puissance réactive Q, calculée comme
√(S² − P²)avecS = U_rms × I_rms— non signée (≥ 0), inclut la puissance de distorsion ; vaut 0 sur les variantes I uniquement et est bruitée près de PF ≈ 1 - Facteur de puissance PF = P / S, avec S = U_rms × I_rms. Le signe de PF correspond à celui de P — un indicateur supplémentaire du sens du flux.
Après le calcul d'une fenêtre, le firmware publie atomiquement le jeu complet de résultats (50+ octets) dans le bloc de registres I²C 0x86..0xCD.
La durée de fenêtre est fixe
La fenêtre est fixée à 100 ms depuis la v1.2, indépendamment de la fréquence du secteur. Sur les images antérieures à la v1.2, la fenêtre est de 200 ms.
À 50 Hz (secteur), une fenêtre de 100 ms couvre exactement 5 cycles ; à 60 Hz, 6 cycles (10 et 12 sur l'ancienne fenêtre de 200 ms). Dans les deux cas, le nombre entier de cycles du secteur garde la précision du RMS et de P.
Le registre V03_PERIOD_MS (0xCA..0xCD, u32 LE) indique la durée de la période d'instantané en cours jusqu'à présent (ms depuis le dernier CMD_LATCH_PERIOD — voir chapitre 04). Il ne sert qu'au diagnostic ; il n'affecte ni la précision de mesure ni le calcul d'énergie.
Au démarrage de la fenêtre suivante
Immédiatement après la publication de la précédente. Il n'y a aucun intervalle entre les fenêtres — la mesure est continue.
DATA_READY (DRDY) — la broche de disponibilité
DRDY est une sortie en collecteur ouvert tirée vers 3.3 V côté maître. Le firmware la met à LOW pendant ~10 µs après la mise à jour des registres temps réel — un signal matériel qui dit « les données sont prêtes à être lues ».
Paramètres d'impulsion
- Durée LOW : ~10 µs (confortable pour tout maître avec EXTI)
- Fréquence : ~10 Hz (une impulsion par fenêtre de 100 ms ; ~5 Hz sur les images antérieures à la v1.2)
- Type de sortie : drain ouvert (permet le OU câblé dans les topologies multi-modules)
- Sémantique : le front descendant garantit que tous les registres RT sont cohérents et à jour
Quand DRDY n'est pas nécessaire
- Le maître interroge plus lentement que la cadence des fenêtres (une fois par seconde ou par minute) — les données sont rafraîchies dix fois par seconde (v1.2 et ultérieures), donc toute lecture récupère des données fraîches.
- Une boucle d'interrogation minimale —
read_rt()peut être appelée à tout moment ; vous obtenez le dernier résultat validé.
Quand DRDY est utile
- Le maître veut minimiser le trafic I²C ou libérer du CPU pour d'autres tâches (systèmes alimentés par batterie)
- Synchronisation précise : lire l'instant exact de fin de mesure (utile pour les journaux haute résolution)
- Détection d'événements : réagir à chaque fenêtre (par ex. suivi de la puissance instantanée à une granularité de ~100 ms)
Utilisation (Arduino, un module)
const uint8_t PIN_DRDY = 15; // example pin — any input-capable GPIO works
volatile bool data_ready = false;
void on_drdy_falling() {
data_ready = true;
}
void setup() {
Serial.begin(115200);
Wire.begin();
pinMode(PIN_DRDY, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(PIN_DRDY), on_drdy_falling, FALLING);
}
void loop() {
if (data_ready) {
data_ready = false;
float u = rb_read_float_le(0x50, 0x86);
float i = rb_read_float_le(0x50, 0x8E);
float p = rb_read_float_le(0x50, 0xA6);
const char* dir = (p >= 0.0f) ? "consume" : "export";
Serial.printf("U=%.1f I=%.3f P=%.1f (%s)\n", u, i, p, dir);
}
}
— la même tâche sans accès aux registres :
| Bibliothèque | Appel | Ce qu'il fait |
|---|---|---|
| Arduino | RbAmp::setDrdyPin(pin) / RbAmp::waitDataReady(timeout_ms, ev) |
reliez la ligne DRDY ; attendez un nouvel instantané |
| ESP-IDF | rbamp_set_drdy_gpio() / rbamp_wait_data_ready() |
raccorder la GPIO DRDY ; attendre un nouvel instantané |
| Python | — | non exposée — la bibliothèque n'utilise pas la broche ; à gérer dans votre propre code |
| ESPHome | drdy_pin: |
entrée DRDY optionnelle dans le YAML ; le composant se contente de la journaliser |
Signe de P et sens du flux
Dans les registres RT, le signe de la puissance active est le principal indicateur du sens du courant :
| Condition | Signification |
|---|---|
P_real > 0 |
La charge consomme (courant entrant) |
P_real < 0 |
Charges qui injectent vers le réseau (production) |
P_real ≈ 0 alors que I_rms > 0 |
Charge purement réactive (transformateur à vide, condensateur) |
Les valeurs RMS du courant et de la tension sont toujours ≥ 0 (le RMS n'est pas négatif par définition). Par conséquent, I_rms ne peut pas servir à déterminer le sens du flux — utilisez P_real.
Exemple de classification du flux
void classify_flow(float p) {
if (p > 10.0f) {
Serial.println("CONSUMING from grid");
} else if (p < -10.0f) {
Serial.println("EXPORTING to grid");
} else {
Serial.println("idle / reactive only");
}
// ±10 W threshold to avoid chatter near zero
}
Sur un firmware de niveau BASIC, l'accumulateur tarifaire ignore l'export (voir period-metering.md). Les registres RT, en revanche, transportent toujours le signe temps réel de P — donc même sur une référence BASIC le maître peut détecter les événements d'export depuis les lectures RT, les journaliser, ou construire un accumulateur bidirectionnel côté maître sur le firmware BASIC.
Référence des registres RT
Toutes les valeurs sont des float32 little-endian (4 octets). La LECTURE supporte l'auto-incrément — lisez chaque valeur en rafale de 4 octets (ou tout le bloc 0x86..0xBD en une seule rafale, voir §read-freeze). Les champs entiers sont marqués de leur type.
Tension
| Adresse | Champ | Type | Unité | Description |
|---|---|---|---|---|
0x86 |
U_rms | float32 | V | Tension efficace RMS sur la dernière fenêtre de mesure |
0x8A |
U_peak | float32 | V | Écart maximal par rapport à la moyenne pendant la fenêtre |
Courants (par canal : 0 = primaire, 1/2 sur UI2/UI3, davantage sur UI5/UI7)
| Adresse | Champ | Type | Unité |
|---|---|---|---|
0x8E |
I0_rms | float32 | A |
0x92 |
I1_rms | float32 | A |
0x96 |
I2_rms | float32 | A |
0x9A |
I0_peak | float32 | A |
0x9E |
I1_peak | float32 | A |
0xA2 |
I2_peak | float32 | A |
Sur les variantes à moins de canaux (par ex. UI1), les registres des canaux inutilisés renvoient 0.0f au lieu d'un NACK. Les variantes à plus de canaux (UI5/UI7) placent leurs valeurs I_rms / P_real / PF / Q supplémentaires dans des registres au-delà de 0xCF ; reportez-vous à la fiche technique de la référence pour la carte étendue.
Puissance
| Adresse | Champ | Type | Unité | Signe | Description |
|---|---|---|---|---|---|
0xA6 |
P0_real | float32 | W | ± | Puissance active, canal 0 — P > 0 = consommation, P < 0 = export |
0xAA |
P1_real | float32 | W | ± | Puissance active, canal 1 (UI2/UI3) |
0xAE |
P2_real | float32 | W | ± | Puissance active, canal 2 (UI3) |
0xB2 |
PF0 | float32 | – | ± | Facteur de puissance, plage −1…+1, le signe suit P0 |
0xB6 |
PF1 | float32 | – | ± | |
0xBA |
PF2 | float32 | – | ± | |
0xD0 |
Q0_reac | float32 | VAr | ≥ 0 | Puissance réactive canal 0 = √(S² − P²) — inclut la puissance de distorsion ; bruitée près de PF ≈ 1 ; 0 sur les variantes I uniquement |
0xD4 |
Q1_reac | float32 | VAr | ≥ 0 | |
0xD8 |
Q2_reac | float32 | VAr | ≥ 0 |
La puissance apparente S peut se calculer côté maître : S = U_rms × I_rms. Les valeurs RMS sont toujours ≥ 0 ; le sens du flux réside dans le signe de P.
Réserve d'atomicité pour Q : le bloc RT 0x86..0xBD (U/I/P/PF) est livré sous gel de lecture et garanti sans déchirure en une seule lecture en rafale. Les registres Q (0xD0..0xDB) sont hors de cette fenêtre de gel — si vous lisez U/I/P + Q en deux transactions séparées, U/I/P proviendront d'un instantané cohérent mais Q peut appartenir au commit RT suivant. Pour une cohérence inter-grandeurs à la granularité sub-période, lisez soit Q sous un instantané CMD_LATCH_PERIOD (0xC2..0xC9 pour la moyenne Q ch1/ch2 n'est pas exposée — utilisez le bloc d'instantané du chapitre 11 §4.12), soit acceptez le décalage d'une fenêtre (~100 ms) entre P et Q.
Système
| Adresse | Champ | Type | Description |
|---|---|---|---|
0x00 |
STATUS | u8 | bit0 = prêt, bit1 = erreur |
0x02 |
ERROR | u8 | Dernier code d'erreur (0x00 = OK) |
0x03 |
VERSION | u8 | Version du firmware |
0x20 |
AC_FREQ | u8 | Fréquence du secteur (Hz), 0 si aucun passage par zéro détecté |
0xCE |
DATA_VALID | u8 | bit0 = résultat valide disponible depuis le démarrage |
0xCA |
V03_PERIOD_MS | u32 LE | Durée de la période d'instantané en cours jusqu'à présent (ms, diagnostic — voir chap. 04) |
— la même tâche sans accès aux registres :
| Bibliothèque | Appel | Ce qu'il fait |
|---|---|---|
| Arduino | RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readPower(ch) |
lire le bloc temps réel complet, ou une valeur à la fois |
| ESP-IDF | rbamp_read_all() / rbamp_read_power() |
lire le bloc temps réel complet, ou une valeur à la fois |
| Python | dev.read_all() / dev.read_power(ch) |
lire le bloc temps réel complet, ou une valeur à la fois |
| ESPHome | voltage / power |
capteurs YAML pour les valeurs RT |
Interrogation — module unique
Boucle d'interrogation la plus simple à 1 Hz
void loop() {
float u = rb_read_float_le(0x50, 0x86);
float i = rb_read_float_le(0x50, 0x8E);
float p = rb_read_float_le(0x50, 0xA6);
float pf = rb_read_float_le(0x50, 0xB2);
float q = rb_read_float_le(0x50, 0xD0);
uint8_t freq = rb_read_u8(0x50, 0x20);
const char* dir = (p >= 0.0f) ? "-> consume" : "<- export ";
Serial.printf("U=%.1fV I=%.3fA P=%.1fW %s PF=%.3f Q=%.1fVAR f=%dHz\n",
u, i, p, dir, pf, q, freq);
delay(1000);
}
Interrogation à intervalle fixe sans DRDY
unsigned long last_read = 0;
void loop() {
unsigned long now = millis();
if (now - last_read >= 200) {
last_read = now;
float p = rb_read_float_le(0x50, 0xA6);
Serial.println(p);
}
}
Cela donne ~5 échantillons par seconde — une fenêtre sur deux (v1.2 et ultérieures) (le module rafraîchit toutes les ~100 ms). Interrogez toutes les 100 ms pour attraper chaque fenêtre ; l'intervalle de 200 ms fonctionne aussi sur les images antérieures à la v1.2.
— la même tâche sans accès aux registres :
| Bibliothèque | Appel | Ce qu'il fait |
|---|---|---|
| Arduino | RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readAllReady(timeout_ms, out, ev) |
lire le bloc temps réel ; ou attendre un nouvel instantané, puis le lire |
| ESP-IDF | rbamp_read_all() / rbamp_read_all_ready() |
lire le bloc temps réel ; ou attendre un nouvel instantané, puis le lire |
| Python | dev.read_all() |
lire tout le bloc temps réel en un seul appel |
| ESPHome | update_interval: |
le composant lit le bloc RT en une seule rafale à chaque mise à jour |
Courant multi-canaux (UI2 / UI3 / UI5 / UI7)
Sur les variantes UI2/UI3, le maître lit les courants et les puissances de tous les canaux directement depuis le bloc temps réel. UI5 et UI7 (5 et 7 canaux de courant) utilisent les mêmes registres pour les canaux 0..2 et une fenêtre d'accès aux canaux pour les canaux 3 et plus — voir UI5 / UI7 : canaux 3 et plus ci-dessous.
// UI3: three current channels on one module
void read_ui3(uint8_t addr) {
float u = rb_read_float_le(addr, 0x86);
float i0 = rb_read_float_le(addr, 0x8E);
float i1 = rb_read_float_le(addr, 0x92);
float i2 = rb_read_float_le(addr, 0x96);
float p0 = rb_read_float_le(addr, 0xA6);
float p1 = rb_read_float_le(addr, 0xAA);
float p2 = rb_read_float_le(addr, 0xAE);
Serial.printf("U=%.1f Ch0: %.3fA/%.1fW Ch1: %.3fA/%.1fW Ch2: %.3fA/%.1fW\n",
u, i0, p0, i1, p1, i2, p2);
}
Les canaux de courant sont indépendants — chacun a sa propre pince CT avec son propre coefficient. Un module UI3 peut surveiller, par exemple, l'arrivée principale, le chauffe-eau et le circuit d'éclairage simultanément sur la même phase. Le signe de P peut différer d'un canal à l'autre : P > 0 à l'entrée du tableau (la maison consomme depuis le réseau) tandis que le canal de sortie solaire affiche P < 0 (l'onduleur injecte pendant qu'il alimente la même phase que celle que la maison consomme).
UI5 / UI7 : canaux 3 et suivants
Le bloc temps réel plat ne contient que les canaux 0, 1 et 2. Sur UI5 (canaux 0..4) et UI7 (canaux 0..6), les autres canaux se lisent via la fenêtre d'accès aux canaux : écrivez (champ << 4) | canal dans REG_CHANNEL_SELECT (0x32), puis lisez la valeur dans REG_CHANNEL_DATA (0x3C, float32). Champs : 0 = courant RMS, 1 = courant de crête, 2 = puissance active, 3 = facteur de puissance, 13 = puissance moyenne de période.
Trois règles qui évitent des nombres silencieusement faux :
- Ne prolongez pas le schéma à plat. Le registre après
V03_I2_RMS(0x96) estV03_I0_PEAK(0x9A), et non le canal 3 — le canal 3 et au-delà n'existent que dans la fenêtre. - Sélectionnez avant chaque lecture.
REG_CHANNEL_DATAest un instantané pris à l'écriture du sélecteur ; le relire sans nouvelle écriture du sélecteur renvoie la même ancienne valeur. - La moyenne de période et l'énergie des canaux 3 et plus proviennent uniquement du champ
13— il n'existe pas de registres de période plats pour eux.
// UI5 / UI7: read current and power on every channel.
// rb_read_u8 / rb_read_float_le / rb_write_u8 are the helpers from initialization.md.
float rb_read_channel(uint8_t addr, uint8_t field, uint8_t ch) {
rb_write_u8(addr, 0x32, (field << 4) | ch); // REG_CHANNEL_SELECT: choose field + channel
return rb_read_float_le(addr, 0x3C); // REG_CHANNEL_DATA: the selected value
}
void read_ui7(uint8_t addr) {
uint8_t n = rb_read_u8(addr, 0x24); // TOPOLOGY: number of current channels (5 on UI5, 7 on UI7)
float u = rb_read_float_le(addr, 0x86); // one shared voltage
Serial.printf("U=%.1f V\n", u);
for (uint8_t ch = 0; ch < n; ch++) {
float i, p;
if (ch < 3) { // channels 0..2: flat real-time block
i = rb_read_float_le(addr, 0x8E + 4 * ch);
p = rb_read_float_le(addr, 0xA6 + 4 * ch);
} else { // channels 3..n-1: channel access window
i = rb_read_channel(addr, 0, ch); // field 0 = RMS current
p = rb_read_channel(addr, 2, ch); // field 2 = active power
}
Serial.printf("Ch%u: %.3f A %.1f W\n", ch, i, p);
}
}
La fenêtre fonctionne aussi pour les canaux 0..2 : vous pouvez l'utiliser pour chaque canal si vous préférez un chemin de code unique (une petite écriture supplémentaire par valeur). Détails et tous les codes de champ : api-reference.md → Fenêtre d'accès aux canaux.
Tous les canaux partagent une même tension U
Les variantes UI contiennent un seul capteur de tension — il mesure la phase qui alimente le module. Les valeurs P de tous les canaux sont calculées par rapport à cette U partagée* :
P0 = mean(u(t) · i0(t))
P1 = mean(u(t) · i1(t))
P2 = mean(u(t) · i2(t))
Ceci suppose que toutes les pinces CT sont sur des conducteurs de la même phase.
— la même tâche sans accès aux registres :
| Bibliothèque | Appel | Ce qu'il fait |
|---|---|---|
| Arduino | RbAmp::channels() / RbAmp::readCurrent(ch) |
obtenir le nombre de canaux ; lire un canal par index |
| ESP-IDF | rbamp_channels() / rbamp_read_channel() |
obtenir le nombre de canaux ; lire tous les champs temps réel d'un canal (y compris 3 et plus) |
| Python | dev.channels / dev.current[ch] |
nombre de canaux après begin() ; lire un canal par son indice |
| ESPHome | current_N: |
déclarer un emplacement de capteur par canal de courant |
Interrogation multi-module — trois stratégies
Stratégie 1 — interrogation circulaire (simple)
Le maître lit les modules à tour de rôle, par exemple à chaque fenêtre (~100 ms) ou chaque seconde :
const uint8_t modules[] = {0x50, 0x51, 0x52};
const int N = 3;
int idx = 0;
void loop() {
uint8_t addr = modules[idx];
float p = rb_read_float_le(addr, 0xA6);
Serial.printf("[0x%02X] P=%.1f W\n", addr, p);
idx = (idx + 1) % N;
delay(200);
}
Avantages : code minimal, aucune broche GPIO supplémentaire requise. Inconvénients : CPU du maître occupé en permanence ; pas d'horodatage précis de « nouvelle fenêtre ».
Stratégie 2 — DRDY par module (précise, gourmande en GPIO)
Le DRDY de chaque module est relié à son propre GPIO maître, chacun avec son propre gestionnaire EXTI :
const uint8_t modules[] = {0x50, 0x51, 0x52};
const uint8_t pins[] = {15, 16, 17};
volatile bool ready[] = {false, false, false};
void IRAM_ATTR drdy_0() { ready[0] = true; }
void IRAM_ATTR drdy_1() { ready[1] = true; }
void IRAM_ATTR drdy_2() { ready[2] = true; }
void setup() {
Wire.begin();
void (*isr_arr[])() = {drdy_0, drdy_1, drdy_2};
for (int i = 0; i < 3; i++) {
pinMode(pins[i], INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(pins[i]), isr_arr[i], FALLING);
}
}
void loop() {
for (int i = 0; i < 3; i++) {
if (ready[i]) {
ready[i] = false;
float p = rb_read_float_le(modules[i], 0xA6);
Serial.printf("[%d] P=%.1f W\n", i, p);
}
}
}
Avantages : synchronisation précise, latence de lecture minimale. Inconvénients : une broche GPIO + EXTI par module ; ne passe pas à l'échelle au-delà de ~4 modules.
Stratégie 3 — DRDY en OU câblé (compact)
Toutes les broches DRDY (collecteur ouvert) sont reliées sur un seul fil. Le maître détecte le front descendant de n'importe quel module et lit tous les modules :
rbAmp #1 DRDY ──┐
rbAmp #2 DRDY ──┼──┬─[10K]── +3.3V
rbAmp #3 DRDY ──┘ │
▼
Master GPIO IN (EXTI falling)
const uint8_t modules[] = {0x50, 0x51, 0x52};
const uint8_t PIN_DRDY = 15; // example pin — any input-capable GPIO works
volatile bool any_ready = false;
void IRAM_ATTR drdy() { any_ready = true; }
void setup() {
Wire.begin();
pinMode(PIN_DRDY, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(PIN_DRDY), drdy, FALLING);
}
void loop() {
if (any_ready) {
any_ready = false;
for (int i = 0; i < 3; i++) {
float p = rb_read_float_le(modules[i], 0xA6);
Serial.printf("[0x%02X] P=%.1f W\n", modules[i], p);
}
}
}
Avantages : une seule GPIO + EXTI pour un nombre quelconque de modules ; économe en fils. Inconvénients : le maître ne sait pas quel module a levé la ligne — il doit tous les lire. Les périodes légèrement décalées entre modules (chacun a son quartz) produisent des déclenchements « doubles » (un module prêt, un autre une milliseconde plus tard). Sans gravité — lisez simplement tous les modules.
Tableau des compromis
| Approche | GPIO maître | Latence | Complexité | Extensibilité |
|---|---|---|---|---|
| Interrogation sans DRDY | 0 | jusqu'à 1 fenêtre (~100 ms) | minimal | jusqu'à ~16 modules |
| DRDY par module | N | < 1 ms | moyen | jusqu'à ~4 modules |
| DRDY en collecteur ouvert commun (wired-OR) | 1 | ~1–5 ms | faible | jusqu'à ~10 modules |
Recommandation
- 1–3 modules, faible latence requise → DRDY par module
- 3 à 10 modules, le budget GPIO compte → DRDY en collecteur ouvert commun
- N'importe quel nombre, la latence n'a pas d'importance → simple interrogation
— la même tâche sans accès aux registres :
| Bibliothèque | Appel | Ce qu'il fait |
|---|---|---|
| Arduino | RbAmpFleet::scan(match_product, added) / RbAmpFleet::pollAll(snaps, status, capacity, n_ok) |
découvrir les modules ; les lire tous en un seul passage |
| ESP-IDF | rbamp_fleet_scan() / rbamp_fleet_poll_all() |
découvrir les modules ; les lire tous en un seul passage |
| Python | fleet.scan(match_product=True) / fleet.poll_all() |
découvrir les modules ; les lire tous en un seul passage |
| ESPHome | rbamp: (liste) |
un bloc rbamp: par module, chacun avec son propre id et address |
Variantes à courant seul (sans capteur de tension)
Sur I1/I2/I3 (et les variantes I* à canaux supérieurs), sans capteur de tension :
| Registre | Retours |
|---|---|
U_rms (0x86) |
0.0f |
U_peak (0x8A) |
0.0f |
I*_rms, I*_peak |
Valeurs réelles |
P*_real (0xA6, 0xAA, 0xAE) |
0.0f (pas de U → pas de P) |
PF*, Q* |
0.0f |
AC_FREQ (0x20) |
Valeur réelle (50 ou 60). La détection du passage à zéro vient d'une broche dédiée au passage par zéro du secteur, indépendante de l'étage de tension et disponible sur toutes les variantes, y compris celles à courant seul. |
ZC_OFFSET (0x4E) |
0xFFFF. Ce registre est le décalage de phase entre l'instant de l'instantané GC et le prochain passage par zéro de la tension, utilisé pour la compensation de phase U/I — significatif seulement lorsqu'un signal de tension est mesuré. Sur les variantes I uniquement, il est forcé au niveau firmware à 0xFFFF (pas de mesure de tension). |
Sans P, aucune information sur le sens du courant — I_rms est toujours ≥ 0 et n'indique pas dans quel sens circule le courant.
Les variantes à courant seul sont destinées à :
- Maîtres qui fournissent leur propre source de tension et calculent eux-mêmes P (par ex. un ESP32 avec un module ZMPT intégré plus un rbAmp-I3 pour trois charges)
- Applications en courant seul : détection de présence de charge, protection contre la surintensité, équilibrage d'éléments chauffants résistifs
Référence rapide des registres temps réel
0x00 STATUS (u8) — bit0=ready, bit1=error
0x02 ERROR (u8) — last error code
0x03 VERSION (u8) — protocol version (0x04 = v1.3)
0x05 CT_MODEL (u8, RW) — staging only; bind via CMD_SET_CT_MODEL_CHn (see ch 02)
0x20 AC_FREQ (u8) — mains frequency, Hz (all variants — ZC-sourced from a dedicated pin)
0x30 I2C_ADDRESS (u8 RW) — slave address; change via two-phase commit (see ch 02)
0x86 U_rms (f32) — V
0x8A U_peak (f32) — V
0x8E I0_rms (f32) — A
0x92 I1_rms (f32) — A
0x96 I2_rms (f32) — A
0x9A I0_peak (f32) — A
0x9E I1_peak (f32) — A
0xA2 I2_peak (f32) — A
0xA6 P0_real (f32, ±) — W (sign: + consume, − export)
0xAA P1_real (f32, ±) — W
0xAE P2_real (f32, ±) — W
0xB2 PF0 (f32, ±) — −1..+1
0xB6 PF1 (f32, ±) — −1..+1
0xBA PF2 (f32, ±) — −1..+1
0xCA V03_PERIOD_MS (u32) — diagnostic, current snapshot-period duration
0xCE DATA_VALID (u8) — bit0 = valid after boot
0xD0 Q0_reac (f32, ≥0) — VAr, √(S²−P²), includes distortion
0xD4 Q1_reac (f32, ≥0) — VAr
0xD8 Q2_reac (f32, ≥0) — VAr
Suivant
- period-metering.md — instantané de période atomique pour l'accumulation tarifaire
- troubleshooting.md — que faire si les valeurs semblent fausses