Esempi
Guida agli sketch inclusi in examples/ più scenari composti. La maggior parte degli esempi numerati qui sotto ha il codice corrispondente in examples/ — apra gli sketch reali nell'IDE Arduino per il sorgente completo.
| # | Titolo | Difficoltà | File sorgente |
|---|---|---|---|
| 1 | Lettura rapida | minimo | 01_QuickRead.ino |
| 2 | Contatore da 60 secondi su OLED | basso | 02_PeriodEnergyOLED.ino |
| 3 | Monitor multimodulo (3 dispositivi) | basso | 03_MultiModuleBroadcast.ino |
| 4 | UI3 per elettrodomestico + MQTT | medio | 04_UI3PerChannelMQTT.ino |
| 5 | Contabilità bidirezionale lato master | medio | 06_BidirectionalEnergy.ino |
| 6 | Bilancio energetico domestico | alta | (composed) |
| 7 | Rilevamento eventi (EMA) | medio | (composed) |
| 8 | Monitor autonomo da banco di 12 ore | medio | (codice in questo capitolo) |
| 9 | Logger a batteria in deep sleep | medio | 07_DeepSleepLogger.ino |
| 10 | Cambio dell'indirizzo I2C | basso | 05_AddressChange.ino |
| 11 | Uno sketch, entrambe le linee di moduli (BASIC + STD) | medio | 11_StdLine.ino |
Scenario 1 — Lettura rapida
Obiettivo: stampare U / I / P / PF / freq una volta al secondo. Il "hello world" appena scritto in Avvio rapido, ma usando dev.readAll(s) per una lettura a blocco RT completa in un colpo solo invece delle singole chiamate alle proprietà.
#include
#include
static RbAmp dev(Wire, 0x50);
void setup() {
Serial.begin(115200);
while (!Serial && millis() < 3000) {}
Wire.begin();
dev.setLogStream(&Serial);
while (!dev.begin()) {
Serial.print(F("begin: ")); Serial.println(RbAmp::errorString(dev.lastError()));
delay(1000);
}
}
void loop() {
RbAmpSnapshot s;
if (!dev.readAll(s)) {
Serial.print(F("read fail: ")); Serial.println(RbAmp::errorString(dev.lastError()));
delay(1000); return;
}
Serial.print(F("U=")); Serial.print(s.voltage, 1); Serial.print(F("V "));
Serial.print(F("f=")); Serial.print(s.frequency, 1); Serial.print(F("Hz "));
for (uint8_t ch = 0; ch < s.channels; ++ch) {
Serial.print(F("I")); Serial.print(ch); Serial.print(F("="));
Serial.print(s.current[ch], 2); Serial.print(F("A "));
Serial.print(F("P")); Serial.print(ch); Serial.print(F("="));
Serial.print(s.power[ch], 1); Serial.print(F("W "));
Serial.print(F("PF")); Serial.print(ch); Serial.print(F("="));
Serial.print(s.power_factor[ch], 2); Serial.print(F(" "));
}
Serial.println();
delay(1000);
}
Cosa passa sul filo: readAll() su un UI3 emette 53 transazioni da un byte (13 float × 4 byte + 1 byte di frequenza). A 100 kHz con margine di 3 tentativi di ripetizione, ~12-15 ms in totale. Passare alle letture per chiamata (dev.voltage, dev.current[ch]) se serve solo un sottoinsieme.
Scenario 2 — Contatore da 60 secondi su OLED
Contatore Wh aggiornato una volta al minuto su un OLED SSD1306 da 128×64 che condivide il bus I2C (OLED a 0x3C). Meccanismo chiave della libreria: readPeriodSnapshot() esegue snapshot + assestamento + controllo di validità + lettura + tick Wh in una sola chiamata.
#include
#include
#include
#include
static Adafruit_SSD1306 oled(128, 64, &Wire, -1);
static RbAmp dev(Wire, 0x50);
static uint32_t next_latch_ms = 0;
static uint32_t snapshots_ok = 0, snapshots_bad = 0;
void setup() {
Serial.begin(115200);
Wire.begin();
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(1000); }
next_latch_ms = millis() + 60000;
}
void loop() {
if (millis() < next_latch_ms) { delay(50); return; }
next_latch_ms = millis() + 60000;
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) { snapshots_bad++; return; }
snapshots_ok++;
oled.clearDisplay();
oled.setTextColor(SSD1306_WHITE);
oled.setCursor(0, 0); oled.setTextSize(1); oled.println(F("rbAmp Energy Meter"));
oled.setCursor(0, 16); oled.setTextSize(2); oled.print(snap.avg_p[0], 1); oled.println(F(" W"));
oled.setTextSize(1);
oled.print(F("Wh:")); oled.println(dev.energy().wh(0), 4);
oled.print(F("ok=")); oled.print(snapshots_ok);
oled.print(F(" bad=")); oled.println(snapshots_bad);
oled.display();
}
Sketch completo in 02_PeriodEnergyOLED.ino.
Gestione dello snapshot non aggiornato: readPeriodSnapshot() restituisce false con lastError() == RB_ERR_STALE se REG_V03_PERIOD_VALID == 0. La libreria registra comunque internamente il timestamp di orologio del master — questo impedisce che lo snapshot successivo riuscito conti due volte il Wh su un intervallo pari a 2× il periodo.
Scenario 3 — Monitor multi-modulo
Tre moduli rbAmp sul bus a 0x50 / 0x51 / 0x52. Ognuno deve avere un indirizzo I²C unico — usi lo scenario 10 per assegnare gli indirizzi durante l'installazione.
ogni modulo che supporta lo snapshot General-Call e ha scelto di aderire (enableGc(true), persistente) acquisisce lo stesso periodo di rete su un unico frame all-call — RbAmp::broadcastLatchGroup(Wire, 0x00, tick). Lo scostamento della flotta è < 10 µs, quindi le potenze dei singoli moduli si sommano in modo coerente. Ogni modulo marca il proprio snapshot con il tick del broadcast; rileggerlo con readGcTick() per individuare un modulo che ha perso il frame. (Sul firmware v1.0/v1.1 lo snapshot General-Call non era disponibile e questo sketch ripiegava su snapshot sequenziali per dispositivo — conservati nella cronologia dei commenti del file per i moduli più vecchi.)
#include
#include
static RbAmp T0(Wire, 0x50);
static RbAmp T1(Wire, 0x51);
static RbAmp T2(Wire, 0x52);
static RbAmp* modules[] = { &T0, &T1, &T2 };
static const uint8_t N = sizeof(modules) / sizeof(modules[0]);
static uint16_t g_tick = 0;
void setup() {
Serial.begin(115200);
Wire.begin();
Wire.setClock(50000); // 50 kHz on ESP32 / 100 kHz on non-ESP32 masters
for (uint8_t i = 0; i < N; ++i) {
modules[i]->begin();
modules[i]->enableGc(true); // opt into General-Call snapshot (persisted)
}
}
void loop() {
g_tick++;
RbAmp::broadcastLatchGroup(Wire, /*group=*/0x00, g_tick); // 0x00 = all-call
delay(50); // single shared settle for the whole bus
for (uint8_t i = 0; i < N; ++i) {
RbAmpPeriodSnapshot snap;
if (modules[i]->readPeriodSnapshot(snap, /*settle_ms=*/0, /*skip_latch=*/true)) {
uint16_t tick;
bool synced = modules[i]->readGcTick(tick) && tick == g_tick;
Serial.print(F("T")); Serial.print(i);
Serial.print(F(" P=")); Serial.print(snap.avg_p[0], 0);
Serial.print(F("W Wh=")); Serial.print(modules[i]->energy().wh(0), 3);
Serial.println(synced ? F(" [sync]") : F(" [MISSED FRAME]"));
}
}
delay(60000);
}
Sketch completo (con sonda di scansione del bus + segnalazione errori) in 03_MultiModuleBroadcast.ino.
Scenario 4 — UI3 per elettrodomestico + MQTT
Un modulo UI3 con tre pinze su tre carichi. Contatori Wh indipendenti per canale, pubblicati su MQTT una volta al minuto. Dimostra che dev.energy().wh(ch) funziona su ogni canale in modo indipendente — senza bisogno di un array manuale total_wh[3].
#include
#include
#include
#include
static RbAmp dev(Wire, 0x50);
static const char* CH_NAMES[3] = {"main", "heatpump", "lights"};
static WiFiClient espClient;
static PubSubClient mqtt(espClient);
void publish_channel(const char* name, float avg_p, double e_wh) {
char topic[64], payload[96];
snprintf(topic, sizeof(topic), "rbamp/%s/state", name);
snprintf(payload, sizeof(payload), "{\"power\":%.1f,\"energy\":%.4f}", avg_p, e_wh);
mqtt.publish(topic, payload, true);
}
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.connect("rbamp-ui3");
Wire.begin();
Wire.setClock(50000); // reduced bus clock on ESP32
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
}
void loop() {
if (!mqtt.connected()) mqtt.connect("rbamp-ui3");
mqtt.loop();
static uint32_t last_period = 0;
if (last_period == 0) last_period = millis();
if (millis() - last_period < 60000) { delay(50); return; }
last_period = millis();
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) return;
for (uint8_t ch = 0; ch < dev.channels(); ++ch) {
publish_channel(CH_NAMES[ch], snap.avg_p[ch], dev.energy().wh(ch));
}
}
Sketch completo in 04_UI3PerChannelMQTT.ino. Per l'auto-discovery MQTT di HA su questa base, vedere Integrazioni fai-da-te.
Scenario 5 — Contabilizzazione bidirezionale lato master
Separare la potenza RT con segno in secchi lordi di consumo / esportazione. Da usare sui moduli di livello BASIC dove l'accumulatore di periodo azzera i valori negativi — campionare dev.readPower(0) a 10 Hz lato master.
#include
#include
static RbAmp dev(Wire, 0x50);
static double consume_wh = 0.0;
static double export_wh = 0.0;
static uint32_t last_sample_ms = 0;
void setup() {
Serial.begin(115200);
Wire.begin();
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
last_sample_ms = millis();
}
void loop() {
if (millis() - last_sample_ms < 100) { delay(5); return; } // 10 Hz — matches RT cadence
const uint32_t now_ms = millis();
const uint32_t dt_ms = now_ms - last_sample_ms;
last_sample_ms = now_ms;
const float p_w = dev.readPower(0);
if (isnan(p_w)) return;
const double dwh = (double)p_w * dt_ms / 3600000.0;
if (p_w >= 0.0f) consume_wh += dwh;
else export_wh += -dwh;
static uint32_t next_print = 0;
if (millis() >= next_print) {
next_print = millis() + 200;
Serial.print(F("P=")); Serial.print(p_w, 1);
Serial.print(F("W cons=")); Serial.print(consume_wh, 4);
Serial.print(F("Wh exp=")); Serial.print(export_wh, 4);
Serial.print(F("Wh net=")); Serial.print(consume_wh - export_wh, 4);
Serial.println(F("Wh"));
}
}
Sketch completo in 06_BidirectionalEnergy.ino. Su un modulo STANDARD (STD), dev.energy().wh(0) fornisce già il saldo netto con segno — le serve questa ripartizione lato master solo per la rendicontazione separata di consumo lordo ed esportazione lorda.
Scenario 6 — Bilancio energetico domestico
Tre moduli: rete (bidir, STANDARD (STD)) + solare (solo generazione, BASIC OK)
- carichi (UI3 BASIC per elettrodomestico). Dashboard domestica complessiva pubblicata ogni 60 s.
#include
#include
#include
#include
static RbAmp mains(Wire, 0x50); // bidirectional
static RbAmp solar(Wire, 0x51); // generation only
static RbAmp loads(Wire, 0x52); // UI3
static RbAmp* mods[] = { &mains, &solar, &loads };
static WiFiClient espClient;
static PubSubClient mqtt(espClient);
void setup() {
Serial.begin(115200);
WiFi.begin("ssid", "pass");
while (WiFi.status() != WL_CONNECTED) delay(500);
mqtt.setServer("192.168.1.10", 1883); mqtt.connect("home-balance");
Wire.begin();
Wire.setClock(50000); // 50 kHz on ESP32 (100 kHz on non-ESP32 masters)
for (auto m : mods) { while (!m->begin()) delay(500); m->enableGc(true); }
}
void loop() {
delay(60000);
static uint16_t g_tick = 0;
RbAmp::broadcastLatchGroup(Wire, /*group=*/0x00, ++g_tick); // coherent all-call snapshot
delay(50);
RbAmpPeriodSnapshot sm, ss, sl;
mains.readPeriodSnapshot(sm, 0, true);
solar.readPeriodSnapshot(ss, 0, true);
loads.readPeriodSnapshot(sl, 0, true);
char payload[512];
snprintf(payload, sizeof(payload),
"{\"mains\":%.3f,\"solar\":%.3f,\"hp\":%.3f,\"ac\":%.3f,\"ev\":%.3f}",
mains.energy().wh(0),
solar.energy().wh(0),
loads.energy().wh(0),
loads.energy().wh(1),
loads.energy().wh(2));
mqtt.publish("home/energy/balance", payload, true);
mqtt.loop();
}
Per la separazione esplicita consumo/esportazione sul modulo di rete, combinare con il pattern dello scenario 5 (eseguire un ciclo separato a 10 Hz su mains.readPower(0)).
Scenario 7 — Rilevamento eventi (EMA)
Su ogni finestra RT da 100 ms, confronti P con una media mobile esponenziale. Registri le deviazioni significative (microonde / bollitore).
#include
#include
static RbAmp dev(Wire, 0x50);
static float p_ema = 0.0f;
static const float EMA_ALPHA = 0.05f;
static const float EVENT_THRESHOLD_W = 200.0f;
void setup() {
Serial.begin(115200);
Wire.begin();
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
p_ema = dev.readPower(0); // seed EMA so first read isn't a spurious event
if (isnan(p_ema)) p_ema = 0.0f;
}
void loop() {
delay(200);
const float p = dev.readPower(0);
if (isnan(p)) return;
const float delta = p - p_ema;
p_ema = (1.0f - EMA_ALPHA) * p_ema + EMA_ALPHA * p;
if (fabsf(delta) > EVENT_THRESHOLD_W) {
Serial.print(millis()); Serial.print(F(" "));
Serial.print(delta > 0 ? F("TURN_ON ") : F("TURN_OFF "));
Serial.print(F("delta=")); Serial.print(delta, 0); Serial.print(F("W "));
Serial.print(F("P=")); Serial.print(p, 0); Serial.print(F("W "));
Serial.print(F("EMA=")); Serial.println(p_ema, 0);
}
}
Scenario composto — nessun file di esempio dedicato. Combini con la pubblicazione MQTT dello Scenario 4 per l'automazione degli eventi lato HA, oppure registri su SD con Adafruit_SD per il tracciamento offline degli eventi.
Scenario 8 — Monitor autonomo da banco di 12 ore
Banco di validazione di lunga durata — esegue la libreria su un DUT reale per 12-15 ore sotto un carico denso per ciclo, emette una riga CSV ogni 5 minuti con contatori diagnostici completi. È la ricetta di riferimento usata per qualificare il firmware v1.1 sul master di riferimento della libreria Arduino.
Caratteristiche principali:
-
Override di
RBAMP_NACK_RETRY_ATTEMPTS=5— definisca PRIMA dell'include per regolare i tentativi con carichi densi (≥10 letture di un byte per ciclo). Il valore predefinito di 3 basta per l'interrogazione ESPHome a 60 s; SoakMonitor legge ~45 byte per ciclo e richiede il margine extra. -
dev.rawTopology()— lettura diretta sul filo di REG_TOPOLOGY (0x24) per il rilevamento della v1.1. Restituisce 1/2/3 sulla v1.1,0x00sulla v1.0,0xFFin caso di errore I²C. -
dev.retryExhaustionCount()+dev.sanityRejectCount()— entrambi devono restare a 0 per una prova di 12 h superata.
Scheletro per ciclo:
#define RBAMP_NACK_RETRY_ATTEMPTS 5
#include
#include
RbAmp dev(Wire, 0x50);
void emitCycle() {
const float u = dev.readVoltage();
float i[3]={NAN,NAN,NAN}, p[3]={NAN,NAN,NAN}, pf[3]={NAN,NAN,NAN};
for (uint8_t c = 0; c < dev.channels(); c++) {
i[c] = dev.readCurrent(c);
p[c] = dev.readPower(c);
pf[c] = dev.readPowerFactor(c);
}
const float freq = dev.readFrequency();
RbAmpPeriodSnapshot snap;
const bool snap_ok = dev.readPeriodSnapshot(snap, 60);
/* CSV row (shortened) */
Serial.printf("%lu,%.3f,%.4f,%.3f,%.4f,%.1f,%.4f,%lu,%lu,%.6f,%lu,%lu,%u\n",
millis(), u, i[0], p[0], pf[0], freq,
snap.avg_p[0], snap.latch_ms, snap.master_dt_ms,
dev.energy().wh(0),
dev.retryExhaustionCount(),
dev.sanityRejectCount(),
snap_ok ? 1 : 0);
}
void setup() {
Serial.begin(115200);
Wire.begin(21, 22); Wire.setClock(50000);
while (!dev.begin()) delay(500);
dev.resetCounters();
emitCycle();
}
void loop() {
static uint32_t next_ms = 5UL * 60UL * 1000UL;
if (millis() >= next_ms) { emitCycle(); next_ms += 5UL * 60UL * 1000UL; }
delay(100);
}
Lo sketch è costruito dai frammenti di questo scenario. Eseguire con arduino-cli monitor -p COM3 -c baudrate=115200 > soak.csv e lasciare in funzione per 12-15 h senza sorveglianza. Criteri di accettazione: retry_exhaust == 0, sanity_reject == 0, period_ok / period_total ≥ 99 %, Wh monotono.
Scenario 9 — Logger a batteria in deep sleep
L'ESP32 si risveglia ogni 10 minuti, prende uno snapshot di periodo, pubblica via WiFi+MQTT, va in deep-sleep. L'energia persiste durante il sonno tramite la memoria RTC. L'accumulatore della libreria è disattivato — il master gestisce la persistenza dei Wh.
Scheletro rilevante per la libreria:
#include
#include
#include "esp_sleep.h"
RTC_DATA_ATTR uint32_t rtc_magic = 0;
RTC_DATA_ATTR double rtc_total_wh = 0;
RTC_DATA_ATTR bool rtc_primer_done = false;
void setup() {
Serial.begin(115200);
Wire.begin();
RbAmp dev(Wire, 0x50);
if (rtc_magic != 0xCAFEFEED) {
rtc_magic = 0xCAFEFEED; rtc_total_wh = 0; rtc_primer_done = false;
}
dev.begin();
dev.energy().disable(); // master owns Wh
if (!rtc_primer_done) {
dev.latchPeriod();
rtc_primer_done = true;
esp_sleep_enable_timer_wakeup(10ULL * 60ULL * 1000000ULL);
esp_deep_sleep_start();
}
RbAmpPeriodSnapshot snap;
if (dev.readPeriodSnapshot(snap)) {
// master_dt_ms measures actual wake-to-wake interval
rtc_total_wh += (double)snap.avg_p[0] * snap.master_dt_ms / 3600000.0;
publish_via_wifi(snap.avg_p[0], rtc_total_wh, snap.master_dt_ms);
}
esp_sleep_enable_timer_wakeup(10ULL * 60ULL * 1000000ULL);
esp_deep_sleep_start();
}
void loop() {}
Sketch completo (con configurazione WiFi, pubblicazione MQTT, guardie con marcatore magico in RTC) in 07_DeepSleepLogger.ino.
Budget energetico (ESP32-WROOM, intervallo di risveglio di 10 minuti):
- Durata del risveglio: ~3 s (WiFi + MQTT + I2C)
- Corrente di risveglio: ~80 mA media → ~0.07 mAh per risveglio
- Corrente di sleep: ~10 µA (RTC + domini conservati)
- ~10 mAh/giorno in totale → una Li-ion da 2000 mAh dura ~6 mesi
Scenario 10 — Cambio dell'indirizzo I2C
Riassegni l'indirizzo I²C di uno slave rbAmp da 0x50 a 0x51. Usato una volta per modulo quando si costruisce un'installazione multimodulo. Scolleghi gli altri moduli durante questa operazione per evitare collisioni sul bus.
Con il firmware attuale (v1.3+), cambiare l'indirizzo I²C di un modulo non richiede alcuna modalità speciale, ponticello o strumento di fabbrica — si predispone il nuovo indirizzo, si arma il cambio e lo si conferma (una sequenza a due fasi con magic, in modo che un indirizzo non possa cambiare per errore), e il modulo si riavvia al nuovo indirizzo. La libreria impone un protocollo in due passi — prepareAddressChange() arma, commitAddressChange() scrive entro una finestra di 5 secondi.
#include
#include
static const uint8_t CURRENT_ADDR = 0x50;
static const uint8_t NEW_ADDR = 0x51;
static RbAmp dev(Wire, CURRENT_ADDR);
void setup() {
Serial.begin(115200);
Wire.begin();
dev.setLogStream(&Serial);
if (!dev.begin()) {
Serial.println(F("device not found")); return;
}
Serial.print(F("fw=0x")); Serial.println(dev.firmwareVersion(), HEX);
// Step 1: arm the change (no special mode needed on firmware v1.3+).
if (!dev.prepareAddressChange(NEW_ADDR)) {
Serial.print(F("prepare: ")); Serial.println(RbAmp::errorString(dev.lastError()));
if (dev.lastError() == rbamp::RB_ERR_MODE) {
Serial.println(F("Module firmware is older than v1.3 - update to v1.3+ for the no-mode two-phase path."));
}
return;
}
delay(1000);
// Step 2: commit — writes 0x30, CMD_SAVE_GAINS (700 ms), CMD_RESET (100 ms).
if (!dev.commitAddressChange()) {
Serial.print(F("commit: ")); Serial.println(RbAmp::errorString(dev.lastError()));
return;
}
Serial.print(F("device now at 0x")); Serial.println(dev.address(), HEX);
if (dev.probe()) Serial.println(F("verified"));
}
void loop() { delay(60000); }
Sketch completo in 05_AddressChange.ino. Se la finestra di armamento di 5 secondi scade prima del commit, la libreria restituisce false con lastError() == RB_ERR_TIMEOUT e azzera il flag di armamento — occorre richiamare prepareAddressChange(). Questo evita errori di battitura che renderebbero il dispositivo inutilizzabile con una sola chiamata sbagliata.
Scenario 11 — Uno sketch, entrambe le linee di moduli
L'esempio 11_StdLine mostra che uno sketch serve sia i moduli BASIC sia quelli STANDARD (STD). begin() rileva la linea; le letture comuni (readVoltage(), readCurrent(), readPower(), readPowerFactor(), readFrequency()) funzionano su entrambi, e gli extra solo-STD — potenza reattiva e apparente, letture a blocchi per canale (stdReadChannel()), contatori di salute (stdReadHealth()) e i banchi di snapshot per periodo — stanno dietro un controllo line():
if (dev.line() == RbAmpLine::Std) {
RbAmpStdChannel c;
if (dev.stdReadChannel(0, c)) {
Serial.print(F("Q0=")); Serial.print(c.q, 1);
Serial.print(F(" var S0=")); Serial.println(c.s, 1);
}
} else {
// BASIC: reactive power is not exposed by this library
}
Su un modulo BASIC le chiamate std* restituiscono RB_ERR_NOT_IMPLEMENTED. La descrizione chiamata per chiamata è in 09 · Riferimento API § API della linea STD.
Tabella di confronto
| # | LOC | Bus I2C | Periodo? | DRDY? | MQTT? | Persistenza |
|---|---|---|---|---|---|---|
| 1 | ~30 | condiviso | no | no | no | nessuno |
| 2 | ~50 | condiviso con OLED | sì | no | no | RAM |
| 3 | ~50 | condiviso tra 3 moduli | sì | no | no | RAM |
| 4 | ~80 | dedicato | sì | no | sì | MQTT retained |
| 5 | ~50 | dedicato | no (RT) | no | no | RAM (di proprietà del master) |
| 6 | ~70 | condiviso tra 3 moduli | sì | no | sì | MQTT retained |
| 7 | ~40 | dedicato | no (RT) | no | no | RAM |
| 8 | ~250 | dedicato | sì | no | no | nessuno (flusso CSV) |
| 9 | ~150 | dedicato | sì | no | sì | Memoria RTC + MQTT |
| 10 | ~50 | dedicato | n/a | no | no | flash (lato slave) |
| 11 | ~130 | dedicato | sì | no | no | nessuno |
Cosa segue
- Integrazioni fai-da-te — collegare questi scenari a Home Assistant / Node-RED / OpenHAB
- Integrazioni cloud — pipeline AWS IoT / Azure / GCP / InfluxDB
- Riferimento API — ogni metodo pubblico documentato
- Risoluzione dei problemi — quando gli scenari si comportano male sul suo banco
Correlati — documentazione principale di rbAmp
- Riferimento API — specifica formale del registro I²C / comandi / errori che la libreria incapsula
- Esempi Arduino (I²C grezzo) — gli stessi scenari senza la libreria, utili per il porting
- Misura per periodo — concetto di snapshot atomico di periodo e formula dell'energia lato master
- Collegamento hardware — piedinatura, cablaggio, installazione del TA
- Risoluzione dei problemi — problemi lato modulo (NACK, deriva di calibrazione, rumore del bus)
Sorgente e problemi: rb-amp/rbamp-arduino · questa pagina nel repo: docs/06_examples.md
Sorgente e problemi: rb-amp/rbamp-arduino · questa pagina nel repo: docs/06_examples.md (v1.6.2)