07 · Intégrations DIY
Comment transmettre les lectures de RbAmp à des systèmes domotiques auto-hébergés populaires. Pour chaque plateforme, vous obtenez un croquis ESP32 minimal fonctionnel ainsi que la configuration correspondante côté plateforme.
Intégrations cloud / commerciales (AWS IoT, Azure, GCP, InfluxDB Cloud) — 08 · Intégrations cloud.
| Plateforme | Transport | Découverte automatique | Hôte |
|---|---|---|---|
| Home Assistant | MQTT | oui (découverte MQTT HA) | ESP32 |
| ESPHome | API native + MQTT | oui (configuration YAML) | ESP32 uniquement |
| Node-RED | MQTT (ou HTTP) | flux manuel | tout hôte |
| OpenHAB | MQTT (ou REST) | .things manuel |
tout hôte |
| Domoticz | MQTT (auto) ou HTTP | oui (extension MQTT) | tout hôte |
| InfluxDB OSS + Grafana | Protocole de ligne HTTP | non | tout hôte |
Home Assistant — découverte automatique MQTT
La découverte MQTT HA crée automatiquement l'appareil et ses capteurs dès que l'ESP32 publie les sujets de configuration. Aucune modification YAML dans HA n'est nécessaire.
Croquis ESP32 (RbAmp + Wi-Fi + découverte MQTT)
#include
#include
#include
#include
#define RBAMP_ADDR 0x50
static const char* DEVICE_ID = "rbamp_main";
static const char* DEVICE_NAME = "Mains rbAmp";
static RbAmp dev(Wire, RBAMP_ADDR);
static WiFiClient espClient;
static PubSubClient mqtt(espClient);
void publish_discovery_sensor(const char* key, const char* friendly,
const char* unit, const char* device_class,
const char* state_class) {
char topic[128], payload[512];
snprintf(topic, sizeof(topic),
"homeassistant/sensor/%s/%s/config", DEVICE_ID, key);
int n = snprintf(payload, sizeof(payload),
"{"
"\"name\":\"%s %s\","
"\"unique_id\":\"%s_%s\","
"\"state_topic\":\"rbamp/%s/state\","
"\"value_template\":\"{{ value_json.%s }}\","
"\"state_class\":\"%s\","
"\"device\":{"
"\"identifiers\":[\"%s\"],"
"\"name\":\"%s\","
"\"manufacturer\":\"rbAmp\","
"\"model\":\"UI*\""
"}",
DEVICE_NAME, friendly,
DEVICE_ID, key,
DEVICE_ID, key, state_class,
DEVICE_ID, DEVICE_NAME);
if (unit) n += snprintf(payload+n, sizeof(payload)-n,
",\"unit_of_measurement\":\"%s\"", unit);
if (device_class) n += snprintf(payload+n, sizeof(payload)-n,
",\"device_class\":\"%s\"", device_class);
snprintf(payload+n, sizeof(payload)-n, "}");
mqtt.publish(topic, payload, true);
}
void publish_discovery_all() {
publish_discovery_sensor("voltage", "Voltage", "V", "voltage", "measurement");
publish_discovery_sensor("current", "Current", "A", "current", "measurement");
publish_discovery_sensor("power", "Power", "W", "power", "measurement");
publish_discovery_sensor("energy", "Energy", "Wh", "energy", "total_increasing");
publish_discovery_sensor("frequency", "Frequency", "Hz", "frequency", "measurement");
publish_discovery_sensor("power_factor", "Power Factor", NULL, "power_factor", "measurement");
}
void setup() {
Serial.begin(115200);
WiFi.begin("ssid", "pass");
while (WiFi.status() != WL_CONNECTED) delay(500);
mqtt.setServer("192.168.1.10", 1883);
mqtt.setKeepAlive(60);
mqtt.setBufferSize(1024); // enough for one discovery payload
mqtt.connect(DEVICE_ID);
publish_discovery_all();
Wire.begin();
Wire.setClock(50000); // ESP32 baseline mitigation — see 10 · Troubleshooting
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
}
void loop() {
if (!mqtt.connected()) mqtt.connect(DEVICE_ID);
mqtt.loop();
static uint32_t last = 0;
if (last == 0) last = millis();
if (millis() - last < 60000) { delay(50); return; }
last = millis();
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) return;
char state[384];
snprintf(state, sizeof(state),
"{\"voltage\":%.1f,\"current\":%.3f,\"power\":%.1f,"
"\"energy\":%.3f,\"frequency\":%.1f,\"power_factor\":%.3f}",
dev.readVoltage(), dev.readCurrent(0), snap.avg_p[0],
dev.energy().wh(0), dev.readFrequency(), dev.readPowerFactor(0));
char topic[64];
snprintf(topic, sizeof(topic), "rbamp/%s/state", DEVICE_ID);
mqtt.publish(topic, state, false);
}
Résultat dans HA
Quelques secondes après la première publication, HA crée automatiquement un appareil nommé « Mains rbAmp » avec 6 capteurs (Tension, Courant, Puissance, Énergie, Fréquence, Facteur de puissance). Le capteur Énergie porte state_class: total_increasing et le device_class correct — le tableau de bord Énergie de HA l'accepte comme source de consommation.
Pour retirer plus tard l'appareil de HA, publiez une charge utile vide sur homeassistant/sensor/.../config (le drapeau retained efface l'enregistrement).
UI3 multi-canaux
Répétez les appels publish_discovery_sensor() avec des clés suffixées pour les canaux 1 et 2 :
publish_discovery_sensor("current_1", "Current 1", "A", "current", "measurement");
publish_discovery_sensor("power_1", "Power 1", "W", "power", "measurement");
publish_discovery_sensor("energy_1", "Energy 1", "Wh", "energy", "total_increasing");
// ...same for _2
Complétez ensuite le JSON d'état avec les champs "current_1", "power_1", "energy_1", renseignés à partir de dev.readCurrent(1) / snap.avg_p[1] / dev.energy().wh(1).
ESPHome via un composant externe
Si votre ESP32 exécute déjà ESPHome (plutôt qu'ESP-IDF nu / arduino-esp32), il existe un composant externe dédié rbamp :
external_components:
- source: github://rb-amp/rbamp-esphome
components: [rbamp]
refresh: 0s
i2c:
sda: 21
scl: 22
frequency: 50kHz # see 10 · Troubleshooting on baseline mitigation
sensor:
- platform: rbamp
address: 0x50
update_interval: 60s
voltage:
name: "rbAmp Voltage"
current:
name: "rbAmp Current"
power:
name: "rbAmp Power"
energy:
name: "rbAmp Energy"
frequency:
name: "rbAmp Frequency"
power_factor:
name: "rbAmp Power Factor"
Cela remplace entièrement le croquis Arduino ci-dessus. ESPHome s'intègre nativement à HA via l'API ESPHome (et non MQTT) — l'appareil apparaît automatiquement dans HA après le flashage.
Le composant rbamp-esphome réside dans un dépôt séparé — voir l'index principal de rbAmp pour les liens.
Node-RED
Abonnez-vous au sujet MQTT de l'ESP32 dans un flux :
[
{
"id": "rbamp_in",
"type": "mqtt in",
"topic": "rbamp/main/state",
"qos": "0",
"datatype": "json"
},
{
"id": "rbamp_chart",
"type": "ui_chart",
"label": "Mains Power",
"chartType": "line",
"ymin": "0",
"ymax": "5000"
},
{
"id": "extract_power",
"type": "function",
"func": "msg.payload = msg.payload.power; return msg;"
}
]
Reliez rbamp_in → extract_power → rbamp_chart et vous obtenez un graphique de puissance en temps réel. Faites de même pour l'énergie / la tension / le FP.
Si Node-RED tourne sur le même Pi que le broker MQTT, définissez l'hôte sur localhost. Pour des brokers distants, utilisez 192.168.X.Y:1883 plus des identifiants si le broker exige une authentification.
OpenHAB
OpenHAB 4.x + liaison MQTT :
# things/rbamp.things
Bridge mqtt:broker:local "MQTT Broker" [ host="192.168.1.10", port=1883 ] {
Thing topic rbamp_main "rbAmp Main" {
Channels:
Type number : voltage "Voltage" [ stateTopic="rbamp/main/state", transformationPattern="JSONPATH:$.voltage" ]
Type number : current "Current" [ stateTopic="rbamp/main/state", transformationPattern="JSONPATH:$.current" ]
Type number : power "Power" [ stateTopic="rbamp/main/state", transformationPattern="JSONPATH:$.power" ]
Type number : energy "Energy" [ stateTopic="rbamp/main/state", transformationPattern="JSONPATH:$.energy" ]
}
}
# items/rbamp.items
Number:ElectricPotential rbAmp_Voltage "Voltage [%.1f V]" { channel="mqtt:topic:local:rbamp_main:voltage" }
Number:ElectricCurrent rbAmp_Current "Current [%.3f A]" { channel="mqtt:topic:local:rbamp_main:current" }
Number:Power rbAmp_Power "Power [%.1f W]" { channel="mqtt:topic:local:rbamp_main:power" }
Number:Energy rbAmp_Energy "Energy [%.3f Wh]" { channel="mqtt:topic:local:rbamp_main:energy" }
Le croquis Arduino est le même que celui de la section Home Assistant ci-dessus. La charge utile JSON est partagée ; seul le consommateur diffère.
Domoticz
Le plugin MQTT Auto-discovery de Domoticz comprend les mêmes topics de découverte homeassistant/.... Activez le plugin dans les paramètres de Domoticz : le croquis ESP32 de la section HA ci-dessus enregistrera alors automatiquement l'appareil dans Domoticz, comme il le fait dans HA.
L'autre solution est l'API HTTP native de Domoticz :
#include
void publish_to_domoticz(int idx, float power, double e_wh) {
char url[256];
// Energy in Wh, Power in W — Domoticz format: "POWER;ENERGY_WH"
snprintf(url, sizeof(url),
"http://192.168.1.20:8080/json.htm?type=command¶m=udevice&idx=%d&svalue=%.1f;%.0f",
idx, power, e_wh);
HTTPClient http;
http.begin(url);
int code = http.GET();
http.end();
if (code != 200) Serial.printf("domoticz HTTP %d\n", code);
}
// In your 60-second loop:
publish_to_domoticz(123 /* your idx */, snap.avg_p[0], dev.energy().wh(0));
Créez un périphérique dans l'interface Domoticz de type General → kWh [General → kWh] (compteur incrémental), récupérez son idx et codez-le en dur dans le croquis.
InfluxDB OSS + Grafana
Écrivez des points en line-protocol dans InfluxDB directement depuis l'ESP32 :
#include
#define INFLUX_HOST "192.168.1.30:8086"
#define INFLUX_ORG "homelab"
#define INFLUX_BKT "energy"
#define INFLUX_TOKEN "your-token-here"
void push_influx(float u, float p, double e_wh) {
char url[256], body[256];
snprintf(url, sizeof(url),
"http://" INFLUX_HOST "/api/v2/write?org=%s&bucket=%s&precision=s",
INFLUX_ORG, INFLUX_BKT);
snprintf(body, sizeof(body),
"rbamp,device=main voltage=%.1f,power=%.1f,energy=%.3f",
u, p, e_wh);
HTTPClient http;
http.begin(url);
http.addHeader("Authorization", "Token " INFLUX_TOKEN);
http.addHeader("Content-Type", "text/plain");
int code = http.POST(body);
http.end();
if (code != 204) Serial.printf("influx HTTP %d\n", code);
}
// In your 60-second loop:
RbAmpPeriodSnapshot snap;
if (dev.readPeriodSnapshot(snap)) {
push_influx(dev.readVoltage(), snap.avg_p[0], dev.energy().wh(0));
}
Dans Grafana, ajoutez une source de données InfluxDB, puis un panneau avec une requête Flux :
from(bucket: "energy")
|> range(start: -24h)
|> filter(fn: (r) => r._measurement == "rbamp" and r.device == "main")
|> filter(fn: (r) => r._field == "power")
Pour un déploiement d'endurance longue, transmettez aussi les compteurs de diagnostic :
snprintf(body, sizeof(body),
"rbamp_diag,device=main retry_exhaust=%lu,sanity_reject=%lu",
dev.retryExhaustionCount(), dev.sanityRejectCount());
// ...push to InfluxDB...
— et vous obtenez un graphique de santé du bus à côté des données d'énergie.
Multi-plateformes — diffusion depuis un seul ESP32
Si vous avez besoin de la découverte automatique HA, d'InfluxDB et de Node-RED à la fois, publiez l'état JSON une seule fois sur MQTT et laissez chaque consommateur s'abonner à rbamp/+/state. L'ESP32 ne parle qu'au broker MQTT — le broker assure la diffusion vers les abonnés. Ne poussez pas depuis l'ESP32 vers N points de terminaison HTTP directement : cela couple l'appareil à des consommateurs précis.
Pour un flux à très haut débit (RT 10 Hz), exécutez un script Python auxiliaire sur le Pi qui héberge le broker — abonnez-vous au sujet rapide, réduisez la cadence et republiez vers les sujets lents. La boucle I²C de l'ESP32 doit rester concentrée sur les appels dev.read*(), sans surcharge HTTP.
Liens
-
06 · Exemples — les croquis de référence sur lesquels reposent ces intégrations
-
08 · Intégrations cloud — AWS / Azure / GCP / services externes
-
10 · Dépannage — schémas de déconnexion MQTT, chien de garde WiFi, tas TLS, etc.
Sources et problèmes : rb-amp/rbamp-arduino · cette page dans le dépôt : docs/07_diy_integrations.md (v1.6.2)