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

08 · Intégrations cloud

Comment envoyer les mesures rbamp vers des plateformes cloud — AWS IoT Core, Azure IoT Hub, Google Cloud, et les chaînes de supervision serverless / gérées. Pour chaque plateforme : comment mettre en place le projet ESP-IDF et ce qu'il faut configurer côté cloud.

Plateformes DIY auto-hébergées (Home Assistant, Node-RED, InfluxDB OSS) — voir 07 · Intégrations DIY.

Flotte → sujets MQTT par module

Dans le déploiement canonique (compteur principal + N sous-charges sur un même bus), le maître publie les mesures sur un sujet distinct pour chaque module. Un motif pratique consiste à parcourir la flotte en utilisant soit l'adresse du module, soit son LABEL défini par l'utilisateur :

C
char topic[64];
for (size_t i = 0; i < rbamp_fleet_count(fleet); ++i) {
    rbamp_handle_t dev = rbamp_fleet_get(fleet, i);
    char label[9]; rbamp_read_label(dev, label);
    snprintf(topic, sizeof topic, "rbamp/%s/snapshot",
             label[0] ? label : "unlabeled");
    /* publish snaps[i] as JSON to topic */
}

Sujets supplémentaires : rbamp/ (alimenté par rbamp_has_error), rbamp/fleet/total_power, rbamp/fleet/total_energy_wh, rbamp/fleet/balance (secteur − Σ(sous-charges) dans le scénario canonique 80 %). Un exemple complet avec charges utiles conservées et découverte automatique Home Assistant figure au chapitre 06 · Exemples, scénario 1.

Cloud Transport Authentification Latence Coût
AWS IoT Core MQTT/TLS Certificat X.509 faible $5/M messages
Azure IoT Hub MQTT/TLS ou AMQP Jeton SAS faible $0.40-2/M messages
Google Cloud IoT (déprécié en 2023) MQTT/TLS JWT — n/a
InfluxDB Cloud Protocole de ligne HTTPS Jeton API moyen $250/mo+
Webhook générique / REST POST HTTPS Clé API élevé dépend
Sécurité

⚠ TLS sur ESP32. Tout transport cloud sur TLS ajoute environ 30 kB de code + environ 30 kB de tas par négociation. Sur de très petites cibles à mémoire limitée (l'ESP32-C2 en particulier, surtout avec le Bluetooth activé), le tas TLS peut poser problème — voir 10 · Dépannage, section « TLS handshake fail » (échec de la négociation TLS).

Certificats TLS — motif à base de fichiers via SPIFFS

Contrairement à la bibliothèque Arduino, où les certificats sont généralement intégrés au firmware sous forme de chaînes PROGMEM, ESP-IDF privilégie une approche par fichiers : les fichiers de certificats sont placés dans une partition SPIFFS dédiée, et une URI de la forme file:///certs/aws_root_ca.pem est transmise à la configuration.

Table de partitions

Ajoutez une entrée pour la partition de certificats dans le partitions.csv de votre projet :

Text
# Name,     Type, SubType, Offset,  Size,    Flags
nvs,        data, nvs,     0x9000,  0x6000,
phy_init,   data, phy,     0xf000,  0x1000,
factory,    app,  factory, 0x10000, 0x100000,
certs,      data, spiffs,  ,        0x20000,

Dans sdkconfig.defaults :

Text
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"

Image SPIFFS avec certificats

Placez les fichiers de certificat dans un répertoire spiffs_image/ à côté de main/ et activez la génération d'image dans main/CMakeLists.txt :

CMake
idf_component_register(
    SRCS "main.c"
    INCLUDE_DIRS "."
    REQUIRES rbamp mqtt esp_http_client nvs_flash esp_wifi esp_event esp_netif
)

# SPIFFS image with certificates — built at build-time and flashed into
# the "certs" partition by one of the `idf.py spiffs-certs-flash` commands.
spiffs_create_partition_image(certs
    ${CMAKE_SOURCE_DIR}/spiffs_image
    FLASH_IN_PROJECT
)

Après idf.py build flash, les fichiers de spiffs_image/* se trouvent dans la partition certs et sont accessibles via VFS sous /certs/.

Montage à l'exécution

C
esp_vfs_spiffs_conf_t spiffs_cfg = {
    .base_path = "/certs",
    .partition_label = "certs",
    .max_files = 4,
    .format_if_mount_failed = false,
};
ESP_ERROR_CHECK(esp_vfs_spiffs_register(&spiffs_cfg));

Ensuite, l'URI "file:///certs/ca.pem" peut être passé à esp_mqtt_client_config_t.broker.verification.certificate_uri et aux champs similaires.


AWS IoT Core

AWS IoT Core utilise le TLS mutuel avec un certificat X.509 de l'appareil.

Provisionnement

  1. Console AWS → IoT Core → Manage → Things → Create things → Single thing [Manage → Things → Create things → Single thing].
  2. Générez le certificat et les clés ; téléchargez device.cert.pem, device.private.key, AmazonRootCA1.pem.

  3. Attachez une politique autorisant iot:Connect, iot:Publish sur arn:aws:iot:::topic/rbamp/+/state.

  4. Notez le point de terminaison AWS IoT : xxxxxx-ats.iot..amazonaws.com:8883.

Fichiers de certificats dans SPIFFS

À placer dans spiffs_image/ :

Text
spiffs_image/
  ca.pem          # AmazonRootCA1.pem
  client.crt      # device.cert.pem
  client.key      # device.private.key

Projet ESP-IDF

C
#include "freertos/FreeRTOS.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_spiffs.h"
#include "esp_wifi.h"
#include "mqtt_client.h"
#include "nvs_flash.h"
#include "rbamp.h"

#define AWS_URI       "mqtts://xxxxxx-ats.iot.eu-west-1.amazonaws.com:8883"
#define AWS_CLIENT_ID "rbamp-main"

static const char *TAG = "aws_iot";
static esp_mqtt_client_handle_t mqtt;

void app_main(void) {
    /* ...nvs + netif + wifi STA until IP_EVENT_STA_GOT_IP is received... */
    /* ...mount SPIFFS at /certs (see the TLS certificates section above)... */
    /* ...I²C bus + rbamp_new + rbamp_begin + set_sensor_class + set_ct_model... */
    rbamp_handle_t dev = NULL;

    const esp_mqtt_client_config_t cfg = {
        .broker.address.uri = AWS_URI,
        .broker.verification.certificate_uri = "file:///certs/ca.pem",
        .credentials.client_id = AWS_CLIENT_ID,
        .credentials.authentication.certificate_uri = "file:///certs/client.crt",
        .credentials.authentication.key_uri         = "file:///certs/client.key",
        .session.keepalive = 60,
    };
    mqtt = esp_mqtt_client_init(&cfg);
    ESP_ERROR_CHECK(esp_mqtt_client_start(mqtt));

    while (1) {
        vTaskDelay(pdMS_TO_TICKS(60000));

        rbamp_period_snapshot_t snap;
        if (rbamp_read_period_snapshot(dev, &snap, 50, false) != ESP_OK ||
            !snap.valid) continue;

        float u, freq;
        rbamp_read_voltage(dev, 0, &u);
        rbamp_read_frequency(dev, &freq);

        char payload[256];
        snprintf(payload, sizeof(payload),
            "{\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f,\"freq\":%.1f}",
            (double)u, (double)snap.avg_p[0],
            rbamp_energy_wh(dev, 0), (double)freq);
        esp_mqtt_client_publish(mqtt, "rbamp/main/state",
                                payload, 0, /*qos*/0, /*retain*/0);
    }
}

Traitement côté cloud

  • Créez une IoT Rule [IoT Rule] : SELECT *, topic(2) AS device FROM 'rbamp/+/state' → Kinesis Data Firehose ou Lambda pour le stockage.

  • Pour les tableaux de bord, utilisez AWS IoT SiteWise (historien industriel) ou Timestream (base de séries temporelles) → QuickSight.

  • Si Home Assistant tourne sur un Pi et consomme les données d'AWS, mettez en place un pont Mosquitto local (moins cher et plus rapide que HA → AWS directement).

Sur le coût

Publication une fois par minute et par appareil, AWS IoT atteint ~525k messages par an → ~2.60 $/an/appareil sur le palier « Connectivity » + « Messaging » (2026, us-east-1). Le coût Timestream / Lambda est séparé.


Azure IoT Hub

Azure IoT Hub prend en charge MQTT 3.1.1 sur TLS avec authentification par jeton SAS (plus simple que X.509 pour les usages domestiques).

Provisionnement

  1. Portail Azure → IoT Hub → Appareils → Nouveau → ID d'appareil rbamp-main, authentification = Clé symétrique.

  2. Enregistrez la chaîne de connexion : HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=….

  3. Générez un jeton SAS (par exemple via az iot hub generate-sas-token ou n'importe quel SDK Azure).

Certificat + configuration

Placez l'autorité de certification racine Azure (Baltimore CyberTrust Root ou DigiCert Global Root G2) dans spiffs_image/ca.pem.

C
#define AZ_URI        "mqtts://foo.azure-devices.net:8883"
#define AZ_USER       "foo.azure-devices.net/rbamp-main/?api-version=2021-04-12"
#define AZ_SAS        "SharedAccessSignature sr=foo.azure-devices.net%2Fdevices%2Frbamp-main&sig=…&se=…"
#define AZ_DEVICE_ID  "rbamp-main"

const esp_mqtt_client_config_t cfg = {
    .broker.address.uri = AZ_URI,
    .broker.verification.certificate_uri = "file:///certs/ca.pem",
    .credentials.client_id = AZ_DEVICE_ID,
    .credentials.username = AZ_USER,         /* SAS auth — no mTLS */
    .credentials.authentication.password = AZ_SAS,
    .session.keepalive = 60,
};

/* Publish to the Azure D2C topic: */
char topic[128];
snprintf(topic, sizeof(topic), "devices/%s/messages/events/", AZ_DEVICE_ID);
esp_mqtt_client_publish(mqtt, topic, payload, 0, /*qos*/0, /*retain*/0);

Expiration du jeton SAS

Les jetons SAS portent une revendication expiry — les durées de vie typiques vont de 1 heure à 1 an. Pour un déploiement ESP32, générez un jeton valable 1 an sur la machine de build et intégrez-le au firmware. Pour une rotation automatique sans surveillance, renouvelez-le périodiquement via le Device Provisioning Service (DPS) d'Azure IoT Hub ; cela dépasse le périmètre du composant.

Traitement côté cloud (Azure)

  • Acheminez les messages vers Event Hubs pour une ingestion à haut débit → Stream Analytics → tableaux de bord Power BI.

  • Une alternative moins chère : messages → Storage Account (blob) → Synapse Serverless SQL pour les requêtes ad hoc.


Google Cloud IoT (DÉPRÉCIÉ en 2023)

Google a arrêté Cloud IoT Core en 2023. Voies de migration :

  • Broker MQTT sur Compute Engine (vous déployez Mosquitto vous-même sur une VM) — le même motif que dans 07 · Intégrations maison, section Home Assistant, mais pointant vers l'IP publique de votre VM.

  • HiveMQ Cloud / EMQX Cloud — brokers MQTT gérés, ~10-20 $/mois sur les offres d'amateurs.

  • Pub/Sub sur HTTPS — publiez directement sur un sujet Pub/Sub via l'API REST (authentification par clé JSON de compte de service, intégrée à l'ESP32).

Pour Pub/Sub sur HTTPS, voir la section « Webhook générique / REST » ci-dessous, en remplaçant par le point de terminaison de publication Pub/Sub.


InfluxDB Cloud (TLSv1.3 + protocole de ligne)

InfluxDB Cloud (palier Serverless) accepte le line-protocol via HTTPS — la même forme que le chemin OSS décrit dans 07 · Intégrations maison, section InfluxDB OSS, mais avec cloud2.influxdata.com comme hôte et un jeton API pour l'authentification.

Placez l'AC de cloud2.influxdata.com (DigiCert Global Root G2 ou similaire) dans spiffs_image/influx_ca.pem.

C
#include "esp_http_client.h"
#include "esp_log.h"

#define INFLUX_URL    "https://us-east-1-1.aws.cloud2.influxdata.com/api/v2/write?org=MyOrg&bucket=energy&precision=s"
#define INFLUX_TOKEN  "your-rw-token"

static const char *TAG = "influx_cloud";

static esp_err_t read_ca(char *buf, size_t buflen, size_t *out_len) {
    FILE *f = fopen("/certs/influx_ca.pem", "rb");
    if (!f) return ESP_FAIL;
    *out_len = fread(buf, 1, buflen - 1, f);
    buf[*out_len] = '\0';
    fclose(f);
    return ESP_OK;
}

static void push_influx_cloud(float u, float p, double e_wh) {
    static char ca_buf[2048];
    static size_t ca_len = 0;
    if (ca_len == 0) {
        if (read_ca(ca_buf, sizeof(ca_buf), &ca_len) != ESP_OK) {
            ESP_LOGE(TAG, "CA read failed");
            return;
        }
    }

    char body[256];
    snprintf(body, sizeof(body),
        "rbamp,device=main voltage=%.1f,power=%.1f,energy=%.3f",
        (double)u, (double)p, e_wh);

    esp_http_client_config_t cfg = {
        .url        = INFLUX_URL,
        .method     = HTTP_METHOD_POST,
        .cert_pem   = ca_buf,
        .timeout_ms = 10000,    /* TLS handshake may take up to 3 s */
    };
    esp_http_client_handle_t client = esp_http_client_init(&cfg);
    esp_http_client_set_header(client, "Authorization", "Token " INFLUX_TOKEN);
    esp_http_client_set_header(client, "Content-Type", "text/plain");
    esp_http_client_set_post_field(client, body, strlen(body));

    esp_err_t err = esp_http_client_perform(client);
    int status = esp_http_client_get_status_code(client);
    esp_http_client_cleanup(client);

    if (err != ESP_OK || status != 204) {
        ESP_LOGW(TAG, "influx HTTP %d (err %s)", status, esp_err_to_name(err));
    }
}

/* In the 60-second loop, after rbamp_read_period_snapshot(): */
float u;
rbamp_read_voltage(dev, 0, &u);
push_influx_cloud(u, snap.avg_p[0], rbamp_energy_wh(dev, 0));

Le palier gratuit InfluxDB Cloud (5 Go / rétention de 30 jours) couvre environ 5000 points à une cadence d'une minute par jour — largement suffisant pour un usage domestique.


Webhook / REST générique

Publication vers n'importe quel point de terminaison HTTPS avec une clé API — fonctionne avec les webhooks IFTTT, les services Flask / FastAPI personnalisés ou toute fonction cloud (AWS Lambda / Azure Functions / GCP Cloud Run) exposée en HTTPS.

C
#include "esp_http_client.h"
#include "esp_log.h"
#include "esp_timer.h"

#define WEBHOOK_URL "https://your-api.example.com/ingest"
#define API_KEY     "Bearer your-token-here"

static const char *TAG = "webhook";

/* CA for your HTTPS endpoint (read from /certs/webhook_ca.pem,
 * via snprintf+fopen as in push_influx_cloud). */
extern const char *get_server_ca(void);   /* implementation as in the InfluxDB section */

static void push_webhook(float u, float p, double e_wh) {
    char body[256];
    snprintf(body, sizeof(body),
        "{\"ts\":%lld,\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f}",
        (long long)(esp_timer_get_time() / 1000000),
        (double)u, (double)p, e_wh);

    esp_http_client_config_t cfg = {
        .url        = WEBHOOK_URL,
        .method     = HTTP_METHOD_POST,
        .cert_pem   = get_server_ca(),
        .timeout_ms = 10000,
    };
    esp_http_client_handle_t client = esp_http_client_init(&cfg);
    esp_http_client_set_header(client, "Authorization", API_KEY);
    esp_http_client_set_header(client, "Content-Type", "application/json");
    esp_http_client_set_post_field(client, body, strlen(body));

    esp_err_t err = esp_http_client_perform(client);
    int status = esp_http_client_get_status_code(client);
    esp_http_client_cleanup(client);

    if (err != ESP_OK || status < 200 || status >= 300) {
        ESP_LOGW(TAG, "webhook HTTP %d (err %s)", status, esp_err_to_name(err));
    }
}
Sécurité

⚠ .skip_cert_common_name_check = false doit rester à false en production. Pendant le prototypage, vous pouvez utiliser .use_global_ca_store = true (le binaire n'embarque alors aucune AC spécifique, ce qui réduit la sécurité TLS) — mais ne JAMAIS livrer cela en production sans une AC explicite.

À une cadence faible (≤ une fois par minute), la surcharge est acceptable. À des cadences plus élevées, regroupez les données côté ESP32 (accumulez 10 minutes dans un tampon circulaire, puis publiez-les en un seul JSON groupé) pour ne pas payer une négociation TLS par requête.


Hybride : stockage local + synchronisation vers le cloud

Pour les déploiements tolérant les coupures : journaliser dans SPIFFS une fois par minute et pousser vers le cloud une fois par heure. Cela survit aux coupures WiFi sans perte de données.

C
#include 
#include "esp_log.h"
#include "esp_timer.h"
#include "rbamp.h"

#define LOG_PATH "/storage/log.csv"
static const char *TAG = "hybrid";

static void log_to_spiffs(const rbamp_period_snapshot_t *snap,
                          float u, double e_wh) {
    FILE *f = fopen(LOG_PATH, "a");
    if (!f) {
        ESP_LOGE(TAG, "fopen failed");
        return;
    }
    fprintf(f, "%lld,%.1f,%.1f,%.3f\n",
            (long long)(esp_timer_get_time() / 1000),
            (double)u, (double)snap->avg_p[0], e_wh);
    fclose(f);
}

static void sync_to_cloud_if_due(void) {
    static int64_t last_sync_us = 0;
    const int64_t now_us = esp_timer_get_time();
    if ((now_us - last_sync_us) < 3600LL * 1000000LL) return;   /* once per hour */
    last_sync_us = now_us;

    FILE *f = fopen(LOG_PATH, "r");
    if (!f) return;
    char line[256];
    while (fgets(line, sizeof(line), f)) {
        push_webhook_line(line);   /* line → JSON → POST */
    }
    fclose(f);
    /* Optionally: rename(LOG_PATH, "/storage/log_pushed.csv") + truncate */
}

L'accumulateur du composant, rbamp_energy_wh(dev, 0), continue de compter pendant toute la fenêtre hors ligne — aucune donnée n'est perdue tant que l'ESP32 est alimenté. La partition SPIFFS storage est présentée dans 06 · Exemples, scénario 8 (spiffs_logger).


Bilan énergétique

Une négociation TLS est une opération coûteuse : ~3 s + ~30 kB de tas par connexion. Pour les enregistreurs en deep-sleep (voir 06 · Exemples, scénario 9) :

  • Réutilisez la session TLS si l'intervalle de sommeil est < 24 h — le mbedtls d'ESP-IDF prend en charge la reprise de session via l'API mbedtls_ssl_get/set_session(). Cela ramène la négociation à ~500 ms.

  • Regrouper plusieurs mesures dans un SPIFFS local en une seule publication POST en bloc par réveil — le motif de la section « Hybride » ci-dessus.

  • MQTT sur TLS avec session persistante (session.disable_clean_session = true dans esp_mqtt_client_config_t) — le broker conserve vos abonnements entre deux réveils, donc inutile de republier la configuration de découverte.

Avec un intervalle de réveil de 10 minutes sur une cellule Li-ion de 2000 mAh, attendez-vous à environ 3 mois de fonctionnement en WiFi + TLS, contre environ 6 mois en WiFi + MQTT simple (selon le budget du scénario 9).


Voir aussi

  • 06 · Exemples — les projets de base sur lesquels reposent les intégrations cloud (surtout le scénario 8 « spiffs_logger » pour l'approche hybride)

  • 07 · Intégrations maison — alternatives auto-hébergées (Home Assistant / Node-RED / OpenHAB / InfluxDB OSS)

  • 10 · Dépannage — coupures Wi-Fi / débogage de la négociation TLS / problèmes de tas


Sources et tickets : rb-amp/rbamp-esp-idf · cette page dans le dépôt : docs/08_cloud_integrations.md (v1.7.3)