rbAmp
RU
Магазин

Проект · · 12 мин чтения

Журнал энергии на Arduino на SD-карту: CSV с временными метками, без облака

Модуль rbAmp и Arduino как автономный регистратор: метки времени, вольты, амперы, ватты и кВт·ч на microSD-карту в CSV, плюс последовательный вывод на ПК.

Что вы соберёте

  • Строка CSV на интервал — timestamp, voltage, current, power, energy — дописывается в файл на microSD-карте.
  • Те же строки передаются по последовательному порту, так что можно писать журнал прямо на ПК (или на последовательный плоттер) без карты.
  • Реальные метки времени от необязательных часов реального времени DS3231 на шине I²C — либо uptime millis(), если вы обходитесь без RTC.
  • Устойчив к отсутствующей карте или плохому чтению — продолжает работу и помечает проблему, а не зависает.

Спецификация

Позиция Кол-во Примечания
rbAmp BASIC SCT-UI1 1 напряжение + ток + активная мощность на чипе · продукт
Клещи SCT-013 CT 1 номинал под вашу цепь · продукт
Отладочная плата ESP32 (фреймворк Arduino) 1 проверенная компиляцией цель (переносится на другие платы Arduino)
Модуль microSD-карты 1 SPI; карта, отформатированная в FAT
RTC DS3231 (необязательно) 1 реальные метки времени по настенным часам; использует шину I²C (адрес 0x68). Нужна библиотека RTClib (Adafruit). Без неё строки помечаются временем работы.

Подключение

Две шины, без конфликта:

  • I²C несёт модуль rbAmp (0x50) — и RTC (0x68), если вы его ставите — по SDA/SCL. Питайте модуль от 5 В, общая земля; шина — логика 3.3 В (почему?).

  • SPI несёт модуль microSD на аппаратных выводах VSPI ESP32: SCK → GPIO18, MISO → GPIO19, MOSI → GPIO23, CS → GPIO5. Держите обе шины на своих выводах — конфликта с I²C нет.

Клещи SCT-013 охватывают проводник цепи снаружи — со стороны тока установка бесконтактная.

CSV

На каждом интервале логгер добавляет одну строку; заголовок записывается при первом создании файла:

Text
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

(С установленным RTC вы получаете реальные даты; без него столбец времени показывает up+ (время работы).)

Откройте в любой таблице или инструменте построения графиков — это просто текст.

Скетч

Задайте MY_CT, вставьте microSD-карту и прошейте. ESP32 (фреймворк Arduino) на 50 кГц; SD — на выводах VSPI, RTC DS3231 — на общей шине I²C:

C++
/**
 * 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));
}

(Проверено компиляцией на ESP32 через Arduino-CLI — RbAmp + RTClib + встроенные SD/SPI/Wire. Каждая строка открывается, записывается, сбрасывается и закрывается сразу, так что строка никогда не теряется из-за несброшенного буфера при выключении питания. RTC DS3231 и rbAmp используют общую шину I²C; SD-карта — на отдельных выводах SPI.)

Что делает скетч

Три небольшие вспомогательные функции ведут журнал — makeTimestamp(), ensureHeader() и logRow() — а loop() связывает их с чтением счётчика.

makeTimestamp() — реальное время или время работы (uptime)

C++
if (rtc_ok) snprintf(buf, n, "%04u-%02u-%02u %02u:%02u:%02u", now.year(), ...);
else        snprintf(buf, n, "up+%lus", millis()/1000UL);

Если DS3231 найден при загрузке (rtc.begin()), строки получают реальную метку времени по настенным часам; если нет — используется up+ (время работы) и скетч сообщает об этом в Serial. В любом случае CSV корректен — вы просто потеряете абсолютные даты без RTC.

ensureHeader() и logRow() — путь записи CSV

C++
File f = SD.open(CSV_PATH, FILE_APPEND);
f.println(line);
f.flush();
f.close();          // open -> append -> flush -> close, every single row

ensureHeader() записывает заголовок столбцов один раз, только при первом создании файла. logRow() форматирует одну строку и делает главное: открывает файл в режиме добавления, пишет строку, затем сбрасывает и сразу закрывает. Такое открытие/сброс/закрытие на каждой строке намеренное — строка оказывается на карте в тот же миг, как записана, так что отключение питания (или карты) никогда не теряет буферизованные данные. Та же строка сначала уходит в Serial.println(), так что последовательный поток — это самоописываемый CSV, который можно перенаправить прямо в файл на ПК.

loop() — чтение, защита, журнал

C++
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));

Каждый LOG_MS (30 с) он защёлкивает период учёта, чтобы итог в Вт·ч продвинулся, читает живые V/I/P и — если ни одно не вернуло NaN — ставит метку и записывает строку. Кратковременно плохое чтение пропускается, а не записывается как мусор; устаревший период отмечается, но строка всё равно записывается (с живыми V/I/P и текущими Вт·ч), потому что пропуск целого отсчёта из-за одного не продвинувшегося шага энергии был бы хуже.

Использование данных

Перенесите карту в ПК и откройте CSV в таблице — постройте мощность за день, просуммируйте энергию по часам, найдите цикл холодильника или скважность водонагревателя. Поскольку столбец энергии — это реальные ватт-часы, интегрированные на хосте, итоги сходятся с тем, что вы ожидаете увидеть в счёте. Хотите график в реальном времени вместо постфактум? Подключите к Home Assistant — а для полностью автономной записи этот файл остаётся за вами.

Адаптируйте под себя

  • Больше столбцов — модуль также выдаёт коэффициент мощности и частоту; добавьте их в CSV_HEADER и в строку формата logRow.

  • Ежедневные файлы — начинайте новый файл каждый день (/2026-07-30.csv) по дате RTC, чтобы журнал не рос бесконечно.

  • Правильно установите часы — RTC берёт время сборки при первом включении; добавьте однострочный rtc.adjust() с известным временем или синхронизируйте по NTP, если подключите ESP32 к WiFi.

  • Несколько цепей — записывайте одну строку на модуль за интервал, объединив со сборкой с несколькими модулями.

  • Отправляйте данные наружу — на ESP32 можно также POST-ом передавать каждую строку на сервер или публиковать по MQTT, оставляя SD-карту как офлайн-резерв.

Итоги серии по Arduino

Теперь у вас есть полный автономный набор инструментов — сеть не нужна:


Читать дальше