rbAmp
ES
Tienda
Docs
Actualizado · Editar en GitHub [Edit on 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 canales de observabilidad gestionados o sin servidor. Para cada plataforma: un sketch para ESP32 y lo que debe configurar en el lado de la nube.

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

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 ~30 kB de código + ~30 kB de heap para el handshake. AVR / ESP8266 no tienen RAM para TLS: para esas plataformas necesita un broker MQTT local que haga de proxy hacia la nube (Mosquitto → puente → AWS IoT).


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 un certificado y 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.

Sketch para ESP32

C++
#include 
#include 
#include 
#include 
#include 

static const char AWS_ENDPOINT[]  = "xxxxxx-ats.iot.eu-west-1.amazonaws.com";
static const char AWS_CLIENT_ID[] = "rbamp-main";

// Contents of AmazonRootCA1.pem, device.cert.pem, device.private.key
// in PROGMEM strings (saves RAM, places them in flash).
static const char AWS_ROOT_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
MIIDQTCC...
-----END CERTIFICATE-----
)EOF";
static const char DEV_CERT[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
MIIDWjCC...
-----END CERTIFICATE-----
)EOF";
static const char DEV_KEY[] PROGMEM = R"EOF(
-----BEGIN RSA PRIVATE KEY-----
MIIEowIB...
-----END RSA PRIVATE KEY-----
)EOF";

static RbAmp dev(Wire, 0x50);
static WiFiClientSecure tls;
static PubSubClient     mqtt(tls);

void setup() {
    Serial.begin(115200);
    WiFi.begin("ssid", "pass");
    while (WiFi.status() != WL_CONNECTED) delay(500);

    tls.setCACert(AWS_ROOT_CA);
    tls.setCertificate(DEV_CERT);
    tls.setPrivateKey(DEV_KEY);

    mqtt.setServer(AWS_ENDPOINT, 8883);
    mqtt.setKeepAlive(60);
    mqtt.connect(AWS_CLIENT_ID);

    Wire.begin();
    Wire.setClock(50000);
    while (!dev.begin()) delay(500);
}

void loop() {
    if (!mqtt.connected()) mqtt.connect(AWS_CLIENT_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 payload[256];
    snprintf(payload, sizeof(payload),
        "{\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f,\"freq\":%.1f}",
        dev.readVoltage(), snap.avg_p[0],
        dev.energy().wh(0), dev.readFrequency());
    mqtt.publish("rbamp/main/state", payload, false);
}

Procesamiento en la nube

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

  • Para paneles: 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

Con publicación una vez por minuto por dispositivo, AWS IoT da unos 525k mensajes al año → unos $2.60/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 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).

Boceto ESP32 (token SAS de larga duración)

C++
#include 
#include 
#include 
#include 

static const char AZ_HOST[]      = "foo.azure-devices.net";
static const char AZ_USER[]      = "foo.azure-devices.net/rbamp-main/?api-version=2021-04-12";
static const char AZ_SAS[]       = "SharedAccessSignature sr=foo.azure-devices.net%2Fdevices%2Frbamp-main&sig=…&se=…";
static const char AZ_DEVICE_ID[] = "rbamp-main";

// Root CA for Azure IoT Hub (Baltimore CyberTrust Root or DigiCert Global Root)
static const char AZ_ROOT_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
)EOF";

static RbAmp dev(Wire, 0x50);
static WiFiClientSecure tls;
static PubSubClient     mqtt(tls);

void setup() {
    // ...WiFi up...
    tls.setCACert(AZ_ROOT_CA);
    mqtt.setServer(AZ_HOST, 8883);
    mqtt.setKeepAlive(60);
    mqtt.connect(AZ_DEVICE_ID, AZ_USER, AZ_SAS);

    Wire.begin(); Wire.setClock(50000);
    while (!dev.begin()) delay(500);
}

void loop() {
    if (!mqtt.connected()) mqtt.connect(AZ_DEVICE_ID, AZ_USER, AZ_SAS);
    mqtt.loop();

    static uint32_t last = 0;
    if (millis() - last < 60000) { delay(50); return; }
    last = millis();

    RbAmpPeriodSnapshot snap;
    if (!dev.readPeriodSnapshot(snap)) return;

    char payload[256];
    snprintf(payload, sizeof(payload),
        "{\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f}",
        dev.readVoltage(), snap.avg_p[0], dev.energy().wh(0));

    // Azure D2C topic format:
    char topic[128];
    snprintf(topic, sizeof(topic), "devices/%s/messages/events/", AZ_DEVICE_ID);
    mqtt.publish(topic, payload, false);
}

Caducidad del token SAS

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

Procesamiento en 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 de sketch que en 07 · Integraciones DIY, sección 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 de cuenta de servicio grabada 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 protocolo de línea sobre HTTPS: la misma forma que la ruta OSS de 07 · Integraciones DIY, sección de InfluxDB OSS, pero con cloud2.influxdata.com como host y un token de API para la autenticación.

C++
#include 
#include 

#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"
// CA for cloud2.influxdata.com (DigiCert Global Root G2 or similar)
static const char INFLUX_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
)EOF";

void push_influx_cloud(float u, float p, double e_wh) {
    WiFiClientSecure client;
    client.setCACert(INFLUX_CA);

    HTTPClient http;
    http.begin(client, INFLUX_URL);
    http.addHeader("Authorization", "Token " INFLUX_TOKEN);
    http.addHeader("Content-Type", "text/plain");

    char body[256];
    snprintf(body, sizeof(body),
        "rbamp,device=main voltage=%.1f,power=%.1f,energy=%.3f",
        u, p, e_wh);
    int code = http.POST(body);
    http.end();
    if (code != 204) Serial.printf("influx HTTP %d\n", code);
}

// In your 60-second loop, after readPeriodSnapshot():
push_influx_cloud(dev.readVoltage(), snap.avg_p[0], dev.energy().wh(0));

El nivel gratuito de InfluxDB Cloud (5 GB / retención de 30 días) cubre unos 5000 puntos a una cadencia de un minuto al día: 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 
#include 

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

// Attach the server CA for TLS, or use setInsecure()
// for prototyping only. NEVER ship setInsecure()
// to production — it disables certificate validation.
static const char SERVER_CA[] PROGMEM = "...";

void push_webhook(float u, float p, double e_wh) {
    WiFiClientSecure client;
    client.setCACert(SERVER_CA);

    HTTPClient http;
    http.begin(client, WEBHOOK_URL);
    http.addHeader("Authorization", API_KEY);
    http.addHeader("Content-Type", "application/json");

    char body[256];
    snprintf(body, sizeof(body),
        "{\"ts\":%lu,\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f}",
        (unsigned long)(millis() / 1000), u, p, e_wh);
    int code = http.POST(body);
    http.end();
    if (code < 200 || code >= 300) {
        Serial.printf("webhook HTTP %d\n", code);
    }
}

A una frecuencia baja (≤ una vez por minuto) la sobrecarga es aceptable. A frecuencias mayores, agrupe los datos en el lado del ESP32 (acumule 10 minutos en un búfer circular y publique un único JSON masivo), para no pagar un handshake TLS por petición.


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

Para despliegues tolerantes a la desconexión: registre en SPIFFS / una tarjeta SD una vez por minuto y envíe a la nube una vez por hora. Así se sobrevive a las caídas de WiFi sin perder datos.

C++
#include 

void log_to_sd(RbAmpPeriodSnapshot& snap) {
    File f = SD.open("/log.csv", FILE_APPEND);
    if (!f) return;
    f.printf("%lu,%.1f,%.1f,%.3f\n",
             (unsigned long)(millis() / 1000),
             dev.readVoltage(),
             snap.avg_p[0],
             dev.energy().wh(0));
    f.close();
}

void sync_to_cloud_if_due() {
    static uint32_t last_sync = 0;
    if (millis() - last_sync < 3600000UL) return;   // once an hour
    last_sync = millis();

    File f = SD.open("/log.csv", FILE_READ);
    if (!f) return;
    while (f.available()) {
        String line = f.readStringUntil('\n');
        push_webhook_line(line.c_str());
    }
    f.close();
    // Optional: archive to /log_pushed.csv + truncate /log.csv
}

El acumulador de la biblioteca dev.energy().wh(0) sigue contando durante todo el tiempo que dure la ventana sin conexión: no se pierden datos mientras el ESP32 permanezca alimentado.


Presupuesto de energía

El handshake TLS es una operación costosa: ~3 s + ~30 kB de heap por conexión. Para los registradores con deep sleep (véase el escenario del registrador con deep sleep alimentado por batería en 06 · Ejemplos):

  • Reutilice la sesión TLS si el intervalo de suspensión es < 24 h (la mayoría de los brokers gestionados admiten la reanudación de sesión).

  • Agrupe varias mediciones en una tarjeta SD local en un único POST masivo por despertar.

  • Use MQTT sobre TLS con sesión persistente (cleansession=0) para no volver a publicar la configuración de descubrimiento en cada despertar.

Con un intervalo de despertar de 10 minutos en una batería Li-ion de 2000 mAh, cabe esperar ~3 meses de funcionamiento con WiFi + TLS, frente a ~6 meses con WiFi + MQTT sin cifrar.



Fuente y incidencias: rb-amp/rbamp-arduino · esta página en el repositorio: docs/08_cloud_integrations.md (v1.6.2)