rbAmp
FR
Boutique
Docs
Mis à jour le

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)

Temporisation de la fenêtre de mesure et moment où son jeu de résultats est publié.

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²) avec S = 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.

Remarque

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.

Comment la fenêtre de mesure se rapporte à l'instantané de période.

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)

C++
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);
  }
}
Dans les bibliothèques clientes

— 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

C++
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
}
Remarque

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
Remarque

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
Remarque

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)
Dans les bibliothèques clientes

— 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

C++
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

C++
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.

Dans les bibliothèques clientes

— 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.

C++
// 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) est V03_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_DATA est 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.
C++
// 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* :

Text
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.

Dans les bibliothèques clientes

— 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

Les trois stratégies pour interroger plusieurs modules : tour à tour, DRDY par module et DRDY en collecteur ouvert commun.

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 :

C++
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 :

C++
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 :

Text
rbAmp #1 DRDY ──┐
rbAmp #2 DRDY ──┼──┬─[10K]── +3.3V
rbAmp #3 DRDY ──┘  │
                   ▼
              Master GPIO IN (EXTI falling)
C++
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
Dans les bibliothèques clientes

— 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

Text
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