Beispiele
Durchgang durch die mitgelieferten examples/-Sketches sowie zusammengesetzte Szenarien. Die meisten nummerierten Beispiele unten haben passenden Code in examples/ — öffnen Sie die echten Sketches in der Arduino IDE für den vollständigen Quelltext.
| # | Titel | Schwierigkeit | Quelldatei |
|---|---|---|---|
| 1 | Schnelllesung | minimal | 01_QuickRead.ino |
| 2 | 60-Sekunden-Zähler auf OLED | niedrig | 02_PeriodEnergyOLED.ino |
| 3 | Mehrmodul-Monitor (3 Geräte) | niedrig | 03_MultiModuleBroadcast.ino |
| 4 | UI3 je Gerät + MQTT | mittel | 04_UI3PerChannelMQTT.ino |
| 5 | Bilanzierung in beide Richtungen auf der Masterseite | mittel | 06_BidirectionalEnergy.ino |
| 6 | Energiebilanz des Hauses | hoch | (composed) |
| 7 | Ereigniserkennung (EMA) | mittel | (composed) |
| 8 | 12-Stunden-autonomer Prüfstand-Monitor | mittel | (Code in diesem Kapitel) |
| 9 | Batteriebetriebener Tiefschlaf-Logger | mittel | 07_DeepSleepLogger.ino |
| 10 | Änderung der I2C-Adresse | niedrig | 05_AddressChange.ino |
| 11 | Ein Sketch, beide Modullinien (BASIC + STD) | mittel | 11_StdLine.ino |
Szenario 1 — Schnelllesezugriff
Ziel: U / I / P / PF / Frequenz einmal pro Sekunde ausgeben. Das "Hallo Welt", das Sie gerade in der Schnellstart-Anleitung geschrieben haben, aber mit dev.readAll(s) für einen einmaligen vollständigen RT-Blocklesezugriff statt einzelner Property-Aufrufe.
#include
#include
static RbAmp dev(Wire, 0x50);
void setup() {
Serial.begin(115200);
while (!Serial && millis() < 3000) {}
Wire.begin();
dev.setLogStream(&Serial);
while (!dev.begin()) {
Serial.print(F("begin: ")); Serial.println(RbAmp::errorString(dev.lastError()));
delay(1000);
}
}
void loop() {
RbAmpSnapshot s;
if (!dev.readAll(s)) {
Serial.print(F("read fail: ")); Serial.println(RbAmp::errorString(dev.lastError()));
delay(1000); return;
}
Serial.print(F("U=")); Serial.print(s.voltage, 1); Serial.print(F("V "));
Serial.print(F("f=")); Serial.print(s.frequency, 1); Serial.print(F("Hz "));
for (uint8_t ch = 0; ch < s.channels; ++ch) {
Serial.print(F("I")); Serial.print(ch); Serial.print(F("="));
Serial.print(s.current[ch], 2); Serial.print(F("A "));
Serial.print(F("P")); Serial.print(ch); Serial.print(F("="));
Serial.print(s.power[ch], 1); Serial.print(F("W "));
Serial.print(F("PF")); Serial.print(ch); Serial.print(F("="));
Serial.print(s.power_factor[ch], 2); Serial.print(F(" "));
}
Serial.println();
delay(1000);
}
Was auf dem Bus passiert: readAll() an einem UI3 löst 53 Einzelbyte-Transaktionen aus (13 Floats × 4 Bytes + 1 Byte Frequenz). Bei 100 kHz mit Reserve für 3 Wiederholungsversuche insgesamt ca. 12–15 ms. Auf Lesezugriffe je Aufruf (dev.voltage, dev.current[ch]) wechseln, wenn Sie nur eine Teilmenge brauchen.
Szenario 2 — 60-Sekunden-Zähler auf OLED
Wh-Zähler wird einmal pro Minute auf einem 128×64-SSD1306-OLED aktualisiert, das den I2C-Bus teilt (OLED bei 0x3C). Wichtige Bibliotheksmechanik: readPeriodSnapshot() erledigt Snapshot + Einschwingen + Gültigkeitsprüfung + Lesen + Wh-Takt in einem Aufruf.
#include
#include
#include
#include
static Adafruit_SSD1306 oled(128, 64, &Wire, -1);
static RbAmp dev(Wire, 0x50);
static uint32_t next_latch_ms = 0;
static uint32_t snapshots_ok = 0, snapshots_bad = 0;
void setup() {
Serial.begin(115200);
Wire.begin();
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(1000); }
next_latch_ms = millis() + 60000;
}
void loop() {
if (millis() < next_latch_ms) { delay(50); return; }
next_latch_ms = millis() + 60000;
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) { snapshots_bad++; return; }
snapshots_ok++;
oled.clearDisplay();
oled.setTextColor(SSD1306_WHITE);
oled.setCursor(0, 0); oled.setTextSize(1); oled.println(F("rbAmp Energy Meter"));
oled.setCursor(0, 16); oled.setTextSize(2); oled.print(snap.avg_p[0], 1); oled.println(F(" W"));
oled.setTextSize(1);
oled.print(F("Wh:")); oled.println(dev.energy().wh(0), 4);
oled.print(F("ok=")); oled.print(snapshots_ok);
oled.print(F(" bad=")); oled.println(snapshots_bad);
oled.display();
}
Vollständiger Sketch in 02_PeriodEnergyOLED.ino.
Behandlung veralteter Snapshots: readPeriodSnapshot() liefert false mit lastError() == RB_ERR_STALE, wenn REG_V03_PERIOD_VALID == 0. Die Bibliothek übernimmt dennoch den Master-Wanduhr-Zeitstempel intern — so kann der nächste erfolgreiche Snapshot Wh über ein 2-fach-Periodenintervall nicht doppelt zählen.
Szenario 3 — Monitor mit mehreren Modulen
Drei rbAmp-Module an einem Bus bei 0x50 / 0x51 / 0x52. Jedes braucht eine eindeutige I2C-Adresse — verwenden Sie Szenario 10, um bei der Installation Adressen zuzuweisen.
jedes Modul, das die General-Call-Momentaufnahme unterstützt und sie aktiviert hat (enableGc(true), gespeichert), erfasst die gleiche Netzperiode in einem einzigen All-Call-Rahmen — RbAmp::broadcastLatchGroup(Wire, 0x00, tick). Der Versatz der Flotte beträgt weniger als 10 µs, daher summieren sich die Einzelleistungen kohärent. Jedes Modul versieht seine Momentaufnahme mit dem Broadcast-tick; lesen Sie ihn mit readGcTick() zurück, um ein Modul zu erkennen, das den Rahmen verpasst hat. (Bei Firmware v1.0/v1.1 war die General-Call-Momentaufnahme nicht verfügbar, und dieser Sketch wich auf sequentielle Momentaufnahmen je Gerät aus — im Verlaufskommentar der Datei für ältere Module belassen.)
#include
#include
static RbAmp T0(Wire, 0x50);
static RbAmp T1(Wire, 0x51);
static RbAmp T2(Wire, 0x52);
static RbAmp* modules[] = { &T0, &T1, &T2 };
static const uint8_t N = sizeof(modules) / sizeof(modules[0]);
static uint16_t g_tick = 0;
void setup() {
Serial.begin(115200);
Wire.begin();
Wire.setClock(50000); // 50 kHz on ESP32 / 100 kHz on non-ESP32 masters
for (uint8_t i = 0; i < N; ++i) {
modules[i]->begin();
modules[i]->enableGc(true); // opt into General-Call snapshot (persisted)
}
}
void loop() {
g_tick++;
RbAmp::broadcastLatchGroup(Wire, /*group=*/0x00, g_tick); // 0x00 = all-call
delay(50); // single shared settle for the whole bus
for (uint8_t i = 0; i < N; ++i) {
RbAmpPeriodSnapshot snap;
if (modules[i]->readPeriodSnapshot(snap, /*settle_ms=*/0, /*skip_latch=*/true)) {
uint16_t tick;
bool synced = modules[i]->readGcTick(tick) && tick == g_tick;
Serial.print(F("T")); Serial.print(i);
Serial.print(F(" P=")); Serial.print(snap.avg_p[0], 0);
Serial.print(F("W Wh=")); Serial.print(modules[i]->energy().wh(0), 3);
Serial.println(synced ? F(" [sync]") : F(" [MISSED FRAME]"));
}
}
delay(60000);
}
Vollständiger Sketch (mit Bus-Scan-Prüfung und Fehlermeldung) in 03_MultiModuleBroadcast.ino.
Szenario 4 — UI3 je Gerät + MQTT
Ein UI3-Modul mit drei Stromwandlerzangen an drei Lasten. Unabhängige Wh-Zähler je Kanal, einmal pro Minute per MQTT veröffentlicht. Zeigt, dass dev.energy().wh(ch) auf jedem Kanal unabhängig funktioniert — kein manuelles Array total_wh[3] nötig.
#include
#include
#include
#include
static RbAmp dev(Wire, 0x50);
static const char* CH_NAMES[3] = {"main", "heatpump", "lights"};
static WiFiClient espClient;
static PubSubClient mqtt(espClient);
void publish_channel(const char* name, float avg_p, double e_wh) {
char topic[64], payload[96];
snprintf(topic, sizeof(topic), "rbamp/%s/state", name);
snprintf(payload, sizeof(payload), "{\"power\":%.1f,\"energy\":%.4f}", avg_p, e_wh);
mqtt.publish(topic, payload, true);
}
void setup() {
Serial.begin(115200);
WiFi.begin("ssid", "pass");
while (WiFi.status() != WL_CONNECTED) delay(500);
mqtt.setServer("192.168.1.10", 1883);
mqtt.setKeepAlive(60);
mqtt.connect("rbamp-ui3");
Wire.begin();
Wire.setClock(50000); // reduced bus clock on ESP32
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
}
void loop() {
if (!mqtt.connected()) mqtt.connect("rbamp-ui3");
mqtt.loop();
static uint32_t last_period = 0;
if (last_period == 0) last_period = millis();
if (millis() - last_period < 60000) { delay(50); return; }
last_period = millis();
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) return;
for (uint8_t ch = 0; ch < dev.channels(); ++ch) {
publish_channel(CH_NAMES[ch], snap.avg_p[ch], dev.energy().wh(ch));
}
}
Vollständiger Sketch in 04_UI3PerChannelMQTT.ino. Für die HA-MQTT-Auto-Discovery auf dieser Basis siehe DIY-Integrationen.
Szenario 5 — Bidirektionale Abrechnung auf Masterseite
Zerlegt die vorzeichenbehaftete RT-Leistung in Bruttobezug und Bruttoeinspeisung. Verwenden Sie dies bei Modulen der BASIC-Stufe, bei denen der Periodenakkumulator negative Werte begrenzt — auf der Masterseite dev.readPower(0) mit 10 Hz abtasten.
#include
#include
static RbAmp dev(Wire, 0x50);
static double consume_wh = 0.0;
static double export_wh = 0.0;
static uint32_t last_sample_ms = 0;
void setup() {
Serial.begin(115200);
Wire.begin();
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
last_sample_ms = millis();
}
void loop() {
if (millis() - last_sample_ms < 100) { delay(5); return; } // 10 Hz — matches RT cadence
const uint32_t now_ms = millis();
const uint32_t dt_ms = now_ms - last_sample_ms;
last_sample_ms = now_ms;
const float p_w = dev.readPower(0);
if (isnan(p_w)) return;
const double dwh = (double)p_w * dt_ms / 3600000.0;
if (p_w >= 0.0f) consume_wh += dwh;
else export_wh += -dwh;
static uint32_t next_print = 0;
if (millis() >= next_print) {
next_print = millis() + 200;
Serial.print(F("P=")); Serial.print(p_w, 1);
Serial.print(F("W cons=")); Serial.print(consume_wh, 4);
Serial.print(F("Wh exp=")); Serial.print(export_wh, 4);
Serial.print(F("Wh net=")); Serial.print(consume_wh - export_wh, 4);
Serial.println(F("Wh"));
}
}
Vollständiger Sketch in 06_BidirectionalEnergy.ino. Auf einem STANDARD-(STD)-Modul liefert dev.energy().wh(0) bereits den vorzeichenbehafteten Nettosaldo — diese masterseitige Aufteilung brauchen Sie nur für die getrennte Ausweisung von Bruttoverbrauch und Bruttoeinspeisung.
Szenario 6 — Energiebilanz des Hauses
Drei Module: Netz (bidirektional, STANDARD (STD)) + Solar (nur Erzeugung, BASIC genügt)
- Lasten (UI3 BASIC für Geräte je Gerät). Kombiniertes Hausdashboard, alle 60 s veröffentlicht.
#include
#include
#include
#include
static RbAmp mains(Wire, 0x50); // bidirectional
static RbAmp solar(Wire, 0x51); // generation only
static RbAmp loads(Wire, 0x52); // UI3
static RbAmp* mods[] = { &mains, &solar, &loads };
static WiFiClient espClient;
static PubSubClient mqtt(espClient);
void setup() {
Serial.begin(115200);
WiFi.begin("ssid", "pass");
while (WiFi.status() != WL_CONNECTED) delay(500);
mqtt.setServer("192.168.1.10", 1883); mqtt.connect("home-balance");
Wire.begin();
Wire.setClock(50000); // 50 kHz on ESP32 (100 kHz on non-ESP32 masters)
for (auto m : mods) { while (!m->begin()) delay(500); m->enableGc(true); }
}
void loop() {
delay(60000);
static uint16_t g_tick = 0;
RbAmp::broadcastLatchGroup(Wire, /*group=*/0x00, ++g_tick); // coherent all-call snapshot
delay(50);
RbAmpPeriodSnapshot sm, ss, sl;
mains.readPeriodSnapshot(sm, 0, true);
solar.readPeriodSnapshot(ss, 0, true);
loads.readPeriodSnapshot(sl, 0, true);
char payload[512];
snprintf(payload, sizeof(payload),
"{\"mains\":%.3f,\"solar\":%.3f,\"hp\":%.3f,\"ac\":%.3f,\"ev\":%.3f}",
mains.energy().wh(0),
solar.energy().wh(0),
loads.energy().wh(0),
loads.energy().wh(1),
loads.energy().wh(2));
mqtt.publish("home/energy/balance", payload, true);
mqtt.loop();
}
Für die explizite Trennung Bezug/Einspeisung am Netzmodul kombinieren Sie dies mit dem Muster aus Szenario 5 (eine separate 10-Hz-Schleife auf mains.readPower(0)).
Szenario 7 — Ereigniserkennung (EMA)
Vergleichen Sie bei jedem RT-Fenster von 100 ms P mit einem exponentiell gewichteten gleitenden Mittelwert. Protokollieren Sie signifikante Abweichungen (Mikrowelle / Wasserkocher).
#include
#include
static RbAmp dev(Wire, 0x50);
static float p_ema = 0.0f;
static const float EMA_ALPHA = 0.05f;
static const float EVENT_THRESHOLD_W = 200.0f;
void setup() {
Serial.begin(115200);
Wire.begin();
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
p_ema = dev.readPower(0); // seed EMA so first read isn't a spurious event
if (isnan(p_ema)) p_ema = 0.0f;
}
void loop() {
delay(200);
const float p = dev.readPower(0);
if (isnan(p)) return;
const float delta = p - p_ema;
p_ema = (1.0f - EMA_ALPHA) * p_ema + EMA_ALPHA * p;
if (fabsf(delta) > EVENT_THRESHOLD_W) {
Serial.print(millis()); Serial.print(F(" "));
Serial.print(delta > 0 ? F("TURN_ON ") : F("TURN_OFF "));
Serial.print(F("delta=")); Serial.print(delta, 0); Serial.print(F("W "));
Serial.print(F("P=")); Serial.print(p, 0); Serial.print(F("W "));
Serial.print(F("EMA=")); Serial.println(p_ema, 0);
}
}
Zusammengesetztes Szenario — keine eigene Beispieldatei. Kombinieren Sie es mit dem MQTT-Veröffentlichen aus Szenario 4 für die Ereignis-Automatisierung in HA oder protokollieren Sie mit Adafruit_SD auf SD für die Offline-Ereignisverfolgung.
Szenario 8 — 12-Stunden-autonomer Prüfstand-Monitor
Dauertest-Validierungsharness — führt die Bibliothek 12–15 Stunden gegen ein echtes DUT unter dichter Last je Zyklus aus und schreibt alle 5 Minuten eine CSV-Zeile mit vollständigen Diagnosezählern. Das Referenzrezept zur Qualifizierung der Firmware v1.1 auf dem Referenz-Master der Arduino-Bibliothek.
Wichtige Merkmale:
-
Überschreibung
RBAMP_NACK_RETRY_ATTEMPTS=5— vor dem Include definieren, um die Wiederholung bei dichter Last anzupassen (≥10 Einzelbyte-Lesungen je Zyklus). Standard 3 genügt für die 60-s-Abfrage von ESPHome; SoakMonitor liest ca. 45 Bytes je Zyklus und braucht die zusätzliche Reserve. -
dev.rawTopology()— direktes Lesen von REG_TOPOLOGY (0x24) über den Bus zur Erkennung von v1.1. Liefert 1/2/3 auf v1.1,0x00auf v1.0,0xFFbei einem I2C-Fehler. -
dev.retryExhaustionCount()+dev.sanityRejectCount()— beide müssen bei einem bestandenen 12-h-Lauf auf 0 bleiben.
Gerüst je Zyklus:
#define RBAMP_NACK_RETRY_ATTEMPTS 5
#include
#include
RbAmp dev(Wire, 0x50);
void emitCycle() {
const float u = dev.readVoltage();
float i[3]={NAN,NAN,NAN}, p[3]={NAN,NAN,NAN}, pf[3]={NAN,NAN,NAN};
for (uint8_t c = 0; c < dev.channels(); c++) {
i[c] = dev.readCurrent(c);
p[c] = dev.readPower(c);
pf[c] = dev.readPowerFactor(c);
}
const float freq = dev.readFrequency();
RbAmpPeriodSnapshot snap;
const bool snap_ok = dev.readPeriodSnapshot(snap, 60);
/* CSV row (shortened) */
Serial.printf("%lu,%.3f,%.4f,%.3f,%.4f,%.1f,%.4f,%lu,%lu,%.6f,%lu,%lu,%u\n",
millis(), u, i[0], p[0], pf[0], freq,
snap.avg_p[0], snap.latch_ms, snap.master_dt_ms,
dev.energy().wh(0),
dev.retryExhaustionCount(),
dev.sanityRejectCount(),
snap_ok ? 1 : 0);
}
void setup() {
Serial.begin(115200);
Wire.begin(21, 22); Wire.setClock(50000);
while (!dev.begin()) delay(500);
dev.resetCounters();
emitCycle();
}
void loop() {
static uint32_t next_ms = 5UL * 60UL * 1000UL;
if (millis() >= next_ms) { emitCycle(); next_ms += 5UL * 60UL * 1000UL; }
delay(100);
}
Der Sketch wird aus den Ausschnitten dieses Szenarios erstellt. Starten Sie mit arduino-cli monitor -p COM3 -c baudrate=115200 > soak.csv und lassen Sie ihn 12–15 h unbeaufsichtigt laufen. Abnahmekriterien: retry_exhaust == 0, sanity_reject == 0, period_ok / period_total ≥ 99 %, Wh monoton.
Szenario 9 — Batteriebetriebener Tiefschlaf-Logger
Der ESP32 wacht alle 10 Minuten auf, nimmt einen Periodensnapshot, veröffentlicht über WLAN+MQTT und geht in den Tiefschlaf. Die Energie bleibt über den RTC-Speicher über den Schlaf hinweg erhalten. Der Bibliotheksakkumulator ist deaktiviert — der Master verwaltet die Wh-Persistenz.
Bibliotheksrelevantes Gerüst:
#include
#include
#include "esp_sleep.h"
RTC_DATA_ATTR uint32_t rtc_magic = 0;
RTC_DATA_ATTR double rtc_total_wh = 0;
RTC_DATA_ATTR bool rtc_primer_done = false;
void setup() {
Serial.begin(115200);
Wire.begin();
RbAmp dev(Wire, 0x50);
if (rtc_magic != 0xCAFEFEED) {
rtc_magic = 0xCAFEFEED; rtc_total_wh = 0; rtc_primer_done = false;
}
dev.begin();
dev.energy().disable(); // master owns Wh
if (!rtc_primer_done) {
dev.latchPeriod();
rtc_primer_done = true;
esp_sleep_enable_timer_wakeup(10ULL * 60ULL * 1000000ULL);
esp_deep_sleep_start();
}
RbAmpPeriodSnapshot snap;
if (dev.readPeriodSnapshot(snap)) {
// master_dt_ms measures actual wake-to-wake interval
rtc_total_wh += (double)snap.avg_p[0] * snap.master_dt_ms / 3600000.0;
publish_via_wifi(snap.avg_p[0], rtc_total_wh, snap.master_dt_ms);
}
esp_sleep_enable_timer_wakeup(10ULL * 60ULL * 1000000ULL);
esp_deep_sleep_start();
}
void loop() {}
Vollständiger Sketch (mit WLAN-Einrichtung, MQTT-Veröffentlichung, RTC-Magic-Marker-Schutz) in 07_DeepSleepLogger.ino.
Leistungsbudget (ESP32-WROOM, Weckintervall 10 Minuten):
- Aufwachdauer: ca. 3 s (WLAN + MQTT + I2C)
- Aufwachstrom: ca. 80 mA im Mittel → ca. 0.07 mAh je Aufwachvorgang
- Ruhestrom: ca. 10 µA (RTC + erhaltene Domänen)
- ~10 mAh/Tag insgesamt → 2000-mAh-Li-Ion hält ~6 Monate
Szenario 10 — Änderung der I2C-Adresse
Ordnen Sie die Slave-Adresse eines rbAmp von 0x50 auf 0x51 neu zu. Wird einmal je Modul beim Aufbau einer Mehrmodul-Installation verwendet. Trennen Sie andere Module während dieses Vorgangs, um Buskollisionen zu vermeiden.
Bei aktueller Firmware (v1.3+) ist für die Änderung der I²C-Adresse eines Moduls kein Sondermodus, keine Brücke und kein Werkzeug nötig — Sie legen die neue Adresse vor, scharf schalten die Änderung und committen sie (eine zweiphasige, magisch scharf geschaltete Abfolge, damit sich eine Adresse nicht versehentlich ändert), und das Modul startet unter seiner neuen Adresse neu. Die Bibliothek erzwingt ein Zweischrittprotokoll — prepareAddressChange() schaltet scharf, commitAddressChange() schreibt innerhalb eines 5-Sekunden-Fensters.
#include
#include
static const uint8_t CURRENT_ADDR = 0x50;
static const uint8_t NEW_ADDR = 0x51;
static RbAmp dev(Wire, CURRENT_ADDR);
void setup() {
Serial.begin(115200);
Wire.begin();
dev.setLogStream(&Serial);
if (!dev.begin()) {
Serial.println(F("device not found")); return;
}
Serial.print(F("fw=0x")); Serial.println(dev.firmwareVersion(), HEX);
// Step 1: arm the change (no special mode needed on firmware v1.3+).
if (!dev.prepareAddressChange(NEW_ADDR)) {
Serial.print(F("prepare: ")); Serial.println(RbAmp::errorString(dev.lastError()));
if (dev.lastError() == rbamp::RB_ERR_MODE) {
Serial.println(F("Module firmware is older than v1.3 - update to v1.3+ for the no-mode two-phase path."));
}
return;
}
delay(1000);
// Step 2: commit — writes 0x30, CMD_SAVE_GAINS (700 ms), CMD_RESET (100 ms).
if (!dev.commitAddressChange()) {
Serial.print(F("commit: ")); Serial.println(RbAmp::errorString(dev.lastError()));
return;
}
Serial.print(F("device now at 0x")); Serial.println(dev.address(), HEX);
if (dev.probe()) Serial.println(F("verified"));
}
void loop() { delay(60000); }
Vollständiger Sketch in 05_AddressChange.ino. Läuft das 5-Sekunden-Scharfzeitfenster vor dem Commit ab, gibt die Bibliothek false mit lastError() == RB_ERR_TIMEOUT zurück und setzt das Scharf-Flag zurück — Sie müssen prepareAddressChange() erneut aufrufen. So wird verhindert, dass ein einziger fehlerhafter Aufruf das Gerät unbrauchbar macht.
Szenario 11 — Ein Sketch, beide Modullinien
Das Beispiel 11_StdLine zeigt, dass ein einziger Sketch BASIC- und STANDARD-(STD)-Module bedient. begin() erkennt die Linie; die gängigen Lesezugriffe (readVoltage(), readCurrent(), readPower(), readPowerFactor(), readFrequency()) funktionieren bei beiden, und die nur für STD vorhandenen Zusatzfunktionen — Blind- und Scheinleistung, Blocklesezugriffe je Kanal (stdReadChannel()), Gesundheitszähler (stdReadHealth()) und die Momentaufnahmebänke der Periode — stehen hinter einer Prüfung mit line():
if (dev.line() == RbAmpLine::Std) {
RbAmpStdChannel c;
if (dev.stdReadChannel(0, c)) {
Serial.print(F("Q0=")); Serial.print(c.q, 1);
Serial.print(F(" var S0=")); Serial.println(c.s, 1);
}
} else {
// BASIC: reactive power is not exposed by this library
}
Auf einem BASIC-Modul liefern die Aufrufe std* RB_ERR_NOT_IMPLEMENTED. Die Beschreibung jedes Aufrufs finden Sie unter 09 · API-Referenz § STD-Linien-API.
Vergleichstabelle
| # | LOC | I2C-Bus | Periode? | DRDY? | MQTT? | Persistenz |
|---|---|---|---|---|---|---|
| 1 | ~30 | gemeinsam | nein | nein | nein | keine |
| 2 | ~50 | mit dem OLED geteilt | ja | nein | nein | RAM |
| 3 | ~50 | gemeinsam 3 Module | ja | nein | nein | RAM |
| 4 | ~80 | dediziert | ja | nein | ja | retained MQTT |
| 5 | ~50 | dediziert | nein (RT) | nein | nein | RAM (vom Master verwaltet) |
| 6 | ~70 | gemeinsam 3 Module | ja | nein | ja | retained MQTT |
| 7 | ~40 | dediziert | nein (RT) | nein | nein | RAM |
| 8 | ~250 | dediziert | ja | nein | nein | keine (CSV-Stream) |
| 9 | ~150 | dediziert | ja | nein | ja | RTC-Speicher + MQTT |
| 10 | ~50 | dediziert | n/a | nein | nein | Flash (slave-seitig) |
| 11 | ~130 | dediziert | ja | nein | nein | keine |
Wie geht es weiter
- DIY-Integrationen — diese Szenarien in Home Assistant / Node-RED / OpenHAB einbinden
- Cloud-Integrationen — AWS IoT / Azure / GCP / InfluxDB-Pipelines
- API-Referenz — jede öffentliche Methode dokumentiert
- Fehlersuche — wenn Szenarien auf Ihrem Prüfstand nicht wie erwartet laufen
Verwandt — Hauptdokumentation von rbAmp
- API-Referenz — formale I²C-Register-/Befehls-/Fehlerspezifikation, die die Bibliothek kapselt
- Arduino-Beispiele (rohes I²C) — dieselben Szenarien ohne Bibliothek, nützlich zum Portieren
- Periodenmessung — Konzept des atomaren Periodensnapshots und die Energieformel auf der Masterseite
- Hardwareanschluss — Pinbelegung, Verdrahtung, Montage des Stromwandlers
- Fehlersuche — modulseitige Probleme (NACK, Kalibrierdrift, Busrauschen)
Quelle und Probleme: rb-amp/rbamp-arduino · diese Seite im Repository: docs/06_examples.md
Quelle und Probleme: rb-amp/rbamp-arduino · diese Seite im Repository: docs/06_examples.md (v1.6.2)