Was Sie bauen werden
- Eine CSV-Zeile pro Intervall —
timestamp, voltage, current, power, energy— auf eine Datei auf einer microSD-Karte angehängt. - Die gleichen Zeilen laufen seriell aus, sodass Sie direkt auf einen PC (oder einen seriellen Plotter) protokollieren können, ohne die Karte.
- Echte Zeitstempel von einer optionalen DS3231-RTC am I²C-Bus — oder der
millis()-Uptime, falls Sie die RTC weglassen. - Robust gegenüber einer fehlenden Karte oder einer fehlerhaften Messung — es läuft weiter und meldet das Problem, statt zu hängen.
Stückliste
| Position | Menge | Hinweise |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 1 | Spannung + Strom + Wirkleistung auf dem Chip · Produkt |
| SCT-013-CT | 1 | Nennwert passend zu Ihrem Stromkreis · Produkt |
| ESP32-Entwicklungsboard (Arduino-Framework) | 1 | das kompilierte Zielsystem (übertragbar auf andere Arduino-Boards) |
| microSD-Kartenmodul | 1 | SPI; eine FAT-formatierte Karte |
| DS3231-RTC (optional) | 1 | echte Zeitstempel in Wanduhrzeit; teilt sich den I²C-Bus (Adresse 0x68). Benötigt die Bibliothek RTClib (Adafruit). Lassen Sie sie weg, und die Zeilen erhalten stattdessen einen Uptime-Zeitstempel. |
Verdrahten
Zwei Busse, kein Konflikt:
-
I²C führt das rbAmp-Modul (
0x50) — und die RTC (0x68), falls Sie eine einbauen — auf SDA/SCL. Versorgen Sie das Modul mit 5 V, gemeinsame Masse; der Bus arbeitet mit 3.3-V-Logik (warum?). -
SPI führt die microSD-Karte über die Hardware-VSPI-Pins des ESP32: SCK → GPIO18, MISO → GPIO19, MOSI → GPIO23, CS → GPIO5. Halten Sie die beiden Busse auf eigenen Pins — kein Konflikt mit I²C.
Die SCT-013-Zangen legen sich um den Stromkreisleiter — berührungslos auf der Stromseite.
Die CSV
Bei jedem Intervall hängt der Logger eine Zeile an; die Kopfzeile wird beim ersten Erstellen der Datei geschrieben:
timestamp,voltage_V,current_A,power_W,energy_Wh
2026-07-30 14:05:00,230.4,0.211,48.2,12.345
2026-07-30 14:05:30,230.1,0.208,47.6,12.477
(Mit eingebauter RTC erhalten Sie echte Datumsangaben; ohne sie zeigt die Zeitstempelspalte die up+-Uptime.)
Öffnen Sie sie in einer beliebigen Tabellenkalkulation oder einem Plot-Werkzeug — es ist nur Text.
Der Sketch
Setzen Sie MY_CT, legen Sie eine microSD-Karte ein und flashen Sie. ESP32 (Arduino-Framework) mit 50 kHz; SD an den VSPI-Pins, DS3231-RTC am gemeinsamen I²C-Bus:
/**
* SdCsvLogger.ino — log energy to microSD as CSV (standalone, no network).
*
* One rbAmp module meters a circuit; every interval the Arduino writes a
* timestamped CSV row to a microSD card AND mirrors it over Serial (redirect to
* a file, or watch in a serial plotter). A data logger you own — no HA, no cloud.
*
* Columns: timestamp,voltage_V,current_A,power_W,energy_Wh
*
* Board: ESP32 (Arduino framework); I2C @ 50 kHz. Non-ESP32 host = 100 kHz.
* Timestamps: a DS3231 RTC on the SAME I2C bus (addr 0x68, coexists with rbAmp
* @0x50) gives real wall-clock time. No RTC -> millis() uptime.
* Wiring: I2C SDA->GPIO21 SCL->GPIO22; rbAmp VCC->5 V; DS3231 VCC->3.3 V; GND
* common; ~4.7 kOhm pull-ups to 3.3 V.
* SD (VSPI) SCK->GPIO18 MISO->GPIO19 MOSI->GPIO23 CS->GPIO5.
*
* 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
#include
/* ---- configuration — the reader edits these ------------------------------ */
static const uint8_t RBAMP_ADDR = 0x50;
static const uint8_t METER_CH = 0;
static const uint32_t I2C_HZ = 50000; /* ESP32-Arduino: 50 kHz */
static const uint8_t SD_CS = 5; /* microSD chip-select (VSPI default) */
static const char* CSV_PATH = "/energy.csv";
static const uint32_t LOG_MS = 30000; /* one CSV row every 30 s */
/* Match to your clamp: Sct013_005 / _010 / _030 / _050 / _020. */
static const RbAmpCTModel MY_CT = RbAmpCTModel::Sct013_030;
static const char CSV_HEADER[] = "timestamp,voltage_V,current_A,power_W,energy_Wh";
/* ---- state --------------------------------------------------------------- */
static RbAmp dev(Wire, RBAMP_ADDR, RbAmpTopology::Single);
static RTC_DS3231 rtc;
static bool rtc_ok = false;
static bool sd_ok = false;
static uint32_t next_log_ms = 0;
static uint32_t rows = 0, skipped = 0, sd_fail = 0;
/* Apply the CT model only if it differs (setCTModel() persists to flash). */
static void ensureCtModel() {
uint8_t applied = 0;
if (dev.readCTModelCh(METER_CH, applied) && applied == static_cast(MY_CT)) {
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()));
}
}
/* Wall-clock from the RTC, or uptime if no RTC. Primitive args only. */
static void makeTimestamp(char* buf, size_t n) {
if (rtc_ok) {
DateTime now = rtc.now();
snprintf(buf, n, "%04u-%02u-%02u %02u:%02u:%02u",
now.year(), now.month(), now.day(),
now.hour(), now.minute(), now.second());
} else {
snprintf(buf, n, "up+%lus", static_cast(millis() / 1000UL));
}
}
/* Create the file with a header row the first time it doesn't exist. */
static void ensureHeader() {
if (!sd_ok || SD.exists(CSV_PATH)) return;
File f = SD.open(CSV_PATH, FILE_WRITE);
if (f) {
f.println(CSV_HEADER);
f.close();
Serial.print(F("created "));
Serial.println(CSV_PATH);
} else {
Serial.println(F("could not create CSV header on SD"));
}
}
/* Append one row: persist to SD (open/append/flush/close so a row is never
* lost on power-off) and mirror to Serial. Primitive args only. */
static void logRow(const char* ts, float v, float a, float p, double wh) {
char line[96];
snprintf(line, sizeof(line), "%s,%.1f,%.3f,%.1f,%.3f",
ts, v, a, p, wh);
Serial.println(line);
if (!sd_ok) return;
File f = SD.open(CSV_PATH, FILE_APPEND);
if (!f) {
sd_fail++;
if (sd_fail % 10 == 1)
Serial.println(F("SD append failed - still logging to Serial"));
return;
}
f.println(line);
f.flush();
f.close();
rows++;
}
/* ---- lifecycle ----------------------------------------------------------- */
void setup() {
Serial.begin(115200);
while (!Serial && millis() < 2000) {}
Wire.begin();
Wire.setClock(I2C_HZ);
/* rbAmp */
dev.setLogStream(&Serial);
uint8_t tries = 0;
while (!dev.begin()) {
Serial.print(F("rbAmp begin failed: "));
Serial.println(RbAmp::errorString(dev.lastError()));
if (++tries % 5 == 0)
Serial.println(F("check wiring: SDA/SCL/5V/GND + external pull-ups"));
delay(1000);
}
Serial.println(F("rbAmp online"));
ensureCtModel();
/* RTC (optional) */
rtc_ok = rtc.begin();
if (rtc_ok) {
if (rtc.lostPower()) {
/* First power-up / dead backup cell: seed from build time. Replace
* with a known-good time or a set-clock sketch for real accuracy. */
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
Serial.println(F("RTC lost power - seeded from build time (set it properly)"));
}
Serial.println(F("timestamp source: DS3231 RTC"));
} else {
Serial.println(F("no DS3231 RTC - timestamps fall back to millis() uptime"));
}
/* SD (optional) */
sd_ok = SD.begin(SD_CS);
if (sd_ok) {
ensureHeader();
} else {
Serial.println(F("no SD card - logging to Serial only"));
}
Serial.println(CSV_HEADER); /* so the Serial stream is a self-describing CSV too */
next_log_ms = millis();
}
void loop() {
uint32_t now = millis();
if (static_cast(now - next_log_ms) < 0) {
delay(5);
return;
}
next_log_ms = now + LOG_MS;
/* Latch a period so energy().wh() advances for this row. A stale period is
* noted but not fatal — the row still carries the live V/I/P + the current
* Wh total (energy simply does not advance that interval). */
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) {
Serial.print(F("period stale/failed: "));
Serial.println(RbAmp::errorString(dev.lastError()));
}
float v = dev.readVoltage();
float a = dev.readCurrent(METER_CH);
float p = dev.readPower(METER_CH);
/* Skip the row on a transient bad read rather than write garbage. */
if (isnan(v) || isnan(a) || isnan(p)) {
skipped++;
Serial.println(F("skip row - transient bad read"));
return;
}
char ts[24];
makeTimestamp(ts, sizeof(ts));
logRow(ts, v, a, p, dev.energy().wh(METER_CH));
}
(Auf ESP32 mit Arduino-CLI kompiliert geprüft — RbAmp + RTClib + die mitgelieferten SD/SPI/Wire. Jede Zeile wird geöffnet, geschrieben, geleert und sofort geschlossen, daher geht eine Zeile bei Stromausfall nie durch einen ungeleerten Puffer verloren. Die DS3231-RTC und rbAmp teilen sich den I²C-Bus; die SD-Karte liegt auf eigenen SPI-Pins.)
Was der Sketch macht
Drei kleine Hilfsfunktionen übernehmen die Protokollierung — makeTimestamp(), ensureHeader() und logRow() — und loop() verknüpft sie mit den Zählerwerten.
makeTimestamp() — echte Zeit oder Uptime
if (rtc_ok) snprintf(buf, n, "%04u-%02u-%02u %02u:%02u:%02u", now.year(), ...);
else snprintf(buf, n, "up+%lus", millis()/1000UL);
Wenn beim Start eine DS3231 gefunden wurde (rtc.begin()), erhalten die Zeilen einen echten Wanduhr-Zeitstempel; wenn nicht, fallen sie auf up+ Uptime zurück, und der Sketch meldet dies auf Serial. In jedem Fall ist die CSV gültig — Sie verlieren nur ohne RTC die absoluten Datumsangaben.
ensureHeader() und logRow() — der CSV-Schreibpfad
File f = SD.open(CSV_PATH, FILE_APPEND);
f.println(line);
f.flush();
f.close(); // open -> append -> flush -> close, every single row
ensureHeader() schreibt die Spaltenkopfzeile einmal, nur wenn die Datei zum ersten Mal erstellt wird. logRow() formatiert eine Zeile und erledigt das Wichtige: Es öffnet die Datei im Anhängemodus, schreibt die Zeile und leert und schließt sie sofort. Dieses Öffnen/Leeren/Schließen pro Zeile ist bewusst gewählt — die Zeile liegt in dem Moment auf der Karte, in dem sie geschrieben wird, daher geht beim Ziehen des Stroms (oder der Karte) nie gepufferte Information verloren. Dieselbe Zeile geht zuerst an Serial.println(), sodass der serielle Strom eine selbstbeschreibende CSV ist, die Sie direkt auf einem PC in eine Datei umleiten können.
loop() — lesen, absichern, protokollieren
dev.readPeriodSnapshot(snap); // latch a window so energy().wh() advances
float v = dev.readVoltage(); float a = dev.readCurrent(0); float p = dev.readPower(0);
if (isnan(v) || isnan(a) || isnan(p)) { skipped++; return; } // skip a bad read, don't log garbage
makeTimestamp(ts, sizeof(ts));
logRow(ts, v, a, p, dev.energy().wh(0));
Alle LOG_MS (30 s) latcht es eine Messperiode, damit die Wattstunden-Summe fortschreitet, liest die Live-V/I/P-Werte und — wenn keiner NaN war — stempelt und schreibt die Zeile. Eine vorübergehend fehlerhafte Messung wird übersprungen, statt als Müll geschrieben zu werden; eine veraltete Periode wird vermerkt, die Zeile wird aber trotzdem geschrieben (mit Live-V/I/P und der aktuellen Wh), denn einen ganzen Messwert wegen eines nicht fortgeschrittenen Energieschritts zu verwerfen wäre schlimmer.
Die Daten verwenden
Stecken Sie die Karte in einen PC und öffnen Sie die CSV in einer Tabellenkalkulation — stellen Sie die Leistung über den Tag dar, summieren Sie die Energie pro Stunde, erkennen Sie das Takten des Kühlschranks oder den Einschaltzyklus des Warmwasserbereiters. Da die Energiespalte echte, vom Host integrierte Wattstunden sind, stimmen die Summen mit dem überein, was Sie auf der Rechnung erwarten. Möchten Sie das lieber live statt nachträglich grafisch sehen? Binden Sie es in Home Assistant ein — für eine vollständig offline geführte Aufzeichnung gehört diese Datei Ihnen.
Passen Sie es an Ihre Bedürfnisse an
-
Mehr Spalten — das Modul liefert außerdem den Leistungsfaktor und die Frequenz; ergänzen Sie sie in
CSV_HEADERund im Formatstring vonlogRow. -
Tagesdateien — pro Tag eine neue Datei anlegen (
/2026-07-30.csv) auf Basis des RTC-Datums, damit ein Protokoll nicht unbegrenzt wächst. -
Stellen Sie die Uhr richtig ein — die RTC übernimmt beim ersten Einschalten die Build-Zeit; ergänzen Sie einen einzeiligen
rtc.adjust()mit einer bekannten Zeit oder synchronisieren Sie per NTP, falls Sie den ESP32 ins WLAN bringen. -
Mehrere Stromkreise — eine Zeile pro Modul und Intervall protokollieren, indem Sie es mit dem Mehrmodul-Aufbau kombinieren.
-
Irgendwohin senden — auf einem ESP32 können Sie jede Zeile auch an einen Server POSTen oder über MQTT veröffentlichen und die SD-Karte als Offline-Sicherung behalten.
Die Arduino-Reihe, Zusammenfassung
Sie haben jetzt das vollständige eigenständige Werkzeugset — ganz ohne Netzwerk:
- Lesen Sie es — ein Modul auf einem OLED.
- Skalieren Sie es — mehrere Stromkreise an einem Bus, kohärent.
- Handeln — ein Relais bei Überstrom auslösen.
- Protokollieren — dieser Aufbau, auf SD/CSV.