rbAmp
DE
Shop
Docs
Aktualisiert

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)

Zeitablauf des Messfensters und wann sein Ergebnissatz veröffentlicht wird.

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

Hinweis

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.

Wie das Messfenster mit dem Periodenschnappschuss zusammenhängt.

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)

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);
  }
}
In den Client-Bibliotheken

— 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

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

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
Hinweis

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
Hinweis

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)
In den Client-Bibliotheken

— 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

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 in festen Intervallen ohne 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);
  }
}

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.

In den Client-Bibliotheken

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

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

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) ist V03_I0_PEAK (0x9A), nicht Kanal 3 — Kanal 3 und höher existieren nur im Fenster.
  • Vor jedem Lesen auswählen. REG_CHANNEL_DATA ist 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.
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);
  }
}

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:

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

In den Client-Bibliotheken

— 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

Die drei Strategien zur Abfrage mehrerer Module: Round-Robin, DRDY pro Modul und Wired-OR-DRDY.

Strategie 1 — Rundlauf-Abfrage (einfach)

Der Master liest die Module der Reihe nach, z. B. bei jedem Fenster (~100 ms) oder jede Sekunde:

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

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:

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

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:

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

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
In den Client-Bibliotheken

— 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

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

Weiter