rbAmp
IT
Negozio
Docs
Aggiornato · Modifica su GitHub [Edit on GitHub]

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.


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à.

C++
#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.

C++
#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.

snapshot coerente v1.3

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

C++
#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].

C++
#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.

C++
#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.
C++
#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).

C++
#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, 0x00 sulla v1.0, 0xFF in caso di errore I²C.

  • dev.retryExhaustionCount() + dev.sanityRejectCount() — entrambi devono restare a 0 per una prova di 12 h superata.

Scheletro per ciclo:

C++
#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:

C++
#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.

C++
#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():

C++
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


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)