rbAmp
IT
Negozio
Docs
Aggiornato

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)

Tempistica della finestra di misura e momento in cui il suo insieme di risultati viene pubblicato.

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

Nota

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.

Come la finestra di misura si relaziona allo snapshot del periodo.

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)

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);
  }
}
Nelle librerie client

— 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

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
}
Nota

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
Nota

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
Nota

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)
Nelle librerie client

— 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

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);
}

Polling a intervallo fisso senza 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);
  }
}

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.

Nelle librerie client

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

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);
}

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

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

Nelle librerie client

— 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

Le tre strategie per il polling di più moduli: round-robin, DRDY per modulo e DRDY wired-OR.

Strategia 1 — polling a turno (semplice)

Il master legge i moduli a turno, per esempio ogni finestra (~100 ms) o ogni secondo:

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);
}

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:

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);
    }
  }
}

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:

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);
    }
  }
}

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
Nelle librerie client

— 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

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

Avanti