Was Sie bauen werden
- Live-Spannung, Strom, Wirkleistung und Leistungsfaktor auf einem 128×64-OLED, etwa einmal pro Sekunde aktualisiert.
- Angesammelte Energie (Wh) auf demselben Bildschirm — echte Wattstunden, auf dem Host über Wanduhrzeit integriert.
- Alles läuft über einen einzigen I²C-Bus, den sich das rbAmp-Modul und das Display teilen — insgesamt vier Signaldrähte.
- Kein WLAN, keine Cloud, kein HA. Serielle Spiegelung zum Debuggen; das OLED ist die gesamte Oberfläche.
Stückliste
| Position | Menge | Hinweise |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 1 | Spannung + Strom + Wirkleistung auf dem Chip · Produkt |
| SCT-013-Stromwandler | 1 | Nennwert passend zu Ihrem Stromkreis · Produkt |
| ESP32-Entwicklungsboard (Arduino-Framework) | 1 | das kompilierte Zielsystem — ein ESP32 liefert ehrliche Langzeit-Wh (echte 64-Bit-Doubles) und Speicerreserven für das Display |
| SSD1306 128×64 I²C-OLED | 1 | das Display (I²C-Adresse 0x3C, teilt sich den Bus) |
| Steckbrücken | — | der gemeinsame I²C-Bus (SDA / SCL / VCC / GND) |
Jedes Arduino-kompatible Board funktioniert. Der Sketch ist einfaches Arduino-C++ — er läuft auf einem Uno, einem Nano, einem STM32, einem RP2040 oder einem ESP32. Wir haben hier einen ESP32 verwendet, weil er günstig, überall verfügbar ist und genug Reserven für ehrliche Langzeit-Energiesummen hat. Das Einzige, was sich je nach Board ändert, ist die I²C-Busgeschwindigkeit: Ein ESP32 braucht Wire.setClock(50000) (50 kHz, die Einstellung seines Treibers), während die meisten Nicht-ESP32-Boards das Modul mit 100 kHz betreiben.
Verdrahten
Das rbAmp-Modul und das OLED liegen beide auf demselben zweidrahtigen I²C-Bus — sie haben nur unterschiedliche Adressen (0x50 für rbAmp, 0x3C für das OLED), sodass sie ohne Konflikt nebeneinander bestehen:
Arduino rbAmp (0x50) OLED (0x3C)
------- ------------ -----------
SDA ───────────────┬────── SDA ───────┬─────── SDA
SCL ───────────────┼────── SCL ───────┼─────── SCL
5V ───────────────┼────── VCC └─(3.3V) VCC *(check your OLED's voltage)*
GND ───────────────┴────── GND ──────────────── GND
│
└── SCT-013 clamped around ONE mains conductor (arrow → load)
-
Der Bus läuft mit 3.3-V-Logik (die I²C-Leitungen des Moduls vertragen 5 V, liegen aber auf dem 3.3-V-Pegel des Hosts). Das rbAmp-Modul trägt Pull-ups von 4.7 kΩ an Bord gegen 3.3 V, die diesen Bus aus einem einzelnen Modul plus OLED bedienen — Sie aktivieren die schwachen internen Pull-ups des ESP32 nicht. Beachten Sie die Pegel: rbAmp VCC = 5 V, OLED VCC = 3.3 V, gemeinsame Masse — der I²C-Bus selbst arbeitet mit 3.3-V-Logik. (Warum wird rbAmp mit 5 V versorgt, der Bus aber mit 3.3 V?)
-
Die SCT-013-Zangen legen sich um einen isolierten Leiter — Sie schneiden oder abisolieren auf der Stromseite nie einen stromführenden Draht. Die Wechselspannungsseite des Moduls wird am Netz angeschlossen. Für Arbeiten im Inneren eines Elektroverteilers sollten Sie eine qualifizierte Elektrofachkraft hinzuziehen.
Die Bibliothek installieren
Arduino IDE: Sketch → Bibliothek einbinden → Bibliotheken verwalten…, nach RbAmp suchen, installieren. Oder mit arduino-cli:
arduino-cli lib install RbAmp
Sie benötigen außerdem den OLED-Treiber — installieren Sie Adafruit SSD1306 (v2.5.14) über den Bibliotheksmanager; er zieht Adafruit GFX und Adafruit BusIO automatisch nach.
Der Sketch
Fügen Sie dies ein, setzen Sie MY_CT passend zu Ihrer Zange und flashen Sie. Es ist für einen ESP32 (Arduino-Framework) mit 50 kHz gebaut (die Einstellung des ESP-IDF-I²C-Treibers — ein Nicht-ESP32-Host wie ein Uno/Nano würde 100 kHz verwenden) und mit einem Adafruit-SSD1306-OLED:
/**
* StandaloneMonitor.ino — a standalone Arduino energy monitor (no network, no HA).
*
* One rbAmp UI1 module + an ESP32 + a 128x64 SSD1306 I2C OLED on the same two-wire
* bus. Shows Voltage / Current / Power / Power Factor live (~1 s) and a
* host-integrated Energy (Wh) total. Wh is integrated on the master from avg power
* x wall-clock dt — that's what makes the total honest.
*
* Board: ESP32 (Arduino framework) -- esp32:esp32:esp32
* Bus: I2C @ 50 kHz (Wire.setClock(50000)) -- required on ESP32-Arduino (its
* Wire wraps the ESP-IDF i2c driver). On a non-ESP32 host use 100 kHz.
* OLED: Adafruit_SSD1306 + Adafruit_GFX (addr 0x3C, shares SDA/SCL with rbAmp).
*
* Wiring:
* SDA -> GPIO21 (both devices)
* SCL -> GPIO22 (both devices)
* rbAmp VCC -> 5 V (4.5-5.5 V; below 4.5 V the ADC loses accuracy)
* OLED VCC -> 3.3 V
* GND -> GND (common ground, both devices)
* ~4.7 kOhm pull-ups on SDA and SCL to 3.3 V (host logic level)
* OLED 0x3C, rbAmp 0x50
*
* Accuracy: per clamp rating — the class and the sensor's own tolerance are both in the accuracy table on the BASIC page.
*/
#include
#include
#include
#include
/* ---- configuration -------------------------------------------------------- */
static const uint8_t RBAMP_ADDR = 0x50;
static const uint8_t OLED_ADDR = 0x3C;
static const uint16_t OLED_W = 128;
static const uint16_t OLED_H = 64;
static const uint32_t I2C_HZ = 50000; /* ESP32-Arduino: 50 kHz */
/* Match this to your clamp: Sct013_005 / _010 / _030 / _050 / _020. */
static const RbAmpCTModel MY_CT = RbAmpCTModel::Sct013_030;
static const uint32_t LIVE_MS = 1000; /* refresh V/I/P/PF each second */
static const uint32_t ENERGY_MS = 30000; /* latch a period + roll Wh every 30 s */
/* ---- objects -------------------------------------------------------------- */
static Adafruit_SSD1306 oled(OLED_W, OLED_H, &Wire, -1);
static RbAmp dev(Wire, RBAMP_ADDR, RbAmpTopology::Single);
static bool oled_ok = false;
static uint32_t next_live_ms = 0;
static uint32_t next_energy_ms = 0;
/* Last-good live values: a single transient read hiccup should not blank the
* display, so we hold the previous plausible reading. */
static float lastV = NAN, lastI = NAN, lastP = NAN, lastPF = NAN;
static uint32_t reads_ok = 0, reads_bad = 0;
/* ---- helpers -------------------------------------------------------------- */
static void banner(const __FlashStringHelper* l1, const char* l2) {
if (!oled_ok) return;
oled.clearDisplay();
oled.setTextSize(1);
oled.setTextColor(SSD1306_WHITE);
oled.setCursor(0, 0);
oled.println(l1);
oled.println(l2);
oled.display();
}
/* Apply the CT model only if the module isn't already on it (setCTModel()
* persists to flash, so we avoid rewriting the same value every boot). */
static void ensureCtModel() {
uint8_t applied = 0;
if (dev.readCTModelCh(0, applied) && applied == static_cast(MY_CT)) {
Serial.println(F("CT model already set; skipping flash write"));
return;
}
Serial.println(F("configuring CT model (persists to flash)..."));
if (!dev.setSensorClass(RbAmpSensorClass::Sct013) || !dev.setCTModel(MY_CT)) {
Serial.print(F("CT config failed: "));
Serial.println(RbAmp::errorString(dev.lastError()));
}
}
static void drawLive() {
if (!oled_ok) return;
oled.clearDisplay();
oled.setTextColor(SSD1306_WHITE);
/* Power headline, big. */
oled.setTextSize(2);
oled.setCursor(0, 0);
oled.print(isnan(lastP) ? 0.0f : lastP, 0);
oled.println(F(" W"));
/* V / I / PF row. */
oled.setTextSize(1);
oled.setCursor(0, 20);
oled.print(isnan(lastV) ? 0.0f : lastV, 1); oled.print(F("V "));
oled.print(isnan(lastI) ? 0.0f : lastI, 3); oled.print(F("A PF"));
oled.println(isnan(lastPF) ? 0.0f : lastPF, 2);
/* Energy total. */
oled.setCursor(0, 36);
oled.print(F("Energy: "));
oled.print(dev.energy().wh(0), 3);
oled.println(F(" Wh"));
/* Health line. */
oled.setCursor(0, 52);
oled.print(F("ok=")); oled.print(reads_ok);
oled.print(F(" bad=")); oled.print(reads_bad);
oled.display();
}
static void readLive() {
float v = dev.readVoltage();
float i = dev.readCurrent(0);
float p = dev.readPower(0);
float pf = dev.readPowerFactor(0);
if (!isnan(v)) lastV = v;
if (!isnan(i)) lastI = i;
if (!isnan(p)) lastP = p;
if (!isnan(pf)) lastPF = pf;
if (isnan(v) && isnan(i) && isnan(p)) reads_bad++; else reads_ok++;
Serial.print(F("V=")); Serial.print(lastV, 1);
Serial.print(F(" I=")); Serial.print(lastI, 3);
Serial.print(F(" P=")); Serial.print(lastP, 1);
Serial.print(F(" PF=")); Serial.print(lastPF, 2);
Serial.print(F(" Wh=")); Serial.println(dev.energy().wh(0), 3);
drawLive();
}
/* Latch a metering period; the library rolls Wh from avg power x master dt on a
* successful, valid snapshot. A stale/not-ready period is reported and skipped
* so the display keeps running on the last live values. */
static void rollEnergy() {
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) {
Serial.print(F("period skipped: "));
Serial.println(RbAmp::errorString(dev.lastError()));
return;
}
Serial.print(F("period ok: avg_P0="));
Serial.print(snap.avg_p[0], 2);
Serial.print(F("W dt="));
Serial.print(snap.master_dt_ms);
Serial.print(F("ms -> Wh="));
Serial.println(dev.energy().wh(0), 4);
}
/* ---- lifecycle ------------------------------------------------------------ */
void setup() {
Serial.begin(115200);
while (!Serial && millis() < 2000) {}
Wire.begin();
Wire.setClock(I2C_HZ);
oled_ok = oled.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
if (oled_ok) {
banner(F("rbAmp monitor"), "booting...");
} else {
Serial.println(F("OLED init failed - running headless on Serial"));
}
dev.setLogStream(&Serial);
uint8_t tries = 0;
while (!dev.begin()) {
const char* why = RbAmp::errorString(dev.lastError());
Serial.print(F("rbAmp begin failed: "));
Serial.println(why);
banner(F("no rbAmp - retry"), why);
if (++tries % 5 == 0)
Serial.println(F("check wiring: SDA/SCL/power/GND + pull-ups"));
delay(1000);
}
Serial.println(F("rbAmp online"));
ensureCtModel();
uint32_t now = millis();
next_live_ms = now;
next_energy_ms = now + ENERGY_MS;
}
void loop() {
uint32_t now = millis();
if (static_cast(now - next_live_ms) >= 0) {
next_live_ms = now + LIVE_MS;
readLive();
}
if (static_cast(now - next_energy_ms) >= 0) {
next_energy_ms = now + ENERGY_MS;
rollEnergy();
}
delay(5);
}
(Auf ESP32 mit Arduino-CLI kompiliert geprüft — Adafruit SSD1306 v2.5.14 + Adafruit GFX. setCTModel() schreibt in den Flash, daher schreibt der Sketch die CT-Voreinstellung nur dann neu, wenn sie sich tatsächlich ändert — kein Flash-Verschleiß bei jedem Start.)
Was der Sketch macht
Die gesamte rbAmp-Arduino-Bibliothek zeigt sich in einer Handvoll Aufrufen. Zwei Funktionen erledigen die eigentliche Arbeit — readLive() jede Sekunde und rollEnergy() alle 30 Sekunden — angetrieben von einer loop() mit zwei Takten. Hier ist jedes Teil.
Einrichtung — binden, prüfen, konfigurieren
RbAmp dev(Wire, 0x50, RbAmpTopology::Single); // bus, address, topology
...
while (!dev.begin()) { /* print errorString(), retry */ }
ensureCtModel();
RbAmp dev(Wire, 0x50, RbAmpTopology::Single) bindet die Bibliothek an den I²C-Bus und das Modul bei 0x50; Single sagt, dass es ein Einkanal-UI1 ist (ein UI2/UI3 würde SplitPhase / ThreePhase übergeben). begin() prüft das Modul und liest seine Fähigkeiten — in einer Schleife aufrufen, bis es true zurückgibt, und dabei RbAmp::errorString(dev.lastError()) ausgeben, damit ein Verdrahtungsfehler offensichtlich wird. ensureCtModel() liest die gespeicherte CT-Voreinstellung des Moduls und schreibt sie nur, wenn sie abweicht (setCTModel() speichert im Flash) — das verhindert Flash-Verschleiß bei jedem Start.
readLive() — die Einmal-pro-Sekunde-Messung
float v = dev.readVoltage();
float i = dev.readCurrent(0);
float p = dev.readPower(0);
float pf = dev.readPowerFactor(0);
if (!isnan(v)) lastV = v; // hold last-good on a transient miss
Diese vier Lesevorgänge holen die echten Messwerte des Moduls: readPower(0) ist echte Wirkleistung in Watt — der Mittelwert aus momentaner Spannung × Strom, nicht Strom × eine angenommene Spannung. Jeder Lesevorgang kann gelegentlich NaN liefern (ein vorübergehender Bus-Aussetzer); der Sketch behält den letzten guten Wert (lastV, lastI, …), damit die Anzeige nie auf null flackert, und erhöht einen Zähler ok=/bad=, den Sie auf dem Bildschirm verfolgen können. Dann ruft er drawLive() auf, um das OLED zu zeichnen.
rollEnergy() — die ehrliche Energiesumme
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) { /* stale/not-ready: report + skip */ return; }
// dev.energy().wh(0) has now advanced for this window
Energie funktioniert anders als die Live-Messungen. readPeriodSnapshot() sendet dem Modul einen atomaren LATCH — „das aktuelle Messfenster jetzt schließen“ — wartet die Einschwingzeit ab und liest den Durchschnittswert der Leistung dieses Fensters zurück. Die Bibliothek rollt dann die Wattstunden-Summe auf dem Host fort: energy = average_power × elapsed_wall-clock_time. Da der Host das Integrationsintervall besitzt, gibt es keinen Gerätezähler, der quantisiert oder driften könnte — dev.energy().wh(0) ist eine ehrliche laufende Summe. Meldet eine Periode veraltet oder nicht bereit, meldet die Funktion dies und kehrt zurück; die Anzeige läuft mit den letzten Live-Werten weiter.
Die loop() mit zwei Takten
if (now - next_live_ms >= 0) { next_live_ms += LIVE_MS; readLive(); } // 1 s
if (now - next_energy_ms >= 0) { next_energy_ms += ENERGY_MS; rollEnergy(); } // 30 s
Zwei unabhängige Timer: Die Live-Anzeige aktualisiert sich alle LIVE_MS (1 s) für eine reaktionsschnelle Anzeige, während der schwerere Energie-Latch nur alle ENERGY_MS (30 s) läuft. Durch die Entkopplung bleibt der Bildschirm flott, ohne das Modul 60-mal pro Minute zu latchen. Ändern Sie eine der Konstanten nach Belieben.
Was Sie sehen werden
Auf dem OLED eine Live-Anzeige, die der Last folgt — schalten Sie eine Lampe oder einen Wasserkocher ein und sehen Sie zu, wie die Watt springen. Auf dem seriellen Monitor (115200 Baud) laufen dieselben Werte zum Debuggen durch:
V=230.4 I=0.211 P=48.2 PF=0.97 Wh=12.345
[Screenshot / Foto — Medienplatz: das OLED mit einer Live-Messung auf dem Prüfstand]
Wie genau ist es?
Bei einer SCT-013-Zange werden Klasse und eigene Toleranz der Zange pro Nennwert in der SCT-013-Genauigkeitstabelle veröffentlicht. Die Genauigkeit wird am sehr unteren Ende des Nennbereichs breiter. Das Modul misst echte Wirkleistung mit kanalweiser Phasenkompensation — daher werden blindleistungsbehaftete und Lasten mit niedrigem Leistungsfaktor ehrlich angezeigt, nicht als aufgeblähte Scheinleistung. Die Hintergründe zu den Zahlen finden Sie unter wie die CT-Energiemessung tatsächlich funktioniert.
Passen Sie es an Ihre Bedürfnisse an
Ein paar kleine Ergänzungen, sobald es läuft:
-
Ein rücksetzbarer Auslösezähler — führen Sie Ihren eigenen
double kwh_sessionneben der Gesamtsumme und setzen Sie ihn über einen Taster an einem freien GPIO auf null für eine Anzeige „seit ich gedrückt habe“. -
Mehr anzeigen — das Modul meldet auch die Frequenz; ergänzen Sie einen Min-/Max-Leistungsverfolger oder eine kWh-Zeile (
wh / 1000.0). -
Ein weicher Alarm — das OLED blinken lassen oder eine LED blinken lassen, sobald die Leistung eine Schwelle überschreitet (kein Relais nötig für eine reine Anzeigewarnung).
-
Nach außen senden — Sie sind auf einem ESP32, also haben Sie WLAN: Veröffentlichen Sie die Messwerte über MQTT an Ihren eigenen Broker oder stellen Sie eine kleine Webseite bereit — ohne das lokale OLED aufzugeben.
-
Langsamer oder schneller — senken Sie
LIVE_MSfür eine lebhaftere Grafik, oder erhöhen SieENERGY_MS, wenn ein 30-s-Energieschritt in Ordnung ist.
Nichts davon berührt die Messung — es ist alles, was Sie mit den Zahlen tun, die readLive() und rollEnergy() Ihnen bereits liefern.
Wie es weitergeht
Dieses eine Modul auf einem Bildschirm ist das Fundament. Von hier aus baut die Arduino-Reihe auf:
- Mehrere Stromkreise gleichzeitig messen — mehrere rbAmp-Module auf demselben Bus, gelesen und summiert von einem Arduino.
-
Auf die Messung reagieren — ein Relais auslösen oder einen Summer ertönen lassen, sobald ein Stromkreis einen Stromgrenzwert überschreitet, alles lokal, ohne Netzwerk.
-
Protokollieren — periodische Energie auf eine SD-Karte schreiben oder CSV an einen PC streamen.
(Lieber in Home Assistant? Dasselbe Modul passt in ESPHome.)