rbAmp
IT
Negozio
Docs
Aggiornato · Modifica su GitHub (Edit on GitHub)

08 · Integrazioni cloud

Come inviare le letture RbAmp alle piattaforme cloud — AWS IoT Core, Azure IoT Hub, Google Cloud e pipeline di osservabilità serverless / gestite. Per ciascuna piattaforma: uno sketch ESP32 e ciò che deve configurare lato cloud.

Piattaforme DIY self-hosted (Home Assistant, Node-RED, InfluxDB OSS) — vedere 07 · Integrazioni fai-da-te.

Cloud Trasporto Autenticazione Latenza Costo
AWS IoT Core MQTT/TLS Certificato X.509 basso $5/M messaggi
Azure IoT Hub MQTT/TLS o AMQP Token SAS basso $0.40-2/M messaggi
Google Cloud IoT (deprecato nel 2023) MQTT/TLS JWT — n/a
InfluxDB Cloud Line protocol HTTPS Token API medio $250/mo+
Webhook generico / REST HTTPS POST chiave API alta dipende
Sicurezza

⚠ TLS su ESP32. Qualsiasi trasporto cloud su TLS aggiunge ~30 kB di codice + ~30 kB di heap per l'handshake. AVR / ESP8266 non hanno la RAM per TLS — per quelle piattaforme serve un broker MQTT locale che faccia da proxy verso il cloud (Mosquitto → bridge → AWS IoT).


AWS IoT Core

AWS IoT Core usa mutual-TLS con un certificato X.509 del dispositivo.

Provisioning

  1. Console AWS → IoT Core → Manage → Things → Create things → Single thing.
  2. Generare un certificato + chiavi; scaricare device.cert.pem, device.private.key, AmazonRootCA1.pem.

  3. Colleghi una policy che consenta iot:Connect, iot:Publish su arn:aws:iot:::topic/rbamp/+/state.

  4. Si noti l'endpoint AWS IoT: xxxxxx-ats.iot..amazonaws.com:8883.

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

Elaborazione lato cloud

  • Creare una IoT Rule: SELECT *, topic(2) AS device FROM 'rbamp/+/state' → Kinesis Data Firehose o Lambda per la memorizzazione.

  • Per le dashboard — AWS IoT SiteWise (storico industriale) o Timestream (database di serie temporali) → QuickSight.

  • Se Home Assistant gira su un Pi e consuma dati da AWS, configuri un bridge Mosquitto locale (più economico e più veloce di HA → AWS direttamente).

Sul costo

Pubblicando una volta al minuto per dispositivo, AWS IoT produce ~525k messaggi all'anno → ~$2.60/anno/dispositivo nel livello "Connectivity" + "Messaging" (2026, us-east-1). Il costo di Timestream / Lambda è a parte.


Azure IoT Hub

Azure IoT Hub supporta MQTT 3.1.1 su TLS con autenticazione a token SAS (più semplice di X.509 per uso domestico).

Provisioning

  1. Portale Azure → IoT Hub → Dispositivi → Nuovo → ID dispositivo rbamp-main, autenticazione = Chiave simmetrica.

  2. Salvare la stringa di connessione: HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=….

  3. Generare un token SAS (ad esempio tramite az iot hub generate-sas-token o un SDK Azure qualsiasi).

Sketch ESP32 (token SAS a lunga durata)

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

Scadenza del token SAS

I token SAS hanno una dichiarazione expiry — la durata tipica va da 1 ora a 1 anno. Per un dispositivo ESP32, generi un token di 1 anno sulla macchina di build e lo scriva nel firmware. Per una rotazione automatica senza presidio, lo aggiorni periodicamente tramite il Device Provisioning Service (DPS) di Azure IoT Hub; ciò esula dallo scopo della libreria.

Elaborazione lato cloud (Azure)

  • Instradi i messaggi verso Event Hubs per un'acquisizione ad alto throughput → Stream Analytics → dashboard di Power BI.

  • Un'alternativa più economica: messaggi → Storage Account (blob) → Synapse Serverless SQL per le query ad hoc.


Google Cloud IoT (DEPRECATO 2023)

Google ha chiuso Cloud IoT Core nel 2023. Percorsi di migrazione:

  • Broker MQTT su Compute Engine (lei stesso distribuisce Mosquitto su una VM) — lo stesso schema di sketch di 07 · Integrazioni fai-da-te, sezione Home Assistant, ma puntato all'IP pubblico della sua VM.

  • HiveMQ Cloud / EMQX Cloud — broker MQTT gestiti, ~$10-20/mese nei piani per hobbisti.

  • Pub/Sub su HTTPS — pubblicare direttamente su un topic Pub/Sub tramite la REST API (autenticazione con una chiave dell'account di servizio inserita nell'ESP32).

Per Pub/Sub su HTTPS vedi la sezione "Webhook generico / REST" qui sotto, sostituendo l'endpoint di pubblicazione di Pub/Sub.


InfluxDB Cloud (TLSv1.3 + line protocol)

InfluxDB Cloud (livello Serverless) accetta il line-protocol su HTTPS — la stessa forma del percorso OSS in 07 · Integrazioni fai-da-te, sezione InfluxDB OSS, ma con cloud2.influxdata.com come host e un token API per l'autenticazione.

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

Il livello gratuito InfluxDB Cloud (5 GB / conservazione di 30 giorni) copre ~5000 punti con cadenza di un minuto al giorno — ampio per uso domestico.


Webhook / REST generico

Pubblicazione su qualsiasi endpoint HTTPS con una chiave API — funziona con webhook IFTTT, servizi Flask / FastAPI personalizzati o qualsiasi funzione cloud (AWS Lambda / Azure Functions / GCP Cloud Run) esposta via 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 frequenza bassa (≤ una volta al minuto) il sovraccarico è accettabile. A frequenze più alte, raggruppi i dati lato ESP32 (accumuli 10 minuti in un buffer circolare, pubblichi come un unico JSON di massa) così da non pagare un handshake TLS per ogni richiesta.


Ibrido: archiviazione locale + sincronizzazione con il cloud

Per le distribuzioni tolleranti alle interruzioni: registri su SPIFFS / una scheda SD una volta al minuto e invii al cloud una volta all'ora. Così si sopravvive alle interruzioni del WiFi senza perdere dati.

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
}

L'accumulatore della libreria dev.energy().wh(0) continua a contare per tutto il tempo in cui dura la finestra offline — nessun dato viene perso finché l'ESP32 resta alimentato.


Bilancio energetico

L'handshake TLS è un'operazione costosa: ~3 s + ~30 kB di heap per connessione. Per i logger in deep sleep (vedi lo scenario del logger a batteria in deep sleep in 06 · Esempi):

  • Riutilizzi la sessione TLS se l'intervallo di sospensione è < 24 h (la maggior parte dei broker gestiti supporta la ripresa della sessione).

  • Raccoglia più misure su una scheda SD locale in un unico POST di massa per risveglio.

  • Usi MQTT su TLS con una sessione persistente (cleansession=0) così da non ripubblicare la configurazione di discovery a ogni risveglio.

Con un intervallo di risveglio di 10 minuti su una cella Li-ion da 2000 mAh, ci si attendono ~3 mesi di funzionamento con WiFi + TLS, contro ~6 mesi con WiFi + MQTT semplice.



Sorgente e segnalazioni: rb-amp/rbamp-arduino · questa pagina nel repository: docs/08_cloud_integrations.md (v1.6.2)