Audio-Datenübertragung mit Arduino Nano 33 BLE Sense

Komponenten und Zubehör

Arduino Nano 33 BLE Sense

×

1

Über dieses Projekt

Hier bei Chirp HQ waren wir äußerst begeistert, als Arduino die Veröffentlichung eines neuen Boards mit zahlreichen neuen Features ankündigte. Dazu gehören eine Vielzahl von Sensoren, ein leistungsstarker Prozessor und – am wichtigsten – ein integriertes Mikrofon! Die freundlichen Leute von Arduino schickten uns eine Vorabversion des neuen Nano 33 Sense Boards, das vollständig mit Chirp kompatibel ist und der Maker-Community ermöglicht, Daten per Schall zu senden und zu empfangen.

Chirp fügt Arduino-Boards einen völlig einzigartigen Übertragungsmechanismus hinzu: Die Data-over-Sound-Fähigkeit gibt Entwicklern mehr Konnektivitätsoptionen an die Hand. Zu den Vorteilen der Datenübertragung per Schall gehören:

• Geräteunabhängig: Daten können von mobilen Apps, Webseiten oder sogar einer simplen Audiodatei gesendet werden
• One-to-Many: Jedes Gerät in Hörweite kann Daten in einer einzigen Transaktion empfangen
• Reibungslos: Kein Pairing, keine Passwörter, keine Ersteinrichtung nötig

In diesem Tutorial zeigen wir, wie man mit dem Chirp SDK einen RGB-Wert sendet, um die Farbe der integrierten LED zu ändern.

Chirp funktioniert sogar in lauten Umgebungen – dank jahrelanger Forschung zur Robustheit des Decoders gegen Hintergrundgeräusche. Mehr über die Vorteile von Data-over-Sound erfahren Sie hier.

Sind Sie noch skeptisch? Probieren Sie es einfach selbst aus.

Der Einstieg in Chirp war nie einfacher…

Erste Schritte

Falls noch nicht geschehen, müssen Sie sich bei Chirp unter developers.chirp.io registrieren. Nach der Anmeldung erhalten Sie Ihren App-Key, Secret und die Audio-Konfiguration für Ihre Anwendung.

Daten empfangen

Da der Nano 33 Sense über ein integriertes Mikrofon verfügt, benötigen Sie zum Empfangen von Daten mit Chirp lediglich das Chirp SDK, das direkt über den Bibliotheksverwalter verfügbar ist.

Öffnen Sie einfach den Bibliotheksverwalter, suchen Sie nach „Chirp SDK“ und installieren Sie Version 3.3.0 oder neuer – schon kann es losgehen.

Werkzeuge > Bibliotheken verwalten

Sie können unser Beispielprogramm als Ausgangspunkt nutzen:

Datei > Beispiele > ChirpSDK > Nano33SenseReceive

Kopieren Sie Ihre Zugangsdaten für das 16khz-mono-embedded-Protokoll von developers.chirp.io in die Datei credentials.h.

Der Beispielcode gibt empfangene Daten lediglich im Serial Monitor aus. Doch wir können das Verhalten einfach anpassen, um die integrierten LEDs anzusteuern, indem wir die Funktion onReceivedCallback bearbeiten.

Im Setup-Funktion müssen wir zunächst die GPIO-Pins der LEDs als Ausgänge definieren:

#define R_LED_PIN 22
#define G_LED_PIN 23
#define B_LED_PIN 24

void setup() {
  pinMode(R_LED_PIN, OUTPUT);
  pinMode(G_LED_PIN, OUTPUT);
  pinMode(B_LED_PIN, OUTPUT);
}

Um die LEDs anzusteuern, extrahieren wir die RGB-Werte aus dem Daten-Payload:

void onReceivedCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
  if (length > 0) {
    // Hohe Werte bedeuten geringere Helligkeit, daher subtrahieren wir von UINT8_MAX
    analogWrite(R_LED_PIN, UINT8_MAX - payload[0]);
    analogWrite(G_LED_PIN, UINT8_MAX - payload[1]);
    analogWrite(B_LED_PIN, UINT8_MAX - payload[2]);
  } else {
    Serial.println("Decode failed");
  }
}

Sie können Ihren Code nun testen, indem Sie die untenstehenden Audiodateien abspielen – jede sollte die LED-Farbe von Rot über Grün nach Blau ändern.

Was kommt als Nächstes?

Die erste Version des Chirp SDK für Arduino unterstützt nur das hörbare 16khz-mono-embedded-Protokoll. In den kommenden Monaten werden wir eine unhörbare Version veröffentlichen, die im nahe-ultraschalligen Frequenzbereich arbeitet. Damit können Sie Daten bei Frequenzen senden, die der Mensch nicht hört – beispielsweise könnten Sie Chirp-Daten in bestehende Audiodateien wie Songs oder Videos einbetten, um Aktionen auszulösen.

Wir werden auch weitere Tutorials veröffentlichen, wie Sie Data-over-Sound mit Arduino nutzen können. Lassen Sie uns wissen, wo Sie Chirp in Ihren eigenen Arduino-Projekten eingesetzt haben – markieren Sie uns auf Twitter @chirp oder kontaktieren Sie uns unter contact@chirp.io.

Code

Chirp RGB-Werte an Nano 33 Sense C/C++

Senden Sie RGB-Werte per Chirp, um die Farbe der integrierten LED zu ändern. Nutzen Sie unsere beigefügten Soundclips in diesem Tutorial oder senden Sie selbst ein Array von 3 Bytes.

/**--------------------------------------------------------------------
 Beispielcode zum Empfangen von Daten mit dem Arduino Nano 33 Sense Board.
 @file Nano33SenseReceive.ino
 @brief Erstellen Sie einen Entwickler-Account unter https://developers.chirp.io,
 und kopieren Sie Ihren Key, Secret und Config-String für das
 "16khz-mono-embedded"-Protokoll in die Chirp-Defines unten.
 Dieses Beispiel lauscht auf RGB-Werte und ändert die Farbe der onboard LED.
 Schaltung:
 - Arduino Nano 33 BLE Board
 Copyright © 2011-2019, Asio Ltd. All rights reserved.
 -------------------------------------------------------------------*/
#include <PDM.h>
#include "chirp_connect.h"

#define CHIRP_APP_KEY "YOUR_APP_KEY"
#define CHIRP_APP_SECRET "YOUR_APP_SECRET"
#define CHIRP_APP_CONFIG "YOUR_APP_CONFIG"
#define SAMPLE_RATE 16000
#define BUFFER_SIZE 256
#define R_LED_PIN 22
#define G_LED_PIN 23
#define B_LED_PIN 24

// Globale Variablen
static chirp_connect_t *chirp = NULL;
short sampleBuffer[BUFFER_SIZE];
volatile int samplesRead;

// Funktionsdeklarationen
void setupChirp(void);
void chirpErrorHandler(chirp_connect_error_code_t code);
void onPDMdata(void);

// Hauptprogramm
void setup() {
  Serial.begin(115200);
  // while (!Serial);
  pinMode(R_LED_PIN, OUTPUT);
  pinMode(G_LED_PIN, OUTPUT);
  pinMode(B_LED_PIN, OUTPUT);
  setupChirp();
  PDM.onReceive(onPDMdata);
  PDM.setGain(30);
  if (!PDM.begin(1, SAMPLE_RATE)) {
    Serial.println("Failed to start PDM!");
    while (1);
  }
  analogWrite(R_LED_PIN, UINT8_MAX);
  analogWrite(G_LED_PIN, UINT8_MAX);
  analogWrite(B_LED_PIN, UINT8_MAX);
}

void loop() {
  if (samplesRead) {
    chirp_connect_error_code_t err = chirp_connect_process_shorts_input(chirp, sampleBuffer, samplesRead);
    chirpErrorHandler(err);
    samplesRead = 0;
  }
}

void onPDMdata() {
  int bytesAvailable = PDM.available();
  PDM.read(sampleBuffer, bytesAvailable);
  samplesRead = bytesAvailable / sizeof(short);
}

// Chirp-Callbacks
void onReceivingCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
  Serial.println("Receiving data...");
  analogWrite(R_LED_PIN, UINT8_MAX);
  analogWrite(G_LED_PIN, UINT8_MAX);
  analogWrite(B_LED_PIN, UINT8_MAX);
}

void onReceivedCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
  if (length) {
    // Hohe Werte bedeuten geringere Helligkeit, daher subtrahieren wir von UINT8_MAX
    analogWrite(R_LED_PIN, UINT8_MAX - payload[0]);
    analogWrite(G_LED_PIN, UINT8_MAX - payload[1]);
    analogWrite(B_LED_PIN, UINT8_MAX - payload[2]);
  } else {
    analogWrite(R_LED_PIN, 0);
    analogWrite(G_LED_PIN, UINT8_MAX);
    analogWrite(B_LED_PIN, UINT8_MAX);
    delay(500);
    analogWrite(R_LED_PIN, UINT8_MAX);
    delay(500);
    analogWrite(R_LED_PIN, 0);
    Serial.println("Decode failed");
  }
}

void chirpErrorHandler(chirp_connect_error_code_t code) {
  if (code != CHIRP_CONNECT_OK) {
    const char *error_string = chirp_connect_error_code_to_string(code);
    Serial.println(error_string);
    exit(42);
  }
}

void setupChirp(void) {
  chirp = new_chirp_connect(CHIRP_APP_KEY, CHIRP_APP_SECRET);
  if (chirp == NULL) {
    Serial.println("Chirp initialisation failed.");
    return;
  }
  chirp_connect_error_code_t err = chirp_connect_set_config(chirp, CHIRP_APP_CONFIG);
  chirpErrorHandler(err);
  char *info = chirp_connect_get_info(chirp);
  Serial.println(info);
  chirp_connect_free(info);
  chirp_connect_callback_set_t callback_set = {
    .on_state_changed = NULL,
    .on_sending = NULL,
    .on_sent = NULL,
    .on_receiving = onReceivingCallback,
    .on_received = onReceivedCallback
  };
  err = chirp_connect_set_callbacks(chirp, callback_set);
  chirpErrorHandler(err);
  err = chirp_connect_set_input_sample_rate(chirp, SAMPLE_RATE);
  chirpErrorHandler(err);
  err = chirp_connect_set_frequency_correction(chirp, 1.0096);
  chirpErrorHandler(err);
  err = chirp_connect_start(chirp);
  chirpErrorHandler(err);
  Serial.println("Chirp SDK initialised.");
  Serial.flush();
}