O que vai construir
- Uma linha CSV por intervalo —
timestamp, voltage, current, power, energy— acrescentada a um ficheiro num cartão microSD. - As mesmas linhas transmitidas pela série, para poder registar diretamente num PC (ou num plotter série) sem o cartão.
- Carimbos temporais reais de um RTC DS3231 opcional no barramento I²C — ou tempo de funcionamento
millis()se dispensar o RTC. - Robusto a um cartão em falta ou a uma leitura má — continua a funcionar e assinala o problema em vez de bloquear.
Lista de materiais
| Item | Qtd. | Notas |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 1 | tensão + corrente + potência ativa calculada no módulo · produto |
| TC SCT-013 | 1 | classificação adequada ao seu circuito · produto |
| Placa de desenvolvimento ESP32 (framework Arduino) | 1 | o alvo verificado por compilação (portável para outras placas Arduino) |
| módulo de cartão microSD | 1 | SPI; um cartão formatado em FAT |
| RTC DS3231 (opcional) | 1 | carimbos temporais reais; partilha o barramento I²C (endereço 0x68). Precisa da biblioteca RTClib (Adafruit). Sem ela, as linhas recebem o carimbo do tempo de funcionamento. |
Ligue tudo
Dois barramentos, sem conflito:
-
O I²C leva o módulo rbAmp (
0x50) — e o RTC (0x68) se o montar — em SDA/SCL. Alimente o módulo a 5 V, massa comum; o barramento é lógica de 3.3 V (porquê?). -
O SPI leva o módulo microSD nos pinos VSPI de hardware do ESP32: SCK → GPIO18, MISO → GPIO19, MOSI → GPIO23, CS → GPIO5. Mantenha os dois barramentos nos seus próprios pinos — sem conflito com o I²C.
As pinças SCT-013 envolvem à volta do condutor do circuito — não invasivas do lado da corrente.
O CSV
Em cada intervalo o registador acrescenta uma linha; o cabeçalho é escrito quando o ficheiro é criado pela primeira vez:
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
(Com o RTC instalado tem datas reais; sem ele, a coluna de carimbo temporal mostra o tempo de funcionamento up+.)
Abra-o em qualquer folha de cálculo ou ferramenta de gráficos — é apenas texto.
O esboço
Defina MY_CT, insira um cartão microSD e carregue o firmware. ESP32 (framework Arduino) a 50 kHz; SD nos pinos VSPI, RTC DS3231 no barramento I²C partilhado:
/**
* 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));
}
(Verificado por compilação em ESP32 com Arduino-CLI — RbAmp + RTClib + os SD/SPI/Wire incluídos. Cada linha é aberta, escrita, com flush e fechada imediatamente, por isso uma linha nunca se perde por um buffer não descarregado em caso de corte. O RTC DS3231 e o rbAmp partilham o barramento I²C; o cartão SD está em pinos SPI separados.)
O que o esboço faz
Três pequenas funções auxiliares fazem o registo — makeTimestamp(), ensureHeader() e logRow() — e loop() liga-as às leituras do medidor.
makeTimestamp() — hora real, ou tempo de funcionamento (uptime)
if (rtc_ok) snprintf(buf, n, "%04u-%02u-%02u %02u:%02u:%02u", now.year(), ...);
else snprintf(buf, n, "up+%lus", millis()/1000UL);
Se um DS3231 for detetado no arranque (rtc.begin()), as linhas recebem um carimbo de relógio real; se não, recorrem ao tempo de funcionamento up+ e o esboço di-lo na Serial. Em qualquer caso o CSV é válido — só perde datas absolutas sem o RTC.
ensureHeader() e logRow() — o caminho de escrita CSV
File f = SD.open(CSV_PATH, FILE_APPEND);
f.println(line);
f.flush();
f.close(); // open -> append -> flush -> close, every single row
ensureHeader() escreve o cabeçalho de colunas uma vez, apenas quando o ficheiro é criado pela primeira vez. logRow() formata uma linha e faz a parte importante: abre o ficheiro em modo de acrescentar, escreve a linha e depois faz flush e fecha imediatamente. Esse abrir/flush/fechar por linha é deliberado — a linha está no cartão no instante em que é escrita, por isso retirar a alimentação (ou o cartão) nunca perde dados em buffer. A mesma linha vai primeiro para o Serial.println(), por isso o fluxo série é um CSV autodescritivo que pode redirecionar diretamente para um ficheiro num PC.
loop() — ler, proteger, registar
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));
A cada LOG_MS (30 s) faz latch de um período de medição para que o total de watt-hora avance, lê a V/I/P em tempo real e — se nenhuma veio NaN — carimba e escreve a linha. Uma leitura transitória má é saltada em vez de escrita como lixo; um período obsoleto é assinalado mas a linha continua a ser escrita (com a V/I/P atual e os Wh atuais), porque descartar uma amostra inteira por causa de um passo de energia não avançado seria pior.
Usar os dados
Leve o cartão para um PC e abra o CSV numa folha de cálculo — trace a potência ao longo do dia, some a energia por hora, identifique o frigorífico a ciclar ou o ciclo de trabalho do termoacumulador. Como a coluna de energia são watt-hora reais integrados no anfitrião, os totais batem certo com o que esperaria na fatura. Quer vê-lo em gráfico em tempo real, em vez de depois? Coloque-o no Home Assistant — mas para um registo totalmente offline, este ficheiro é seu.
Personalize-o
-
Mais colunas — o módulo também fornece o fator de potência e a frequência; acrescente-os ao
CSV_HEADERe à string de formato dologRow. -
Ficheiros diários — inicie um novo ficheiro por dia (
/2026-07-30.csv) a partir da data do RTC, para que um registo não cresça sem limite. -
Acerte o relógio corretamente — o RTC toma a data da compilação no primeiro arranque; acrescente um
rtc.adjust()de uma linha com uma hora conhecida, ou sincronize por NTP se puser o ESP32 em Wi-Fi. -
Vários circuitos — registe uma linha por módulo e por intervalo combinando com a construção multimódulo.
-
Envie para algum lado — num ESP32 também pode enviar cada linha por POST para um servidor ou publicá-la via MQTT, mantendo o cartão SD como cópia de segurança offline.
A série Arduino, resumo
Tem agora o kit completo autónomo — sem necessidade de rede:
- Leia — um módulo num OLED.
- Escale-o — vários circuitos num barramento, coerentemente.
- Atue sobre ela — dispare um relé por sobrecorrente.
- Registe — esta construção, em SD/CSV.