rbAmp
FR
Boutique
Docs
Mis à jour le · Modifier sur GitHub [Edit on GitHub]

Exemples

Parcours des croquis fournis dans examples/ et des scénarios composés. La plupart des exemples numérotés ci-dessous ont un code correspondant dans examples/ — ouvrez les vrais croquis dans l'IDE Arduino pour le code source complet.


Scénario 1 — Lecture rapide

Objectif : afficher U / I / P / PF / fréquence une fois par seconde. Le « bonjour le monde » que vous venez d'écrire dans le Démarrage rapide, mais avec dev.readAll(s) pour une lecture complète d'un bloc RT en une fois, au lieu d'appels de propriétés individuels.

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

Ce qui circule sur le fil : readAll() sur un UI3 émet 53 transactions d'un seul octet (13 floats × 4 octets + 1 octet de fréquence). À 100 kHz avec une marge de 3 tentatives, environ 12 à 15 ms au total. Passez aux lectures par appel (dev.voltage, dev.current[ch]) si vous n'avez besoin que d'un sous-ensemble.


Scénario 2 — Compteur de 60 secondes sur OLED

Compteur Wh rafraîchi une fois par minute sur un OLED SSD1306 de 128×64 partageant le bus I2C (OLED à 0x3C). Mécanique clé de la bibliothèque : readPeriodSnapshot() effectue l'instantané + la stabilisation + la vérification de validité + la lecture + le tick Wh en un seul appel.

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

Croquis complet dans 02_PeriodEnergyOLED.ino.

Traitement des instantanés périmés : readPeriodSnapshot() renvoie false avec lastError() == RB_ERR_STALE si REG_V03_PERIOD_VALID == 0. La bibliothèque valide quand même en interne l'horodatage mural du maître — cela empêche le prochain instantané réussi de compter deux fois les Wh sur un intervalle de 2× la période.


Scénario 3 — Surveillance multi-modules

Trois modules rbAmp sur un bus à 0x50 / 0x51 / 0x52. Chacun doit avoir une adresse I2C unique — utilisez le scénario 10 pour attribuer les adresses pendant l'installation.

instantané cohérent v1.3

chaque module qui prend en charge l'instantané General-Call et qui a choisi de l'activer (enableGc(true), persisté) capture la même période du secteur sur une seule trame all-call — RbAmp::broadcastLatchGroup(Wire, 0x00, tick). La dérive de la flotte est < 10 µs, donc les puissances de chaque module s'additionnent de façon cohérente. Chaque module marque son instantané avec le tick diffusé ; relisez-le avec readGcTick() pour repérer un module qui a manqué la trame. (Sur le firmware v1.0/v1.1, l'instantané General-Call n'était pas disponible et ce croquis se repliait sur des instantanés séquentiels par appareil — conservés dans l'historique des commentaires du fichier pour les anciens modules.)

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

Croquis complet (avec sondage de scan du bus et rapport d'erreurs) dans 03_MultiModuleBroadcast.ino.


Scénario 4 — UI3 par appareil + MQTT

Un module UI3 avec trois pinces sur trois charges. Compteurs Wh indépendants par canal, publiés sur MQTT une fois par minute. Montre que dev.energy().wh(ch) fonctionne indépendamment sur chaque canal — pas besoin de tableau total_wh[3] manuel.

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

Croquis complet dans 04_UI3PerChannelMQTT.ino. Pour la découverte automatique MQTT HA par-dessus cette base, voir Intégrations DIY.


Scénario 5 — Comptabilité bidirectionnelle côté maître

Sépare la puissance RT signée en compteurs de consommation brute / d'injection brute. À utiliser sur les modules de palier BASIC, où l'accumulateur de période borne à zéro les valeurs négatives — échantillonnez dev.readPower(0) à 10 Hz côté maître.

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

Croquis complet dans 06_BidirectionalEnergy.ino. Sur un module STANDARD (STD), dev.energy().wh(0) fournit déjà le solde net signé — vous n'avez besoin de cette répartition côté maître que pour les rapports de consommation brute et d'export brut.


Scénario 6 — Bilan énergétique domestique

Trois modules : secteur (bidirectionnel, STANDARD (STD)) + solaire (production seule, BASIC possible)

  • charges (UI3 BASIC pour un suivi par appareil). Tableau de bord domestique global publié toutes les 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();
}

Pour la séparation explicite consommation / injection sur le module secteur, combinez avec le schéma du scénario 5 (une boucle séparée à 10 Hz sur mains.readPower(0)).


Scénario 7 — Détection d'événements (EMA)

À chaque fenêtre RT de 100 ms, comparez P à une moyenne mobile exponentiellement pondérée. Journalisez les écarts significatifs (micro-ondes / bouilloire).

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

Scénario composé — pas de fichier d'exemple dédié. Combinez-le avec la publication MQTT du scénario 4 pour l'automatisation d'événements côté HA, ou journalisez sur SD avec Adafruit_SD pour un suivi d'événements hors ligne.


Scénario 8 — Supervision autonome de banc sur 12 heures

Harnais de validation d'endurance longue durée — exécute la bibliothèque contre un DUT réel pendant 12 à 15 heures sous une charge dense par cycle, et émet une ligne CSV toutes les 5 minutes avec des compteurs de diagnostic complets. La recette de référence utilisée pour qualifier le firmware v1.1 sur le maître de référence de la bibliothèque Arduino.

Caractéristiques principales :

  • Surcharge RBAMP_NACK_RETRY_ATTEMPTS=5 — à définir AVANT l'inclusion pour régler les nouvelles tentatives sur des charges denses (≥10 lectures d'un octet par cycle). La valeur 3 par défaut suffit pour l'interrogation ESPHome toutes les 60 s ; SoakMonitor lit ~45 octets par cycle et a besoin de la marge supplémentaire.

  • dev.rawTopology() — lecture directe sur le fil de REG_TOPOLOGY (0x24) pour la détection v1.1. Renvoie 1/2/3 sur v1.1, 0x00 sur v1.0, 0xFF en cas d'échec I2C.

  • dev.retryExhaustionCount() + dev.sanityRejectCount() — les deux doivent rester à 0 pour un essai de 12 h réussi.

Squelette de chaque cycle :

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

Le croquis est construit à partir des extraits de ce scénario. Lancez avec arduino-cli monitor -p COM3 -c baudrate=115200 > soak.csv et laissez tourner 12 à 15 h sans surveillance. Critères d'acceptation : retry_exhaust == 0, sanity_reject == 0, period_ok / period_total ≥ 99 %, Wh monotone.


Scénario 9 — Enregistreur sur batterie en veille profonde

L'ESP32 se réveille toutes les 10 minutes, prend un instantané de période, publie via WiFi+MQTT, puis entre en veille profonde. L'énergie persiste pendant la veille grâce à la mémoire RTC. L'accumulateur de la bibliothèque est désactivé — le maître gère la persistance des Wh.

Squelette utile à la bibliothèque :

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() {}

Croquis complet (avec configuration WiFi, publication MQTT, gardes de marqueur magique RTC) dans 07_DeepSleepLogger.ino.

Budget de puissance (ESP32-WROOM, réveil toutes les 10 minutes) :

  • Durée de réveil : ~3 s (Wi-Fi + MQTT + I2C)
  • Courant de réveil : ~80 mA en moyenne → ~0.07 mAh par réveil
  • Courant de veille : ~10 µA (RTC + domaines conservés)
  • ~10 mAh/jour au total → une cellule Li-ion de 2000 mAh tient ~6 mois

Scénario 10 — Changement d'adresse I2C

Réaffecte l'adresse esclave d'un rbAmp de 0x50 à 0x51. Utilisé une fois par module lors de la construction d'une installation multi-modules. Déconnectez les autres modules pendant cette opération pour éviter les collisions sur le bus.

Sur le firmware actuel (v1.3+), changer l'adresse I²C d'un module ne nécessite ni mode spécial, ni cavalier, ni outillage d'usine : vous préparez la nouvelle adresse, armez le changement puis le validez (séquence en deux phases armée par magic, pour qu'une adresse ne puisse pas changer par accident), et le module redémarre à sa nouvelle adresse. La bibliothèque impose un protocole en deux étapes — prepareAddressChange() arme, commitAddressChange() écrit dans une fenêtre de 5 secondes.

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

Croquis complet dans 05_AddressChange.ino. Si la fenêtre d'armement de 5 secondes expire avant la validation, la bibliothèque renvoie false avec lastError() == RB_ERR_TIMEOUT et réinitialise l'indicateur d'armement — vous devez rappeler prepareAddressChange(). Cela évite les erreurs de frappe qui rendraient l'appareil inutilisable.


Scénario 11 — Un seul croquis, les deux lignes de modules

L'exemple 11_StdLine montre qu'un seul croquis sert les modules BASIC et STANDARD (STD). begin() détecte la gamme ; les lectures communes (readVoltage(), readCurrent(), readPower(), readPowerFactor(), readFrequency()) fonctionnent sur l'un ou l'autre, et les extras réservés au STD — puissances réactive et apparente, lectures de blocs par canal (stdReadChannel()), compteurs de santé (stdReadHealth()) et banques d'instantanés de période — sont protégés par un contrôle 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
}

Sur un module BASIC, les appels std* renvoient RB_ERR_NOT_IMPLEMENTED. La description appel par appel se trouve dans 09 · Référence de l'API § API de la ligne STD.


Tableau comparatif

# LOC Bus I2C Période ? DRDY? MQTT? Persistance
1 ~30 partagé non non non aucun
2 ~50 partagé avec l'OLED oui non non RAM
3 ~50 partagé par 3 modules oui non non RAM
4 ~80 dédié oui non oui retained MQTT
5 ~50 dédié non (RT) non non RAM (détenue par le maître)
6 ~70 partagé par 3 modules oui non oui retained MQTT
7 ~40 dédié non (RT) non non RAM
8 ~250 dédié oui non non aucun (flux CSV)
9 ~150 dédié oui non oui Mémoire RTC + MQTT
10 ~50 dédié n/a non non flash (côté esclave)
11 ~130 dédié oui non non aucun

Et ensuite


Source et problèmes : rb-amp/rbamp-arduino · cette page dans le dépôt : docs/06_examples.md


Source et problèmes : rb-amp/rbamp-arduino · cette page dans le dépôt : docs/06_examples.md (v1.6.2)