rbAmp
FR
Boutique
Docs
Mis à jour · Modifier sur GitHub [Edit on GitHub]

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)

C++
#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 :

C++
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 :

YAML
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 :

JSON
[
  {
    "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 :

Text
# 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" ]
    }
}
Text
# 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 :

C++
#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 :

C++
#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 :

Text
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 :

C++
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.



Sources et problèmes : rb-amp/rbamp-arduino · cette page dans le dépôt : docs/07_diy_integrations.md (v1.6.2)