rbAmp
FR
Boutique

Projet · · lecture de 12 min

Enregistreur d'énergie Arduino sur carte SD : CSV horodaté, sans cloud

Un module rbAmp et un Arduino en enregistreur autonome : volts, ampères, watts et kWh horodatés sur une carte microSD au format CSV, plus le flux série vers votre PC.

Ce que vous allez construire

  • Une ligne CSV par intervalle — timestamp, voltage, current, power, energy — ajoutée à un fichier sur une carte microSD.
  • Les mêmes lignes envoyées en série, pour enregistrer directement sur un PC (ou un traceur série) sans la carte.
  • Horodatages réels depuis un RTC DS3231 optionnel sur le bus I²C — ou le temps de fonctionnement millis() si vous omettez le RTC.
  • Robuste face à une carte absente ou à une mauvaise lecture — il continue et signale le problème plutôt que de se bloquer.

Nomenclature

Élément Qté Remarques
rbAmp BASIC SCT-UI1 1 tension + courant + puissance réelle sur puce · produit
TC SCT-013 1 calibre adapté à votre circuit · produit
Carte de développement ESP32 (framework Arduino) 1 la cible vérifiée à la compilation (portable sur d'autres cartes Arduino)
Module carte microSD 1 SPI ; carte formatée en FAT
RTC DS3231 (facultatif) 1 horodatages réels ; partage le bus I²C (adresse 0x68). Nécessite la bibliothèque RTClib (Adafruit). Sans elle, les lignes sont horodatées par le temps de fonctionnement.

Câblage

Deux bus, sans conflit :

  • I²C transporte le module rbAmp (0x50) — et le RTC (0x68) si vous en installez un — sur SDA/SCL. Alimentez le module en 5 V, masse commune ; le bus est en logique 3.3 V (pourquoi ?).

  • SPI transporte le module carte microSD sur les broches VSPI matérielles de l'ESP32 : SCK → GPIO18, MISO → GPIO19, MOSI → GPIO23, CS → GPIO5. Gardez les deux bus sur leurs propres broches — aucun conflit avec l'I²C.

Les pinces SCT-013 se placent autour du conducteur du circuit — non invasives côté courant.

Le CSV

À chaque intervalle, l'enregistreur ajoute une ligne ; l'en-tête est écrit à la création du fichier :

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

(Avec le RTC installé, vous obtenez de vraies dates ; sans lui, la colonne d'horodatage affiche le temps de fonctionnement up+.)

Ouvrez-le dans n'importe quel tableur ou outil de tracé — c'est simplement du texte.

Le croquis

Réglez MY_CT, insérez une carte microSD et flashez. ESP32 (framework Arduino) à 50 kHz ; SD sur les broches VSPI, RTC DS3231 sur le bus I²C partagé :

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

(Compilation vérifiée sur ESP32 avec Arduino-CLI — RbAmp + RTClib + les SD/SPI/Wire fournis. Chaque ligne est ouverte, écrite, vidée et fermée immédiatement, de sorte qu'une ligne n'est jamais perdue à cause d'un tampon non vidé lors d'une coupure. Le RTC DS3231 et rbAmp partagent le bus I²C ; la carte SD est sur des broches SPI séparées.)

Ce que fait le croquis

Trois petites fonctions auxiliaires assurent l'enregistrement — makeTimestamp(), ensureHeader() et logRow() — et loop() les relie aux lectures du compteur.

makeTimestamp() — heure réelle, ou temps de fonctionnement

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

Si un DS3231 est détecté au démarrage (rtc.begin()), les lignes reçoivent un horodatage horloge réelle ; sinon, elles reviennent à up+ (temps de fonctionnement) et le croquis l'indique sur Serial. Dans les deux cas le CSV est valide — vous perdez simplement les dates absolues sans RTC.

ensureHeader() et logRow() — le chemin d'écriture 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() écrit l'en-tête de colonnes une seule fois, uniquement à la création du fichier. logRow() formate une ligne et fait l'essentiel : ouvre le fichier en mode ajout, écrit la ligne, puis vide et ferme immédiatement. Cette ouverture/vidage/fermeture par ligne est délibérée — la ligne est sur la carte dès son écriture, donc couper l'alimentation (ou retirer la carte) ne perd jamais de données en tampon. La même ligne part d'abord vers Serial.println(), de sorte que le flux série est un CSV autodescriptif que vous pouvez rediriger directement vers un fichier sur un PC.

loop() — lire, garder, journaliser

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

Toutes les LOG_MS (30 s), il verrouille une période de mesure pour faire avancer le total en wattheures, lit le V/I/P en direct et — si aucune valeur n'est revenue NaN — horodate et écrit la ligne. Une mauvaise lecture passagère est ignorée plutôt qu'écrite comme déchet ; une période périmée est signalée mais la ligne est tout de même écrite (avec le V/I/P en direct et les Wh courants), car abandonner un échantillon entier pour un seul pas d'énergie non avancé serait pire.

Exploiter les données

Insérez la carte dans un PC et ouvrez le CSV dans un tableur — tracez la puissance sur la journée, additionnez l'énergie par heure, repérez les cycles du réfrigérateur ou le cycle de service du chauffe-eau. Comme la colonne d'énergie correspond à des wattheures intégrés par l'hôte, les totaux concordent avec ce que vous attendez sur la facture. Vous voulez un graphique en direct plutôt qu'a posteriori ? Intégrez-le à Home Assistant — mais pour un enregistrement entièrement hors ligne, ce fichier vous appartient.

Adaptez-le à votre installation

  • Davantage de colonnes — le module fournit aussi le facteur de puissance et la fréquence ; ajoutez-les à CSV_HEADER et à la chaîne de format de logRow.

  • Fichiers journaliers — ouvrez un nouveau fichier chaque jour (/2026-07-30.csv) à partir de la date du RTC, pour qu'un journal ne grossisse pas sans limite.

  • Réglez l'horloge correctement — le RTC prend l'heure de compilation au premier démarrage ; ajoutez une ligne rtc.adjust() avec une heure connue, ou synchronisez via NTP si vous mettez l'ESP32 sur le Wi-Fi.

  • Plusieurs circuits — enregistrez une ligne par module et par intervalle en combinant avec le montage multimodule.

  • Envoyez-le ailleurs — sur un ESP32, vous pouvez aussi POSTer chaque ligne vers un serveur ou la publier via MQTT, en gardant la carte SD comme sauvegarde hors ligne.

Récapitulatif de la série Arduino

Vous disposez maintenant de la boîte à outils autonome complète — aucun réseau requis :

  • Lisez-le — un module sur un OLED.
  • Passez à l'échelle — plusieurs circuits sur un bus, de façon cohérente.
  • Agissez — déclenchez un relais sur surintensité.
  • Journalisez-le — ce montage, sur SD/CSV.

À lire ensuite