03 · Echtzeit-Polling
Echtzeit-Polling — das regelmäßige Lesen der Augenblickswerte von U, I, P, PF, Flussrichtung und verwandter Größen (typisch einmal pro Messfenster, ~100 ms). Es dient zu:
- Live-Dashboards (aktuelle Leistung, Spannung)
- Schwellwertalarme
- Ereigniserkennung (Laststart / Lastabschaltung)
- Überwachung der Netzqualität (Frequenz, PF)
- Bestimmung der Stromrichtung — Verbrauch oder Einspeisung (aus dem Vorzeichen von P_real)
Für die Tarifenergiesumme (Wh über eine Periode) verwenden Sie den im Kapitel period-metering.md beschriebenen Periodenschnappschuss-Mechanismus.
Das Messfenster (100 ms)
Was es ist
Das Modul misst fortlaufend und veröffentlicht alle ~100 ms einen Ergebnissatz (Firmware-Images vor v1.2: alle ~200 ms):
- Effektivwerte von Spannung und Strömen
- Spitzenwerte von U und I
- Wirkleistung P, berechnet als
mean(u(t) · i(t))— vorzeichenbehaftet, das Vorzeichen zeigt die Flussrichtung an: P > 0— die Last bezieht Strom aus dem Netz (Normalbetrieb)P < 0— die Last speist in das Netz ein (Solarwechselrichter, generatorische Last)- Blindleistung Q, berechnet als
√(S² − P²)mitS = U_rms × I_rms— ohne Vorzeichen (≥ 0), enthält die Verzerrungsleistung; liefert 0 bei reinen I-Varianten und ist bei PF ≈ 1 verrauscht - Leistungsfaktor PF = P / S, mit S = U_rms × I_rms. Das Vorzeichen von PF entspricht dem von P — ein zusätzlicher Indikator für die Flussrichtung.
Nach der Berechnung eines Fensters veröffentlicht die Firmware den gesamten Ergebnissatz (50+ Byte) atomar im I2C-Registerblock 0x86..0xCD.
Fensterlänge ist fest
Das Fenster ist ab v1.2 fest auf 100 ms eingestellt, unabhängig von der Netzfrequenz. Bei Images vor v1.2 beträgt das Fenster 200 ms.
Bei 50 Hz Netz deckt ein 100-ms-Fenster genau 5 Zyklen ab; bei 60 Hz 6 Zyklen (10 bzw. 12 beim älteren 200-ms-Fenster). In beiden Fällen halten die ganzzahlige Anzahl der Netzzyklen Effektivwert und P genau.
Das Register V03_PERIOD_MS (0xCA..0xCD, u32 LE) meldet die bisherige Dauer der aktuellen Snapshot-Periode (ms seit dem letzten CMD_LATCH_PERIOD — siehe Kapitel 04). Es dient nur der Diagnose; es beeinflusst weder die Messgenauigkeit noch die Energieberechnung.
Wenn das nächste Fenster beginnt
Unmittelbar nach der Veröffentlichung des vorherigen. Zwischen den Fenstern gibt es keine Lücke — die Messung läuft durchgehend.
DATA_READY (DRDY) — der Bereit-Pin
DRDY ist ein Open-Drain-Ausgang, auf der Master-Seite auf 3.3 V hochgezogen. Die Firmware zieht ihn für ~10 µs auf LOW, nachdem die RT-Register aktualisiert wurden — ein Hardwaresignal, das „Daten sind zum Lesen bereit“ anzeigt.
Impulsparameter
- LOW-Dauer: ~10 µs (unkritisch für jeden Master mit EXTI)
- Frequenz: ~10 Hz (ein Impuls pro 100-ms-Fenster; ~5 Hz bei Images vor v1.2)
- Ausgangstyp: Open-Drain (unterstützt Wired-OR in Mehrmodultopologien)
- Bedeutung: die fallende Flanke garantiert, dass alle RT-Register kohärent und aktuell sind
Wenn DRDY nicht benötigt wird
- Der Master fragt langsamer ab als die Fensterrate (einmal pro Sekunde oder Minute) — die Daten werden zehnmal pro Sekunde aktualisiert (v1.2 und neuer), daher erhält jeder Lesevorgang frische Daten.
- Eine einfache Polling-Schleife —
read_rt()kann jederzeit aufgerufen werden; Sie erhalten das zuletzt committete Ergebnis.
Wann DRDY nützlich ist
- Der Master will den I2C-Verkehr minimieren oder CPU-Zeit für andere Aufgaben freimachen (batteriebetriebene Systeme)
- Präzise Synchronisation: den exakten Zeitpunkt des Messabschlusses erfassen (nützlich für hochauflösende Protokolle)
- Ereigniserkennung: auf jedes Fenster reagieren (z. B. Verfolgung der Augenblicksleistung im Raster von ~100 ms)
Verwendung (Arduino, ein Modul)
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);
}
}
— dieselbe Aufgabe ohne Registerzugriff:
| Bibliothek | Aufruf | Was es tut |
|---|---|---|
| Arduino | RbAmp::setDrdyPin(pin) / RbAmp::waitDataReady(timeout_ms, ev) |
die DRDY-Leitung anschließen; auf einen neuen Schnappschuss warten |
| ESP-IDF | rbamp_set_drdy_gpio() / rbamp_wait_data_ready() |
den DRDY-GPIO anschließen; auf einen neuen Snapshot warten |
| Python | — | nicht verfügbar — die Bibliothek verwendet den Pin nicht; behandeln Sie ihn in Ihrem eigenen Code |
| ESPHome | drdy_pin: |
optionaler DRDY-Eingang in YAML; die Komponente protokolliert ihn nur |
Das Vorzeichen von P und die Flussrichtung
In den RT-Registern ist das Vorzeichen der Wirkleistung der primäre Indikator der Stromrichtung:
| Bedingung | Bedeutung |
|---|---|
P_real > 0 |
Verbraucher nimmt auf (Strom fließt hinein) |
P_real < 0 |
Einspeisung ins Netz (Erzeugung) erfassen |
P_real ≈ 0, während I_rms > 0 |
Rein induktive Last (unbelasteter Transformator, Kondensator) |
Effektivwerte von Strom und Spannung sind immer ≥ 0 (der Effektivwert ist per Definition nicht negativ). Daher I_rms kann nicht zur Bestimmung der Flussrichtung verwendet werden — verwenden Sie P_real.
Beispiel zur Flussklassifikation
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
}
Bei BASIC-Firmware ignoriert der Tarifakkumulator ignoriert die Einspeisung (siehe period-metering.md). Die RT-Register führen dagegen immer das Echtzeit-Vorzeichen von P — so kann der Master auch bei einem BASIC-Artikel Einspeiseereignisse aus RT-Lesevorgängen erkennen, protokollieren oder auf der BASIC-Firmware einen bidirektionalen Akkumulator auf Master-Seite aufbauen.
RT-Registerreferenz
Alle Werte sind float32 little-endian (4 Byte). Das Lesen unterstützt automatisches Hochzählen — jeden Wert als einzelnen 4-Byte-Burst lesen (oder den gesamten Block 0x86..0xBD in einem Burst, siehe §Lese-Einfrieren). Ganzzahlige Felder sind mit ihrem Typ gekennzeichnet.
Spannung
| Adresse | Feld | Typ | Einheit | Beschreibung |
|---|---|---|---|---|
0x86 |
U_rms | float32 | V | Effektivspannung über das letzte Messfenster |
0x8A |
U_peak | float32 | V | Maximale Abweichung vom Mittelwert während des Fensters |
Ströme (je Kanal: 0 = primär, 1/2 bei UI2/UI3, mehr bei UI5/UI7)
| Adresse | Feld | Typ | Einheit |
|---|---|---|---|
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 |
Bei Varianten mit weniger Kanälen (z. B. UI1) liefern die ungenutzten Kanalregister 0.0f statt NACK. Varianten mit mehr Kanälen (UI5/UI7) legen ihre zusätzlichen I_rms-/P_real-/PF-/Q-Werte in Registern oberhalb von 0xCF ab; die vollständige Abbildung steht im Datenblatt der SKU.
Leistung
| Adresse | Feld | Typ | Einheit | Vorzeichen | Beschreibung |
|---|---|---|---|---|---|
0xA6 |
P0_real | float32 | W | ± | Wirkleistung, Kanal 0 — P > 0 = Verbrauch, P < 0 = Einspeisung |
0xAA |
P1_real | float32 | W | ± | Wirkleistung, Kanal 1 (UI2/UI3) |
0xAE |
P2_real | float32 | W | ± | Wirkleistung, Kanal 2 (UI3) |
0xB2 |
PF0 | float32 | – | ± | Leistungsfaktor, Bereich −1…+1, Vorzeichen entspricht P0 |
0xB6 |
PF1 | float32 | – | ± | |
0xBA |
PF2 | float32 | – | ± | |
0xD0 |
Q0_reac | float32 | VAr | ≥ 0 | Blindleistung Kanal 0 = √(S² − P²) — enthält die Verzerrungsleistung; bei PF ≈ 1 verrauscht; 0 bei reinen I-Varianten |
0xD4 |
Q1_reac | float32 | VAr | ≥ 0 | |
0xD8 |
Q2_reac | float32 | VAr | ≥ 0 |
Die Scheinleistung S kann auf der Masterseite berechnet werden: S = U_rms × I_rms. Effektivwerte sind immer ≥ 0; die Flussrichtung steckt im Vorzeichen von P.
Atomaritätsvorbehalt bei Q: Der RT-Block 0x86..0xBD (U/I/P/PF) wird unter einem Lese-Einfrieren geliefert und ist in einem einzigen Burst-Lesen garantiert frei von Mischzuständen. Die Q-Register (0xD0..0xDB) liegen außerhalb dieses Einfrierfensters — lesen Sie U/I/P und Q in zwei getrennten Transaktionen, stammen U/I/P aus einem kohärenten Schnappschuss, Q aber möglicherweise aus dem nächsten RT-Commit. Für die Kohärenz zwischen Größen unterhalb der Periodengranularität lesen Sie entweder Q unter einem CMD_LATCH_PERIOD-Schnappschuss (0xC2..0xC9 für Kanal 1/2 gemittelter Q ist nicht verfügbar — verwenden Sie den Schnappschussblock in Kapitel 11 §4.12) oder akzeptieren Sie den Versatz zwischen P und Q von bis zu einem Fenster (~100 ms).
System
| Adresse | Feld | Typ | Beschreibung |
|---|---|---|---|
0x00 |
STATUS | u8 | Bit 0 = bereit, Bit 1 = Fehler |
0x02 |
ERROR | u8 | Letzter Fehlercode (0x00 = OK) |
0x03 |
VERSION | u8 | Firmwareversion |
0x20 |
AC_FREQ | u8 | Netzfrequenz (Hz), 0, wenn kein Nulldurchgang erkannt wurde |
0xCE |
DATA_VALID | u8 | Bit 0 = gültiges Ergebnis seit dem Start verfügbar |
0xCA |
V03_PERIOD_MS | u32 LE | Dauer der bisherigen aktuellen Snapshot-Periode (ms, Diagnose — siehe Kap. 04) |
— dieselbe Aufgabe ohne Registerzugriff:
| Bibliothek | Aufruf | Was es tut |
|---|---|---|
| Arduino | RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readPower(ch) |
den gesamten RT-Block oder einen Wert nach dem anderen lesen |
| ESP-IDF | rbamp_read_all() / rbamp_read_power() |
den gesamten RT-Block oder einen Wert nach dem anderen lesen |
| Python | dev.read_all() / dev.read_power(ch) |
den gesamten RT-Block oder einen Wert nach dem anderen lesen |
| ESPHome | voltage / power |
YAML-Sensoren für die RT-Werte |
Abfrage — einzelnes Modul
Einfachste Abfrageschleife mit 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 in festen Intervallen ohne 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);
}
}
Das ergibt ~5 Messwerte pro Sekunde — jedes zweite Fenster (ab v1.2) (das Modul aktualisiert ca. alle 100 ms). Mit 100 ms abfragen, um jedes Fenster zu erfassen; das 200-ms-Intervall funktioniert auch bei Images vor v1.2.
— dieselbe Aufgabe ohne Registerzugriff:
| Bibliothek | Aufruf | Was es tut |
|---|---|---|
| Arduino | RbAmp::readAll(RbAmpSnapshot&) / RbAmp::readAllReady(timeout_ms, out, ev) |
den RT-Block lesen; oder auf einen neuen Snapshot warten und dann lesen |
| ESP-IDF | rbamp_read_all() / rbamp_read_all_ready() |
den RT-Block lesen; oder auf einen neuen Snapshot warten und dann lesen |
| Python | dev.read_all() |
den gesamten RT-Block in einem Aufruf lesen |
| ESPHome | update_interval: |
die Komponente liest den RT-Block bei jeder Aktualisierung in einem Burst |
Mehrkanal-Strom (UI2 / UI3 / UI5 / UI7)
Bei UI2/UI3-Varianten liest der Master Ströme und Leistungen aller Kanäle direkt aus dem Echtzeitblock. UI5 und UI7 (5 bzw. 7 Stromkanäle) verwenden dieselben Register für die Kanäle 0..2 und ein Kanal-Zugriffsfenster für die Kanäle 3 und höher — siehe UI5 / UI7: Kanäle 3 und höher unten.
// 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);
}
Die Stromkanäle sind unabhängig — jeder hat seine eigene CT-Zange mit eigenem Koeffizienten. Ein UI3-Modul kann beispielsweise die Hauptzuleitung, den Warmwasserbereiter und den Lichtkreis gleichzeitig auf derselben Phase überwachen. Das Vorzeichen von P kann sich zwischen Kanälen unterscheiden: Netzeingang P > 0 (das Haus bezieht aus dem Netz), während der Solarausgangskanal P < 0 zeigt (der Wechselrichter speist ein, während er dieselbe Phase versorgt, aus der das Haus bezieht).
UI5 / UI7: Kanäle 3 und höher
Der flache Echtzeitblock enthält nur die Kanäle 0, 1 und 2. Bei UI5 (Kanäle 0..4) und UI7 (Kanäle 0..6) werden die übrigen Kanäle über das Kanal-Zugriffsfenster gelesen: Schreiben Sie (field << 4) | channel nach REG_CHANNEL_SELECT (0x32), dann lesen Sie den Wert aus REG_CHANNEL_DATA (0x3C, float32). Felder: 0 = Effektivstrom, 1 = Scheitelstrom, 2 = Wirkleistung, 3 = Leistungsfaktor, 13 = Periodenmittelleistung.
Drei Regeln, die stillschweigend falsche Zahlen vermeiden:
- Das flache Schema nicht fortschreiben. Das Register nach
V03_I2_RMS(0x96) istV03_I0_PEAK(0x9A), nicht Kanal 3 — Kanal 3 und höher existieren nur im Fenster. - Vor jedem Lesen auswählen.
REG_CHANNEL_DATAist ein Schnappschuss, der beim Schreiben des Auswahlwerts gemacht wird; erneutes Lesen ohne neuen Auswahlschreibvorgang liefert denselben alten Wert. - Periodenmittelwert und Energie für Kanäle 3 und höher kommen nur aus Feld
13— für sie gibt es keine flachen Periodenregister.
// 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);
}
}
Das Fenster funktioniert auch für Kanal 0..2, sodass Sie es für alle Kanäle verwenden können, wenn Sie einen einheitlichen Codepfad bevorzugen (ein zusätzlicher kleiner Schreibvorgang je Wert). Details und alle Feldcodes: api-reference.md → Kanalzugriffsfenster.
Alle Kanäle teilen sich eine Spannung U
UI-Varianten enthalten einen einzigen Spannungssensor — er misst die Phase, die das Modul speist. Alle P-Werte der Kanäle werden gegen diese gemeinsame* U berechnet:
P0 = mean(u(t) · i0(t))
P1 = mean(u(t) · i1(t))
P2 = mean(u(t) · i2(t))
Dies setzt voraus, dass alle CT-Zangen an Leitern derselben Phase liegen.
— dieselbe Aufgabe ohne Registerzugriff:
| Bibliothek | Aufruf | Was es tut |
|---|---|---|
| Arduino | RbAmp::channels() / RbAmp::readCurrent(ch) |
die Kanalanzahl abrufen; einen Kanal über seinen Index lesen |
| ESP-IDF | rbamp_channels() / rbamp_read_channel() |
die Kanalanzahl abfragen; alle RT-Felder eines Kanals lesen (einschließlich 3 und höher) |
| Python | dev.channels / dev.current[ch] |
Kanalanzahl nach begin(); einen Kanal über den Index lesen |
| ESPHome | current_N: |
je Stromkanal einen Sensor-Slot deklarieren |
Abfrage mehrerer Module — drei Strategien
Strategie 1 — Rundlauf-Abfrage (einfach)
Der Master liest die Module der Reihe nach, z. B. bei jedem Fenster (~100 ms) oder jede Sekunde:
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);
}
Vorteile: minimaler Code, kein zusätzlicher GPIO nötig. Nachteile: CPU des Masters ständig beschäftigt; kein präziser Zeitstempel für „neues Fenster“.
Strategie 2 — DRDY pro Modul (präzise, GPIO-intensiv)
Der DRDY jedes Moduls ist an einen eigenen Master-GPIO angeschlossen, jeweils mit eigenem EXTI-Handler:
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);
}
}
}
Vorteile: präzise Synchronisation, minimale Leselatenz. Nachteile: ein GPIO und EXTI je Modul; skaliert nicht über etwa 4 Module hinaus.
Ansatz 3 — Wired-OR-DRDY (kompakt)
Alle DRDY-Pins (Open-Drain) sind an einer einzigen Leitung zusammengeschaltet. Der Master erkennt die fallende Flanke von irgendeinem Modul und liest alle Module:
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);
}
}
}
Vorteile: ein GPIO + EXTI für beliebig viele Module; wenig Verdrahtung. Nachteile: Der Master weiß nicht, welches Modul die Leitung ausgelöst hat — er muss alle lesen. Leicht versetzte Modulperioden (jedes Modul hat seinen eigenen Quarz) erzeugen „doppelte“ Auslösungen (ein Modul bereit, ein anderes eine Millisekunde später). Unschädlich — lesen Sie einfach alle Module.
Abwägungstabelle
| Vorgehen | Master-GPIO | Latenz | Komplexität | Skalierbarkeit |
|---|---|---|---|---|
| Polling ohne DRDY | 0 | bis zu 1 Fenster (~100 ms) | minimal | bis zu ca. 16 Module |
| DRDY pro Modul | N | < 1 ms | mittel | bis zu ca. 4 Module |
| Wired-OR-DRDY | 1 | ~1–5 ms | niedrig | bis zu ca. 10 Module |
Empfehlung
- 1–3 Module, geringe Latenz erforderlich → DRDY je Modul
- 3–10 Module, GPIO-Budget ist entscheidend → Wired-OR-DRDY
- Beliebige Anzahl, Latenz spielt keine Rolle → einfache Abfrage
— dieselbe Aufgabe ohne Registerzugriff:
| Bibliothek | Aufruf | Was es tut |
|---|---|---|
| Arduino | RbAmpFleet::scan(match_product, added) / RbAmpFleet::pollAll(snaps, status, capacity, n_ok) |
die Module erkennen; alle in einem Durchgang lesen |
| ESP-IDF | rbamp_fleet_scan() / rbamp_fleet_poll_all() |
die Module erkennen; alle in einem Durchgang lesen |
| Python | fleet.scan(match_product=True) / fleet.poll_all() |
die Module erkennen; alle in einem Durchgang lesen |
| ESPHome | rbamp: (Liste) |
ein rbamp:-Block je Modul, jeweils mit eigener id und address |
Nur-Strom-Varianten (ohne Spannungssensor)
Bei I1/I2/I3 (und höherkanaligen Varianten nur mit Strom), ohne Spannungssensor:
| Register | Rückgabewerte |
|---|---|
U_rms (0x86) |
0.0f |
U_peak (0x8A) |
0.0f |
I*_rms, I*_peak |
Echtwerte |
P*_real (0xA6, 0xAA, 0xAE) |
0.0f (keine U → keine P) |
PF*, Q* |
0.0f |
AC_FREQ (0x20) |
Realwert (50 oder 60). Die Nulldurchgangserkennung kommt von einem eigenen Netz-Nulldurchgangspin, unabhängig vom Spannungs-Eingangsteil, und ist bei allen Varianten verfügbar, auch bei Nur-Strom. |
ZC_OFFSET (0x4E) |
0xFFFF. Dieses Register ist der Phasenversatz zwischen dem GC-Snapshot-Zeitpunkt und dem nächsten Spannungs-Nulldurchgang, der zur U/I-Phasenkompensation dient — sinnvoll nur, wenn ein Spannungssignal gemessen wird. Bei reinen I-Varianten ist es auf 0xFFFF festgelegt (keine Spannungsmessung). |
Ohne P gibt es keine Information über die Stromrichtung — I_rms ist immer ≥ 0 und zeigt nicht an, in welche Richtung der Strom fließt.
Nur-Strom-Varianten sind vorgesehen für:
- Master, die eine eigene Spannungsquelle bereitstellen und P selbst berechnen (z. B. ein ESP32 mit eingebautem ZMPT-Modul plus ein rbAmp-I3 für drei Lasten)
- Reine Stromanwendungen: Erkennung der Laststufe, Überstromschutz, Ausgleich ohmscher Heizelemente
RT-Registerkurzreferenz
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
Weiter
- period-metering.md — atomarer Periodenschnappschuss für die Tarifsummierung
- troubleshooting.md — was zu tun ist, wenn Werte falsch aussehen