rbAmp
ES
Tienda
Docs
Actualizado · Editar en GitHub

08 · Integraciones en la nube

Cómo enviar las lecturas de rbamp a plataformas en la nube: AWS IoT Core, Azure IoT Hub, Google Cloud y canalizaciones de observabilidad gestionadas o sin servidor. Para cada plataforma: cómo montar el proyecto ESP-IDF y qué debe configurar en el lado de la nube.

Plataformas DIY autoalojadas (Home Assistant, Node-RED, InfluxDB OSS): vea 07 · Integraciones DIY.

Flota → temas MQTT por módulo

En la implantación canónica (acometida + N subcircuitos en un bus), el maestro publica las lecturas en un tema independiente para cada módulo. Un patrón práctico es recorrer la flota usando la dirección del módulo o su LABEL definido por el usuario:

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 */
}

Temas adicionales: rbamp/ (generado por rbamp_has_error), rbamp/fleet/total_power, rbamp/fleet/total_energy_wh, rbamp/fleet/balance (red − Σ(subcircuitos) en el escenario canónico del 80 %). Un ejemplo completo con cargas útiles retenidas y autodescubrimiento de Home Assistant está en el capítulo 06 · Ejemplos, escenario 1.

Nube Transporte Autenticación Latencia Coste
AWS IoT Core MQTT/TLS Certificado X.509 bajo $5/M mensajes
Azure IoT Hub MQTT/TLS o AMQP Token SAS bajo $0.40-2/M mensajes
Google Cloud IoT (obsoleto desde 2023) MQTT/TLS JWT — n/a
InfluxDB Cloud Protocolo de línea HTTPS Token de API medio $250/mo+
Webhook genérico / REST POST HTTPS Clave de API alta depende
Seguridad

⚠ TLS en ESP32. Cualquier transporte en la nube sobre TLS añade unos 30 kB de código + unos 30 kB de heap por handshake. En objetivos muy pequeños con memoria limitada (el ESP32-C2 en particular, sobre todo con Bluetooth activado) el heap de TLS puede ser un problema: vea 10 · Solución de problemas, sección «Fallo del handshake TLS».

Certificados TLS — patrón basado en archivos mediante SPIFFS

A diferencia de la biblioteca de Arduino, donde los certificados suelen incrustarse en el firmware mediante cadenas PROGMEM, ESP-IDF prefiere un enfoque basado en archivos: los archivos de certificado se colocan en una partición SPIFFS dedicada, y se pasa a la configuración un URI del tipo file:///certs/aws_root_ca.pem.

Tabla de particiones

Añada una entrada para la partición de certificados en el partitions.csv de su proyecto:

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,

En sdkconfig.defaults:

Text
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"

Imagen SPIFFS con certificados

Coloque los archivos de certificado en un directorio spiffs_image/ junto a main/ y habilite la generación de la imagen en 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
)

Tras idf.py build flash, los archivos de spiffs_image/* quedan en la partición certs y son accesibles por VFS en /certs/.

Montaje en tiempo de ejecución

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));

Después, el URI "file:///certs/ca.pem" puede pasarse a esp_mqtt_client_config_t.broker.verification.certificate_uri y a campos similares.


AWS IoT Core

AWS IoT Core usa TLS mutuo con un certificado de dispositivo X.509.

Aprovisionamiento

  1. AWS Console → IoT Core → Manage → Things → Create things → Single thing.
  2. Genere el certificado y las claves; descargue device.cert.pem, device.private.key, AmazonRootCA1.pem.

  3. Asocie una política que permita iot:Connect, iot:Publish sobre arn:aws:iot:::topic/rbamp/+/state.

  4. Tenga en cuenta el endpoint de AWS IoT: xxxxxx-ats.iot..amazonaws.com:8883.

Archivos de certificado en SPIFFS

Colóquelo en spiffs_image/:

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

Proyecto 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);
    }
}

Procesamiento en el lado de la nube

  • Cree una IoT Rule: SELECT *, topic(2) AS device FROM 'rbamp/+/state' → Kinesis Data Firehose o Lambda para almacenamiento.

  • Para paneles, use AWS IoT SiteWise (historiador industrial) o Timestream (base de datos de series temporales) → QuickSight.

  • Si Home Assistant se ejecuta en una Pi y consume datos de AWS, configure un puente local de Mosquitto (más barato y rápido que HA → AWS directamente).

Sobre el coste

Publicar una vez por minuto por dispositivo supone unos 525 mil mensajes al año → ~2.60 USD/año/dispositivo en el nivel «Connectivity» + «Messaging» (2026, us-east-1). El coste de Timestream / Lambda es aparte.


Azure IoT Hub

Azure IoT Hub admite MQTT 3.1.1 sobre TLS con autenticación por token SAS (más sencillo que X.509 para casos de uso doméstico).

Aprovisionamiento

  1. Azure Portal → IoT Hub → Devices → New → ID de dispositivo rbamp-main, autenticación = Symmetric key.

  2. Guarde la cadena de conexión: HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=….

  3. Genere un token SAS (por ejemplo, con az iot hub generate-sas-token o cualquier SDK de Azure).

Certificado + configuración

Coloque la CA raíz de Azure (Baltimore CyberTrust Root o DigiCert Global Root G2) en 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);

Caducidad del token SAS

Los tokens SAS llevan una declaración expiry: la vida útil típica va de 1 hora a 1 año. Para un despliegue con ESP32, genere en la máquina de compilación un token de 1 año y grábelo en el firmware. Para una rotación automática desatendida, renuévelo periódicamente mediante el Device Provisioning Service (DPS) de Azure IoT Hub; eso está fuera del alcance del componente.

Procesamiento en el lado de la nube (Azure)

  • Enrute los mensajes a Event Hubs para una ingesta de alto rendimiento → Stream Analytics → paneles de Power BI.

  • Una alternativa más barata: mensajes → Storage Account (blob) → Synapse Serverless SQL para consultas ad hoc.


Google Cloud IoT (OBSOLETO desde 2023)

Google cerró Cloud IoT Core en 2023. Vías de migración:

  • Broker MQTT en Compute Engine (usted despliega Mosquitto en una VM) — el mismo patrón que en 07 · Integraciones caseras, sección de Home Assistant, pero apuntando a la IP pública de su VM.

  • HiveMQ Cloud / EMQX Cloud: brokers MQTT gestionados, ~$10-20/mes en niveles para aficionados.

  • Pub/Sub sobre HTTPS: publique directamente en un tema de Pub/Sub mediante la API REST (autenticación con una clave JSON de cuenta de servicio, incrustada en el ESP32).

Para Pub/Sub sobre HTTPS, véase la sección «Webhook genérico / REST» de abajo, sustituyendo el endpoint de publicación de Pub/Sub.


InfluxDB Cloud (TLSv1.3 + protocolo de línea)

InfluxDB Cloud (nivel Serverless) acepta line-protocol sobre HTTPS: la misma forma que la ruta OSS de 07 · Integraciones caseras, sección InfluxDB OSS, pero con cloud2.influxdata.com como host y un token de API para la autenticación.

Coloque la CA de cloud2.influxdata.com (DigiCert Global Root G2 o similar) en 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));

El nivel gratuito de InfluxDB Cloud (5 GB / retención de 30 días) cubre ~5000 puntos a una cadencia de un minuto al día, más que suficiente para uso doméstico.


Webhook / REST genérico

Publicación en cualquier endpoint HTTPS con una clave de API: funciona con webhooks de IFTTT, servicios personalizados en Flask / FastAPI, o cualquier función en la nube (AWS Lambda / Azure Functions / GCP Cloud Run) expuesta por 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));
    }
}
Seguridad

⚠ .skip_cert_common_name_check = false debe quedarse en false en producción. Durante el prototipado puede usar .use_global_ca_store = true (el binario no incluye una CA específica, lo que reduce la seguridad de TLS), pero NUNCA lo envíe a producción sin una CA explícita.

A un ritmo bajo (≤ una vez por minuto), la sobrecarga es aceptable. A ritmos más altos, agrupe los datos en el lado del ESP32 (acumule 10 minutos en un buffer circular y publique después un único JSON masivo) para no pagar un handshake TLS por cada solicitud.


Híbrido: almacenamiento local + sincronización con la nube

Para despliegues tolerantes a la desconexión: registre en SPIFFS una vez por minuto y envíe a la nube una vez por hora. Así sobreviven los cortes de WiFi sin perder datos.

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 */
}

El acumulador del componente rbamp_energy_wh(dev, 0) sigue contando durante toda la ventana sin conexión: no se pierde ningún dato mientras el ESP32 tenga alimentación. La partición SPIFFS storage se muestra en 06 · Ejemplos, escenario 8 (spiffs_logger).


Presupuesto de energía

Un handshake TLS es una operación costosa: ~3 s + ~30 kB de heap por conexión. Para registradores con deep sleep (vea 06 · Ejemplos, escenario 9):

  • Reutilice la sesión TLS si el intervalo de suspensión es < 24 h: el mbedtls de ESP-IDF admite la reanudación de sesión mediante la API mbedtls_ssl_get/set_session(). Esto reduce el handshake a ~500 ms.

  • Agrupe varias mediciones en SPIFFS local en un único POST masivo por despertar: el patrón de la sección «Híbrido» de arriba.

  • MQTT sobre TLS con sesión persistente (session.disable_clean_session = true en esp_mqtt_client_config_t): el broker recuerda sus suscripciones entre despertares, así que no necesita volver a publicar la configuración de descubrimiento.

Con un intervalo de despertar de 10 minutos en una celda Li-ion de 2000 mAh, espere unos ~3 meses de funcionamiento con WiFi + TLS, frente a unos ~6 meses con WiFi + MQTT sin cifrar (según el presupuesto del escenario 9).


Ver también

  • 06 · Ejemplos — los proyectos base sobre los que se construyen las integraciones en la nube (sobre todo el escenario 8 «spiffs_logger» para el enfoque híbrido)

  • 07 · Integraciones caseras — alternativas autoalojadas (Home Assistant / Node-RED / OpenHAB / InfluxDB OSS)

  • 10 · Solución de problemas: caídas de WiFi / depuración del handshake TLS / problemas de heap


Código fuente y incidencias: rb-amp/rbamp-esp-idf · esta página en el repositorio: docs/08_cloud_integrations.md (v1.7.3)