Ce que vous allez construire
- Tension, courant, puissance active et facteur de puissance en direct, affichés dans le terminal environ une fois par seconde.
- Un total d'énergie (Wh) cumulé, intégré sur le Pi en temps mural.
- Tout sur le bus I²C du Pi — quatre fils — en CPython simple.
- Aucun service Wi-Fi, pas de cloud, pas de HA. Juste un script que vous lancez.
Nomenclature
| Élément | Qté | Remarques |
|---|---|---|
| rbAmp BASIC SCT-UI1 | 1 | tension + courant + puissance réelle sur puce · produit |
| Transformateur de courant 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) |
Activer I²C et installer la bibliothèque
Sur le Pi, activez une fois l'interface I²C — sudo raspi-config → Interface Options → I2C → activer (ou ajoutez dtparam=i2c_arm=on à /boot/firmware/config.txt et redémarrez). Installez ensuite le paquet :
pip install rbamp smbus2
(Le pilote I²C du noyau du Pi tourne à 100 kHz par défaut et convient au module — il n'y a pas de contournement à 50 kHz ici ; cela ne vaut que pour le pilote ESP-IDF sur ESP32.)
Câblage
Le module rbAmp se branche sur les broches I²C du Pi :
Raspberry Pi header rbAmp (0x50)
------------------- ------------
pin 3 SDA (GPIO2) ────────── SDA
pin 5 SCL (GPIO3) ────────── SCL
pin 2 5V ────────── VCC (rbAmp wants 5 V)
pin 6 GND ────────── GND
│
└── SCT-013 clamped around ONE mains conductor (arrow → load)
-
Le bus I²C du Pi est en logique 3.3 V, et le module rbAmp embarque des tirages — donc pas de tirages supplémentaires pour un seul module. Alimentez le module en 5 V (les broches 5 V du Pi) ; les lignes du bus sont au repos à 3.3 V. (Pourquoi une alimentation 5 V avec un bus 3.3 V ?)
-
Les pinces SCT-013 se placent autour d'un conducteur isolé — vous ne coupez ni ne dénudez jamais le fil sous tension côté courant. Le côté tension alternative se branche au secteur. Pour toute intervention dans un tableau électrique, faites appel à un électricien qualifié.
Le script
Enregistrez-le, réglez MY_CT (ou passez --ct) pour correspondre à votre pince, puis lancez python tp1_standalone_pi_monitor.py :
"""
T-P1 — Standalone Raspberry Pi energy monitor (no network, no HA).
One rbAmp UI1 module on the Raspberry Pi hardware I2C bus. Prints live
mains Voltage / Current / Power / Power Factor to the terminal every
second, and every 30 s latches a period snapshot to roll a host-side
Energy (Wh) total. Nothing is invented on-device: Wh is integrated on
the host from average power x wall-clock dt, which is what makes the
total honest.
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; 4.5-5.5 V -- below 4.5 V the ADC loses accuracy)
Enable I2C once on the Pi:
sudo raspi-config # Interface Options -> I2C -> Enable
# (equivalent to `dtparam=i2c_arm=on`)
The stock Raspberry Pi Broadcom I2C driver runs at 100 kHz and is
clean with rbAmp straight out of the box -- no `dtparam=i2c_arm_baudrate`
override is needed. (The 50 kHz workaround only applies to the ESP-IDF
i2c_master driver on ESP32.)
Install:
pip install rbamp smbus2
Run:
python tp1_standalone_pi_monitor.py
# or with a non-default bus / address / CT model:
# python tp1_standalone_pi_monitor.py --bus 1 --addr 0x50 --ct 3
Set MY_CT below (or pass --ct) to match YOUR clamp before first run.
The value persists to the module's flash, so this script only re-writes
it when it actually differs -- no flash wear on every power-up.
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.
"""
import argparse
import time
from smbus2 import SMBus
from rbamp import (
RbAmp,
RbAmpError,
RbAmpStaleError,
RbAmpSensorClass,
)
# ---- configuration --------------------------------------------------------
# CT model code (matches your clamp; persists to module flash):
# 1 = SCT-013-005 (5 A) 4 = SCT-013-050 (50 A)
# 2 = SCT-013-010 (10 A) 6 = SCT-013-020 (20 A)
# 3 = SCT-013-030 (30 A)
MY_CT = 3
LIVE_S = 1.0 # refresh V/I/P/PF each second
ENERGY_S = 30.0 # latch a period + roll Wh every 30 s
def ensure_ct_preset(dev, ct_code):
"""Verify-then-set: only rewrite the CT preset if the module isn't
already on it. set_sensor_class / set_ct_model_ch both persist to
flash, so this avoids a needless flash write every power-up.
"""
try:
applied = dev.read_ct_model_ch(0)
except RbAmpError:
applied = -1
if applied == ct_code:
print(f"CT model already SCT_013 code={ct_code}; skipping flash write")
return False
print(f"configuring CT model SCT_013 code={ct_code} (persists to flash)...")
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model_ch(0, ct_code)
return True
def read_live(dev, last, counters):
"""Read one live sample. A single transient hiccup keeps the previous
plausible reading so the terminal keeps ticking (mirrors the Arduino
T-A1 NaN-guard)."""
try:
v = dev.voltage
i = dev.current[0]
p = dev.power[0]
pf = dev.power_factor[0]
except RbAmpError as e:
counters["bad"] += 1
print(f"read skipped: {type(e).__name__} -- {e}")
return
last["V"], last["I"], last["P"], last["PF"] = v, i, p, pf
counters["ok"] += 1
print(
f"U={v:6.1f}V I={i:6.3f}A P={p:7.1f}W PF={pf:+.2f} "
f"E={dev.energy.wh(0):8.4f}Wh "
f"[ok={counters['ok']} bad={counters['bad']}]"
)
def roll_energy(dev):
"""Latch a metering period; the library rolls Wh from avg power x master
dt on a successful valid snapshot. A stale / not-ready period is reported
and skipped so the loop keeps running on the last live values."""
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
print(" * period STALE (skipped)")
return
except RbAmpError as e:
print(f" * period skipped: {type(e).__name__} -- {e}")
return
print(
f" * period ok: avg_P0={snap.avg_p[0]:6.2f}W "
f"dt={snap.master_dt_ms:5d}ms -> E={dev.energy.wh(0):.4f}Wh"
)
def run(bus, addr=0x50, ct_code=MY_CT,
live_s=LIVE_S, energy_s=ENERGY_S, max_iters=None):
"""Core loop; broken out so a test harness can swap in a mock bus."""
with RbAmp(bus, addr) as dev:
print(
f"rbAmp @ 0x{dev.address:02X} fw=0x{dev.firmware_version:02X} "
f"topology={dev.topology_name} channels={dev.channels} "
f"voltage_hw={'yes' if dev.has_voltage_hw else 'no'}"
)
ensure_ct_preset(dev, ct_code)
print("Accuracy: per clamp rating — see the BASIC page. Ctrl-C to stop.\n")
last = {"V": 0.0, "I": 0.0, "P": 0.0, "PF": 0.0}
counters = {"ok": 0, "bad": 0}
next_live_t = time.monotonic()
next_energy_t = next_live_t + energy_s
iters = 0
while True:
now = time.monotonic()
if now >= next_live_t:
next_live_t = now + live_s
read_live(dev, last, counters)
if now >= next_energy_t:
next_energy_t = now + energy_s
roll_energy(dev)
iters += 1
if max_iters is not None and iters >= max_iters:
return counters
sleep_for = min(next_live_t, next_energy_t) - time.monotonic()
if sleep_for > 0:
time.sleep(sleep_for)
def main():
ap = argparse.ArgumentParser(
description="Standalone Raspberry Pi energy monitor for a single rbAmp UI1 module."
)
ap.add_argument("--bus", type=int, default=1,
help="I2C bus number (Raspberry Pi default: 1)")
ap.add_argument("--addr", type=lambda s: int(s, 0), default=0x50,
help="rbAmp I2C address (default: 0x50)")
ap.add_argument("--ct", type=int, default=MY_CT,
help="CT model code: 1=SCT-013-005, 2=-010, 3=-030, "
"4=-050, 6=-020 (default: 3 = 30 A)")
args = ap.parse_args()
with SMBus(args.bus) as bus:
run(bus, addr=args.addr, ct_code=args.ct)
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
print("\nstopped.")
(Exécution vérifiée avec le backend de test de la bibliothèque Python rbAmp sur CPython 3.12 — rbamp 1.3.0 + smbus2 0.6.1. set_ct_model_ch() écrit en flash, donc le script ne réécrit le préréglage du TC que lorsqu'il diffère réellement — pas d'usure de la flash à chaque exécution. Le cœur run() est isolé pour être facile à tester ou à réutiliser.)
Ce que fait le script
Toute la bibliothèque Python rbAmp tient en quelques blocs with et une poignée de lectures.
Les gestionnaires de contexte
with SMBus(1) as bus:
with RbAmp(bus, 0x50) as dev:
...
SMBus(1) ouvre le bus I²C du Pi ; RbAmp(bus, 0x50) lie la bibliothèque au module à l'adresse 0x50. Les deux sont des gestionnaires de contexte : le bus et le périphérique sont nettoyés automatiquement à la sortie du bloc (ou sur Ctrl-C) — la version Python de « ouvrir le bus, sonder le module ».
Les lectures en direct
v = dev.voltage
i = dev.current[0]
p = dev.power[0]
pf = dev.power_factor[0]
Ces propriétés renvoient les mesures réelles du module : dev.power[0] est la puissance active réelle en watts — la moyenne de la tension × courant instantanés, et non le courant × une tension supposée. (La forme méthode dev.read_power(0) est strictement équivalente — utilisez celle qui se lit le mieux.) Une lecture passagère peut lever RbAmpError ; le script l'intercepte et conserve les dernières valeurs correctes au lieu de planter.
Énergie — l'instantané de période
snap = dev.read_period_snapshot() # atomic LATCH: close the window, read avg power
print(dev.energy.wh(0)) # host-integrated watt-hours, honest over wall-clock time
read_period_snapshot() envoie au module un LATCH atomique — « fermer la fenêtre de mesure maintenant » — et la bibliothèque fait avancer le total de wattheures côté hôte à partir de average_power × elapsed_time. Le Pi gère l'intervalle d'intégration, donc il n'y a aucun compteur embarqué qui puisse dériver ; dev.energy.wh(0) est un total courant fiable. Une fenêtre périmée lève RbAmpStaleError, que le script ignore simplement.
Ce que vous verrez
Dans le terminal, une lecture en direct qui suit la charge — allumez une lampe ou une bouilloire et regardez les watts bondir :
rbAmp @ 0x50 fw=0x04 topology=SINGLE channels=1 voltage_hw=yes
CT model already SCT_013 code=3; skipping flash write
Accuracy: per clamp rating — see the BASIC page. Ctrl-C to stop.
U= 231.2V I= 4.874A P= 1123.5W PF=+1.00 E= 0.0000Wh [ok=1 bad=0]
U= 231.2V I= 4.874A P= 1123.5W PF=+1.00 E= 0.0000Wh [ok=2 bad=0]
* period ok: avg_P0=1119.40W dt= 50ms -> E=0.0622Wh
U= 231.2V I= 4.874A P= 1123.5W PF=+1.00 E= 0.0622Wh [ok=3 bad=0]
Quelle est sa précision ?
Avec une pince SCT-013, la classe et la tolérance propre de la pince sont publiées par calibre dans le tableau de précision SCT-013. Le module mesure la puissance active réelle avec une compensation de phase par canal — donc les charges réactives et à faible facteur de puissance se lisent honnêtement. Les raisons derrière les chiffres : comment fonctionne réellement la mesure d'énergie par TC.
Adaptez-le à votre installation
-
Journalisez dans un fichier ou SQLite — le Pi dispose d'un vrai système de fichiers ; ajoutez chaque lecture en CSV ou dans une base de données (c'est le montage d'enregistrement).
-
Servez-le — le Pi est en réseau : exposez les lectures via un petit point d'accès Flask, ou publiez-les via MQTT vers votre propre broker — sans aucun cloud.
-
Un résumé cron — exécutez le script à intervalle régulier et recevez par e-mail un total journalier en kWh.
- Ajoutez un écran — un petit OLED I²C sur le même bus pour un affichage sans écran principal.
- Davantage de circuits — placez plusieurs modules sur le bus et totalisez-les (c'est le montage multimodule).
Rien de tout cela ne touche à la mesure — ce sont les usages que vous faites des chiffres que les lectures vous donnent déjà.
Pour aller plus loin
Ce module unique dans le terminal est la base. À partir de là, la série Python se construit :
- Mesurez plusieurs circuits — plusieurs modules rbAmp sur un même bus, lus et totalisés par le Pi.
- Agissez — déclenchez un relais GPIO quand un circuit dépasse une limite de courant.
- Journalisez-le — énergie périodique en CSV ou SQLite.
(Vous préférez un microcontrôleur à un Pi ? Le même module fonctionne avec Arduino ou dans Home Assistant via ESPHome.)