03 · Polling in tempo reale
Polling in tempo reale — lettura dei valori istantanei di U, I, P, PF, direzione del flusso e grandezze correlate a intervalli regolari (tipicamente una volta per finestra di misura, ~100 ms). Serve per:
- Cruscotti in tempo reale (potenza e tensione attuali)
- Allarmi a soglia
- Rilevamento eventi (accensione / spegnimento del carico)
- Monitoraggio della qualità di rete (frequenza, PF)
- Determinare la direzione della corrente — consumo o esportazione (dal segno di P_real)
Per la contabilità energetica tariffaria (Wh su un periodo) usi il meccanismo di snapshot del periodo descritto in period-metering.md.
La finestra di misura (100 ms)
Cos'è
Il modulo misura in continuo e pubblica un insieme di risultati ogni ~100 ms (immagini firmware precedenti alla v1.2: ogni ~200 ms):
- RMS di tensione e correnti
- Valori di picco di U e I
- Potenza attiva P, calcolata come
mean(u(t) · i(t))— con segno, il segno indica il verso del flusso: P > 0— il carico assorbe dalla rete (modalità normale)P < 0— il carico immette in rete (inverter solare, carico rigenerativo)- Potenza reattiva Q, calcolata come
√(S² − P²)conS = U_rms × I_rms— senza segno (≥ 0), include la potenza di distorsione; legge 0 sulle varianti solo-I ed è rumorosa vicino a PF ≈ 1 - Fattore di potenza PF = P / S, con S = U_rms × I_rms. Il segno di PF coincide con quello di P — un ulteriore indicatore della direzione del flusso.
Dopo aver calcolato una finestra, il firmware pubblica atomicamente l'intero insieme di risultati (50+ byte) nel blocco di registri I²C 0x86..0xCD.
La lunghezza della finestra è fissa
La finestra è fissa a 100 ms dalla v1.2, indipendentemente dalla frequenza di rete. Sulle immagini precedenti alla v1.2 la finestra è di 200 ms.
Con rete a 50 Hz una finestra da 100 ms copre esattamente 5 cicli; a 60 Hz, 6 cicli (10 e 12 sulla vecchia finestra da 200 ms). In entrambi i casi il numero intero di cicli di rete mantiene accurati RMS e P.
Il registro V03_PERIOD_MS (0xCA..0xCD, u32 LE) riporta la durata del periodo di snapshot corrente finora (ms dall'ultimo CMD_LATCH_PERIOD — vedi capitolo 04). È solo diagnostico; non influisce sull'accuratezza della misura né sul calcolo dell'energia.
Quando inizia la finestra successiva
Subito dopo la pubblicazione della precedente. Non c'è intervallo tra le finestre — la misura è continua.
DATA_READY (DRDY) — il pin di pronto
DRDY è un'uscita open-drain tirata su a 3.3 V dal lato master. Il firmware la porta LOW per ~10 µs dopo che i registri RT sono stati aggiornati — un segnale hardware che dice "i dati sono pronti da leggere".
Parametri dell'impulso
- Durata LOW: ~10 µs (comodo per qualsiasi master con EXTI)
- Frequenza: ~10 Hz (un impulso per finestra da 100 ms; ~5 Hz sulle immagini precedenti alla v1.2)
- Tipo di uscita: open-drain (supporta il wired-OR nelle topologie multi-modulo)
- Significato: il fronte di discesa garantisce che tutti i registri RT siano coerenti e aggiornati
Quando DRDY non serve
- Il master fa polling più lentamente della frequenza della finestra (una volta al secondo o al minuto) — i dati si aggiornano dieci volte al secondo (v1.2 e successive), quindi ogni lettura riceve dati freschi.
- Un ciclo di polling elementare —
read_rt()si può chiamare in qualsiasi momento; si ottiene l'ultimo risultato confermato.
Quando DRDY è utile
- Il master vuole ridurre il traffico I²C o liberare CPU per altri compiti (sistemi alimentati a batteria)
- Sincronizzazione precisa: legga il momento esatto del completamento della misura (utile per log ad alta risoluzione)
- Rilevamento eventi: reagire a ogni finestra (per es. monitoraggio della potenza istantanea con granularità di ~100 ms)
Uso (Arduino, un modulo)
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);
}
}
— lo stesso compito senza accesso ai registri:
| Libreria | Chiamata | Cosa fa |
|---|---|---|
| Arduino | RbAmp::setDrdyPin(pin) / RbAmp::waitDataReady(timeout_ms, ev) |
colleghi la linea DRDY; attenda un nuovo snapshot |
| ESP-IDF | rbamp_set_drdy_gpio() / rbamp_wait_data_ready() |
collegare il GPIO DRDY; attendere un nuovo snapshot |
| Python | — | non esposto — la libreria non usa il pin; lo gestisca nel proprio codice |
| ESPHome | drdy_pin: |
ingresso DRDY opzionale nel YAML; il componente lo registra soltanto |
Il segno di P e la direzione del flusso
Nei registri RT il segno della potenza attiva è il principale indicatore del verso della corrente:
| Condizione | Significato |
|---|---|
P_real > 0 |
Il carico consuma (corrente che entra) |
P_real < 0 |
Carichi che esportano verso la rete (produzione) |
P_real ≈ 0 mentre I_rms > 0 |
Carico puramente reattivo (trasformatore a vuoto, condensatore) |
I valori RMS di corrente e tensione sono sempre ≥ 0 (per definizione l'RMS non è negativo). Quindi I_rms non può essere usato per determinare la direzione del flusso — usi P_real.
Esempio di classificazione del flusso
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
}
Sul firmware di livello BASIC l'accumulatore tariffario ignora l'esportazione (vedi period-metering.md). I registri RT, però, riportano sempre il segno reale in tempo reale di P — quindi anche su un SKU BASIC il master può rilevare eventi di esportazione dalle letture RT, registrarli, oppure costruire sul firmware BASIC un accumulatore bidirezionale lato master.
Riferimento dei registri RT
Tutti i valori sono float32 little-endian (4 byte). La LETTURA supporta l'incremento automatico — legga ogni valore come un unico burst di 4 byte (oppure l'intero blocco 0x86..0xBD in un solo burst, vedi §read-freeze). I campi interi sono indicati con il loro tipo.
Tensione
| Indirizzo | Campo | Tipo | Unità | Descrizione |
|---|---|---|---|---|
0x86 |
U_rms | float32 | V | Tensione RMS sull'ultima finestra di misura |
0x8A |
U_peak | float32 | V | Deviazione massima dalla media durante la finestra |
Correnti (per canale: 0 = primario, 1/2 su UI2/UI3, altri su UI5/UI7)
| Indirizzo | Campo | Tipo | 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 |
Sulle varianti con meno canali (per es. UI1), i registri dei canali inutilizzati restituiscono 0.0f invece di NACK. Le varianti con più canali (UI5/UI7) collocano i valori aggiuntivi di I_rms / P_real / PF / Q in registri oltre 0xCF; consulti la scheda tecnica della SKU per la mappa estesa.
Potenza
| Indirizzo | Campo | Tipo | Unità | Segno | Descrizione |
|---|---|---|---|---|---|
0xA6 |
P0_real | float32 | W | ± | Potenza attiva, canale 0 — P > 0 = assorbimento, P < 0 = immissione |
0xAA |
P1_real | float32 | W | ± | Potenza attiva, canale 1 (UI2/UI3) |
0xAE |
P2_real | float32 | W | ± | Potenza attiva, canale 2 (UI3) |
0xB2 |
PF0 | float32 | – | ± | Fattore di potenza, intervallo da −1 a +1, il segno corrisponde a P0 |
0xB6 |
PF1 | float32 | – | ± | |
0xBA |
PF2 | float32 | – | ± | |
0xD0 |
Q0_reac | float32 | VAr | ≥ 0 | Potenza reattiva ch0 = √(S² − P²) — include la potenza di distorsione; rumorosa vicino a PF ≈ 1; 0 sulle varianti solo-I |
0xD4 |
Q1_reac | float32 | VAr | ≥ 0 | |
0xD8 |
Q2_reac | float32 | VAr | ≥ 0 |
La potenza apparente S può essere ricavata lato master: S = U_rms × I_rms. I valori RMS sono sempre ≥ 0; la direzione del flusso sta nel segno di P.
Avvertenza sull'atomicità di Q: il blocco RT 0x86..0xBD (U/I/P/PF) è consegnato sotto un read-freeze ed è garantito privo di letture spezzate in un unico burst. I registri Q (0xD0..0xDB) sono fuori da quella finestra di freeze — se legge U/I/P + Q insieme in due transazioni separate, U/I/P saranno di uno snapshot coerente ma Q potrebbe appartenere al commit RT successivo. Per la coerenza tra grandezze a granularità inferiore al periodo, o legge Q sotto uno snapshot CMD_LATCH_PERIOD (0xC2..0xC9 per la Q media di ch1/ch2 non è esposta — usi il blocco di snapshot del capitolo 11 §4.12), oppure accetti uno sfasamento fino a una finestra (~100 ms) tra P e Q.
Sistema
| Indirizzo | Campo | Tipo | Descrizione |
|---|---|---|---|
0x00 |
STATUS | u8 | bit0 = pronto, bit1 = errore |
0x02 |
ERROR | u8 | Ultimo codice di errore (0x00 = OK) |
0x03 |
VERSION | u8 | Versione del firmware |
0x20 |
AC_FREQ | u8 | Frequenza di rete (Hz), 0 se non rilevato alcun passaggio per lo zero |
0xCE |
DATA_VALID | u8 | bit0 = risultato valido disponibile dall'avvio |
0xCA |
V03_PERIOD_MS | u32 LE | Durata del periodo di snapshot corrente finora (ms, diagnostica — vedi cap. 04) |
— lo stesso compito senza accesso ai registri:
| Libreria | Chiamata | Cosa fa |
|---|---|---|
| Arduino | RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readPower(ch) |
legga l'intero blocco RT, oppure un valore alla volta |
| ESP-IDF | rbamp_read_all() / rbamp_read_power() |
legga l'intero blocco RT, oppure un valore alla volta |
| Python | dev.read_all() / dev.read_power(ch) |
legga l'intero blocco RT, oppure un valore alla volta |
| ESPHome | voltage / power |
Sensori YAML per i valori RT |
Polling — singolo modulo
Ciclo di polling semplice a 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);
}
Polling a intervallo fisso senza 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);
}
}
Si ottengono circa 5 campioni al secondo — una finestra sì e una no (v1.2 e successive) (il modulo aggiorna ogni ~100 ms). Interroghi ogni 100 ms per catturare ogni finestra; l'intervallo di 200 ms funziona anche sulle immagini precedenti alla v1.2.
— lo stesso compito senza accesso ai registri:
| Libreria | Chiamata | Cosa fa |
|---|---|---|
| Arduino | RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readAllReady(timeout_ms, out, ev) |
legga il blocco RT; oppure attenda un nuovo snapshot, poi lo legga |
| ESP-IDF | rbamp_read_all() / rbamp_read_all_ready() |
legga il blocco RT; oppure attenda un nuovo snapshot, poi lo legga |
| Python | dev.read_all() |
legga l'intero blocco RT in una sola chiamata |
| ESPHome | update_interval: |
il componente legge il blocco RT in un solo burst a ogni aggiornamento |
Corrente multicanale (UI2 / UI3 / UI5 / UI7)
Sulle varianti UI2/UI3 il master legge correnti e potenze di tutti i canali direttamente dal blocco real-time. UI5 e UI7 (5 e 7 canali di corrente) usano gli stessi registri per i canali 0..2 e una finestra di accesso ai canali per i canali 3 e successivi — vedi UI5 / UI7: canali 3 e successivi più sotto.
// 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);
}
I canali di corrente sono indipendenti — ciascuno ha la propria pinza CT con il proprio coefficiente. Un modulo UI3 può monitorare, per esempio, l'alimentazione principale, lo scaldabagno e il circuito di illuminazione contemporaneamente sulla stessa fase. Il segno di P può differire tra canali: P ingresso master > 0 (la casa assorbe dalla rete) mentre il canale dell'uscita solare mostra P < 0 (l'inverter immette in rete mentre alimenta la stessa fase da cui la casa assorbe).
UI5 / UI7: canali 3 e superiori
Il blocco real-time piatto contiene solo i canali 0, 1 e 2. Su UI5 (canali 0..4) e UI7 (canali 0..6) gli altri canali si leggono tramite la finestra di accesso ai canali: scriva (field << 4) | channel in REG_CHANNEL_SELECT (0x32), poi legga il valore da REG_CHANNEL_DATA (0x3C, float32). Campi: 0 = corrente RMS, 1 = corrente di picco, 2 = potenza attiva, 3 = fattore di potenza, 13 = potenza media di periodo.
Tre regole che evitano numeri silenziosamente sbagliati:
- Non estenda lo schema piatto. Il registro dopo
V03_I2_RMS(0x96) èV03_I0_PEAK(0x9A), non il canale 3 — il canale 3 e quelli successivi esistono solo nella finestra. - Selezioni prima di ogni lettura.
REG_CHANNEL_DATAè uno snapshot preso quando si scrive il selettore; rileggerlo senza una nuova scrittura del selettore restituisce lo stesso valore vecchio. - Il valore medio di periodo e l'energia per i canali 3 e successivi provengono solo dal campo
13— per questi non esistono registri di periodo piatti.
// 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 finestra funziona anche per i canali 0..2, quindi può usarla per tutti i canali se preferisce un unico percorso di codice (una piccola scrittura in più per valore). Dettagli e tutti i codici dei campi: api-reference.md → Finestra di accesso ai canali.
Tutti i canali condividono una tensione U
Le varianti UI contengono un singolo sensore di tensione — misura la fase che alimenta il modulo. Tutti i valori P dei canali sono calcolati rispetto a questa condivisa* U:
P0 = mean(u(t) · i0(t))
P1 = mean(u(t) · i1(t))
P2 = mean(u(t) · i2(t))
Questo presuppone che tutte le pinze CT siano sui conduttori della stessa fase.
— lo stesso compito senza accesso ai registri:
| Libreria | Chiamata | Cosa fa |
|---|---|---|
| Arduino | RbAmp::channels() / RbAmp::readCurrent(ch) |
legga il numero di canali; legga un canale per indice |
| ESP-IDF | rbamp_channels() / rbamp_read_channel() |
legga il numero di canali; legga tutti i campi RT di un canale (incluso 3 e successivi) |
| Python | dev.channels / dev.current[ch] |
numero di canali dopo begin(); legga un canale per indice |
| ESPHome | current_N: |
dichiari uno slot sensore per ogni canale di corrente |
Polling multi-modulo — tre strategie
Strategia 1 — polling a turno (semplice)
Il master legge i moduli a turno, per esempio ogni finestra (~100 ms) o ogni secondo:
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);
}
Pro: codice minimo, nessun GPIO extra richiesto. Contro: la CPU del master è sempre occupata; nessun marcatore temporale preciso di "nuova finestra".
Strategia 2 — DRDY per modulo (precisa, ricca di GPIO)
Il DRDY di ogni modulo è collegato al proprio GPIO del master, ciascuno con il proprio gestore 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);
}
}
}
Pro: sincronizzazione precisa, latenza di lettura minima. Contro: un GPIO + EXTI per modulo; non scala oltre ~4 moduli.
Strategia 3 — DRDY wired-OR (compatta)
Tutti i pin DRDY (open-drain) sono collegati su un unico filo. Il master rileva il fronte di discesa di qualsiasi modulo e legge tutti i moduli:
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);
}
}
}
Pro: un GPIO + EXTI per qualsiasi numero di moduli; economico in fili. Contro: il master non sa quale modulo ha asserito la linea — deve leggerli tutti. Periodi dei moduli leggermente sfasati (ogni modulo ha il proprio quarzo) producono trigger « doppi » (un modulo pronto, un altro un millisecondo dopo). Innocuo: legga semplicemente tutti i moduli.
Tabella dei compromessi
| Approccio | GPIO del master | Latenza | Complessità | Scalabilità |
|---|---|---|---|---|
| Polling senza DRDY | 0 | fino a 1 finestra (~100 ms) | minimo | fino a ~16 moduli |
| DRDY per modulo | N | < 1 ms | medio | fino a ~4 moduli |
| DRDY wired-OR | 1 | ~1–5 ms | basso | fino a ~10 moduli |
Raccomandazione
- 1–3 moduli, è richiesta bassa latenza → DRDY per modulo
- Da 3 a 10 moduli, il budget dei GPIO conta → DRDY wired-OR
- Qualsiasi numero di moduli, la latenza non conta → polling semplice
— lo stesso compito senza accesso ai registri:
| Libreria | Chiamata | Cosa fa |
|---|---|---|
| Arduino | RbAmpFleet::scan(match_product, added) / RbAmpFleet::pollAll(snaps, status, capacity, n_ok) |
individui i moduli; li legga tutti in un solo passaggio |
| ESP-IDF | rbamp_fleet_scan() / rbamp_fleet_poll_all() |
individui i moduli; li legga tutti in un solo passaggio |
| Python | fleet.scan(match_product=True) / fleet.poll_all() |
individui i moduli; li legga tutti in un solo passaggio |
| ESPHome | rbamp: (elenco) |
un blocco rbamp: per modulo, ciascuno con il proprio id e address |
Varianti solo corrente (senza sensore di tensione)
Su I1/I2/I3 (e sulle varianti con soli canali di corrente di numero superiore), senza sensore di tensione:
| Registro | Valori restituiti |
|---|---|
U_rms (0x86) |
0.0f |
U_peak (0x8A) |
0.0f |
I*_rms, I*_peak |
Valori reali |
P*_real (0xA6, 0xAA, 0xAE) |
0.0f (nessuna U → nessuna P) |
PF*, Q* |
0.0f |
AC_FREQ (0x20) |
Valore reale (50 o 60). Il rilevamento dello zero-crossing proviene da un pin dedicato di zero-crossing di rete, indipendente dal front-end di tensione, ed è disponibile su tutte le varianti, incluse quelle solo corrente. |
ZC_OFFSET (0x4E) |
0xFFFF. Questo registro è lo sfasamento tra l'istante dello snapshot GC e il successivo passaggio per lo zero della tensione, usato per la compensazione di fase U/I — significativo solo quando si misura un segnale di tensione. Sulle varianti solo-I è forzato a 0xFFFF dal firmware (nessuna misura di tensione). |
Senza P non si ha alcuna informazione sul verso della corrente — I_rms è sempre ≥ 0 e non mostra in quale direzione scorre la corrente.
Le varianti solo corrente sono pensate per:
- Master che forniscono la propria sorgente di tensione e calcolano P da soli (per esempio un ESP32 con un modulo ZMPT integrato più un rbAmp-I3 per tre carichi)
- Applicazioni solo-corrente: rilevamento della presenza di carico, protezione da sovracorrente, bilanciamento di elementi riscaldanti resistivi
Riferimento rapido dei registri RT
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
Avanti
- period-metering.md — snapshot atomico del periodo per l'accumulo tariffario
- troubleshooting.md — cosa fare se i valori sembrano errati