rbAmp
FR
Boutique

Projet · · lecture de 11 min

Enregistrement d'énergie sur Raspberry Pi en CSV et SQLite en Python, sans cloud

Transformez un Raspberry Pi en enregistreur d'énergie autonome : volts, ampères, watts et kWh horodatés, écrits en CSV ou SQLite en Python simple. Sans RTC, sans cloud.

Ce que vous allez construire

  • Une ligne CSV par intervalle — timestamp, voltage, current, power, energy — ajoutée à un fichier sur le Pi.
  • Optionnellement les mêmes lignes en SQLite (--sqlite energy.db), pour pouvoir faire un SELECT et tracer plus tard.
  • Horodatages réels issus de l'horloge système du Pi (synchronisée par NTP) — aucun matériel RTC nécessaire.
  • Robuste face à une mauvaise lecture, et vidé pour qu'une ligne survive à une coupure de courant.

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
Raspberry Pi 1 tout modèle doté de l'en-tête I²C 40 broches
Fils de liaison — le bus I²C (SDA / SCL / 5V / GND)

(Ni module carte SD, ni RTC — le Pi dispose déjà des deux.)

Câblage et installation

Le rbAmp se branche sur les broches I²C du Pi (SDA GPIO2 / SCL GPIO3, VCC 5 V — pourquoi 5 V alors que le bus est en 3.3 V ?), pince TC posée autour d'un conducteur. Activez I²C (sudo raspi-config) et installez — CSV et SQLite font tous deux partie de la bibliothèque standard de Python, donc aucune dépendance supplémentaire :

Bash
pip install rbamp smbus2

Le CSV

Chaque intervalle 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-30T14:05:00+01:00,230.70,3.793,875.00,0.0120
2026-07-30T14:05:30+01:00,230.65,3.788,873.40,1.4700

(L'horodatage porte le décalage de fuseau horaire local du Pi, pour que le fichier reste sans ambiguïté un an plus tard sur un autre hôte. Si votre Pi est hors ligne et non synchronisé par NTP, les horodatages affichent 1970-… jusqu'à ce que vous réglez l'horloge ou le connectiez.)

Ouvrez-le dans un tableur, ou — si vous avez passé --sqlite — interrogez la base : SELECT strftime('%H', timestamp), AVG(power_W) FROM energy GROUP BY 1;.

Le script

Lancez-le tel quel pour un CSV, ou ajoutez --sqlite energy.db pour écrire aussi une base interrogeable :

Python
"""
T-P4 -- Log energy to CSV (and optionally SQLite) on a Raspberry Pi.

One rbAmp module meters a circuit; every interval this script writes a
timestamped row to a CSV file, mirrors it to stdout so you can watch, and
-- if you pass `--sqlite path.db` -- also inserts the same row into an
SQLite table for easy querying (`SELECT AVG(power_W) FROM energy WHERE ...`).

Compared to the Arduino data-logger equivalent this is much simpler: the
Pi has a real filesystem and an NTP-synchronised system clock, so there
is no microSD-card module and no external RTC. Timestamps are just
`datetime.now().astimezone().isoformat(...)` -- the Pi is already telling
you the correct wall-clock time.

CSV columns:
    timestamp,voltage_V,current_A,power_W,energy_Wh

Wiring (Raspberry Pi, hardware I2C):
    rbAmp SDA -> GPIO2  (Pi pin 3)
    rbAmp SCL -> GPIO3  (Pi pin 5)
    rbAmp GND -> any GND pin
    rbAmp VCC -> 5V     (Pi pin 2 or 4)
                ^ rbAmp needs 5V for its analog front-end. Only the I2C
                  logic level is 3.3V (handled internally).

Enable I2C once on the Pi (same as T-P1/P2/P3):
    sudo raspi-config    # Interface Options -> I2C -> Enable

Install:
    pip install rbamp smbus2
    # `csv` and `sqlite3` are Python stdlib; no extra pip deps.

Run:
    python tp4_pi_csv_sqlite_logger.py                    # CSV only, every 30 s
    python tp4_pi_csv_sqlite_logger.py --sqlite energy.db # CSV + SQLite
    python tp4_pi_csv_sqlite_logger.py --interval 10 --ct 3

Accuracy: per clamp rating — the class and the sensor's own tolerance are both in the accuracy table on the BASIC page.
Ctrl-C to stop -- the CSV file + SQLite DB are flushed and closed cleanly.
Data is safe against power cuts: every CSV row is flushed and every SQLite
insert is committed before the loop moves on.
"""

import argparse
import csv
import os
import sqlite3
import sys
import time
from datetime import datetime

from smbus2 import SMBus

from rbamp import (
    RbAmp,
    RbAmpError,
    RbAmpStaleError,
    RbAmpSensorClass,
)

# ---- configuration --------------------------------------------------------
RBAMP_ADDR = 0x50
METER_CH   = 0
MY_CT      = 3         # SCT-013-030
CSV_PATH   = "energy.csv"
LOG_S      = 30.0      # one CSV row every 30 s

CSV_HEADER = ["timestamp", "voltage_V", "current_A", "power_W", "energy_Wh"]
SQLITE_DDL = """
CREATE TABLE IF NOT EXISTS energy (
    timestamp TEXT NOT NULL,
    voltage_V REAL,
    current_A REAL,
    power_W   REAL,
    energy_Wh REAL
)
"""
SQLITE_INSERT = "INSERT INTO energy (timestamp, voltage_V, current_A, power_W, energy_Wh) VALUES (?, ?, ?, ?, ?)"


def ensure_ct_preset(dev, ct_code):
    """Verify-then-set CT preset (same pattern as T-P1/P2/P3)."""
    try:
        applied = dev.read_ct_model_ch(0)
    except RbAmpError:
        applied = -1
    if applied == ct_code:
        return False
    dev.set_sensor_class(RbAmpSensorClass.SCT_013)
    dev.set_ct_model_ch(0, ct_code)
    return True


def sample_row(dev):
    """Read one V/I/P + latch a period + roll Wh. Returns a row tuple or None
    on any RbAmpError (transient hiccup / stale snapshot). The energy tick
    silently skips on stale but V/I/P are still reported."""
    try:
        v = dev.voltage
        i = dev.current[METER_CH]
        p = dev.power[METER_CH]
    except RbAmpError:
        return None
    try:
        dev.read_period_snapshot()   # library auto-rolls the Wh accumulator
    except RbAmpStaleError:
        pass                          # keep the V/I/P row; skip the energy tick
    except RbAmpError:
        pass
    wh = dev.energy.wh(METER_CH)
    # ISO-8601 with local tz offset; Pi is NTP-synced.
    ts = datetime.now().astimezone().isoformat(timespec="seconds")
    return (ts, v, i, p, wh)


def open_csv(path):
    """Open (or create) the CSV, write the header only if new, return
    (file, writer). Line-buffered so each row hits disk immediately."""
    is_new = not os.path.exists(path) or os.path.getsize(path) == 0
    f = open(path, "a", newline="", encoding="utf-8", buffering=1)
    w = csv.writer(f)
    if is_new:
        w.writerow(CSV_HEADER)
        f.flush()
    return f, w


def open_sqlite(path):
    """Open SQLite (create tables if missing), return connection. Explicit
    commit per insert gives crash-safe single-row durability."""
    con = sqlite3.connect(path)
    con.execute(SQLITE_DDL)
    con.commit()
    return con


def run(bus, addr=RBAMP_ADDR, ct_code=MY_CT,
        csv_path=CSV_PATH, sqlite_path=None, log_s=LOG_S,
        max_iters=None, stdout=sys.stdout):
    """Core loop. `sqlite_path=None` = CSV only."""
    with RbAmp(bus, addr=addr) as dev:
        ensure_ct_preset(dev, ct_code)
        print(f"rbAmp @ 0x{dev.address:02X}  fw=0x{dev.firmware_version:02X}  "
              f"topology={dev.topology_name}  ch={dev.channels}", file=stdout)
        print(f"logging every {log_s:.1f} s -> {csv_path}"
              + (f" + sqlite:{sqlite_path}" if sqlite_path else ""),
              file=stdout)
        print("Accuracy: per clamp rating — see the BASIC page. Ctrl-C stops.\n",
              file=stdout)

        csv_file, csv_writer = open_csv(csv_path)
        con = open_sqlite(sqlite_path) if sqlite_path else None

        rows = 0
        skipped = 0
        iters = 0
        try:
            while True:
                t_start = time.monotonic()
                row = sample_row(dev)
                if row is None:
                    skipped += 1
                    print(f"[SKIP #{skipped}] read failed -- holding, no row written",
                          file=stdout)
                else:
                    ts, v, i, p, wh = row
                    csv_writer.writerow([
                        ts,
                        f"{v:.2f}", f"{i:.3f}", f"{p:.2f}", f"{wh:.4f}",
                    ])
                    csv_file.flush()              # crash-safe row
                    if con is not None:
                        con.execute(SQLITE_INSERT, (ts, v, i, p, wh))
                        con.commit()               # crash-safe row
                    rows += 1
                    print(f"row#{rows:>4d}  {ts}  U={v:6.1f}V  I={i:6.3f}A  "
                          f"P={p:7.1f}W  E={wh:9.4f}Wh", file=stdout)

                iters += 1
                if max_iters is not None and iters >= max_iters:
                    return {"rows": rows, "skipped": skipped,
                            "csv": csv_path, "sqlite": sqlite_path}

                sleep_for = log_s - (time.monotonic() - t_start)
                if sleep_for > 0:
                    time.sleep(sleep_for)
        finally:
            csv_file.close()
            if con is not None:
                con.close()


def main():
    ap = argparse.ArgumentParser(
        description="Log rbAmp energy to CSV (and optionally SQLite) on a Raspberry Pi."
    )
    ap.add_argument("--bus",      type=int, default=1)
    ap.add_argument("--addr",     type=lambda s: int(s, 0), default=RBAMP_ADDR)
    ap.add_argument("--ct",       type=int, default=MY_CT)
    ap.add_argument("--csv",      type=str, default=CSV_PATH)
    ap.add_argument("--sqlite",   type=str, default=None,
                    help="Optional path to an SQLite DB file (adds `energy` table).")
    ap.add_argument("--interval", type=float, default=LOG_S,
                    help="Seconds between rows (default 30).")
    args = ap.parse_args()

    with SMBus(args.bus) as bus:
        run(bus, addr=args.addr, ct_code=args.ct,
            csv_path=args.csv, sqlite_path=args.sqlite, log_s=args.interval)


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\nstopped.")

(Exécution vérifiée avec le backend de simulation de la bibliothèque rbAmp et un vrai CSV sur système de fichiers ainsi qu'une vraie base SQLite sur CPython 3.12 — trois scénarios : écriture CSV+SQLite, idempotence d'ajout lors d'une nouvelle exécution, et SKIP gracieux sur des échecs de lecture injectés. Chaque ligne est vidée (CSV) et validée (SQLite) avant que la boucle n'avance, donc une coupure de courant ne perd jamais une ligne écrite.)

Ce que fait le script

Trois fonctions auxiliaires — sample_row(), open_csv() et (en option) open_sqlite() — alimentent une simple boucle run().

sample_row() — une lecture

Python
v = dev.voltage; i = dev.current[0]; p = dev.power[0]   # RbAmpError here -> return None (skip the row)
dev.read_period_snapshot()                              # roll the Wh accumulator (stale -> keep V/I/P, skip tick)
ts = datetime.now().astimezone().isoformat(timespec="seconds")
return (ts, v, i, p, dev.energy.wh(0))

Lit le V/I/P en direct, verrouille une période pour faire avancer le total en wattheures, et l'horodate avec l'heure système du Pi — ISO-8601 avec le décalage du fuseau horaire local, sans RTC ni réglage manuel de l'horloge puisque le Pi est synchronisé par NTP. Une erreur de lecture passagère renvoie None (la boucle saute cette ligne) ; une fenêtre d'énergie périmée conserve la ligne V/I/P mais n'avance pas les Wh pour cet intervalle.

open_csv() / open_sqlite() — les destinations

Python
f = open(path, "a", newline="", encoding="utf-8", buffering=1)   # line-buffered -> each row hits disk
if is_new: writer.writerow(CSV_HEADER)                           # header written once
con.execute("CREATE TABLE IF NOT EXISTS energy (...)")           # SQLite, only if --sqlite given

Le CSV s'ouvre en mode ajout (en-tête seulement si le fichier est nouveau), avec tampon de ligne pour que chaque ligne soit sur le disque immédiatement. Passez --sqlite et il ouvre aussi une base SQLite et crée la table energy si elle manque — le tout depuis la bibliothèque standard de Python, donc rien à installer.

La boucle run()

Python
row = sample_row(dev)
if row is None:  skipped += 1                       # bad read -> log a SKIP, no row
else:
    csv_writer.writerow([...]); csv_file.flush()    # crash-safe CSV row
    if con: con.execute(INSERT, row); con.commit()  # crash-safe SQLite row

Toutes les --interval secondes, il prend un échantillon et — si la lecture est bonne — écrit une ligne CSV (et une ligne SQLite si activé), en vidant et validant avant de se mettre en veille, pour qu'une coupure de courant ne perde jamais une ligne écrite. Un bloc finally ferme proprement le fichier et la base lors d'un Ctrl-C. Ce vidage/validation par ligne est toute la garantie de durabilité.

Exploiter les données

Ouvrez le CSV dans n'importe quel tableur — tracez la puissance sur la journée, additionnez l'énergie par heure, repérez les cycles du réfrigérateur. Ou, avec l'option SQLite, exécutez directement du SQL dessus — moyennes horaires, totaux journaliers, tout. 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 préférez un graphique en direct ? Intégrez-le à Home Assistant — mais pour un enregistrement entièrement hors ligne, ces fichiers vous appartiennent.

Récapitulatif de la série Python

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

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

À lire ensuite