Transmission de données audio avec Arduino Nano 33 BLE Sense

Composants et fournitures

Arduino Nano 33 BLE Sense

×

1

À propos de ce projet

Chez Chirp, nous étions extrêmement enthousiastes à l'annonce par Arduino d'une nouvelle carte dotée de nombreuses fonctionnalités : une large gamme de capteurs, un processeur puissant et, surtout, un microphone intégré ! L'équipe d'Arduino nous a envoyé une pré-version de la Nano 33 Sense, entièrement compatible avec Chirp, permettant à la communauté des makers d'envoyer et de recevoir des données par le son.

Chirp ajoute un mécanisme de transport unique aux cartes Arduino : la transmission de données par le son offre aux bidouilleurs davantage d'options de connectivité. Parmi les avantages :

• Indépendant du matériel : les données peuvent être envoyées depuis des applications mobiles, des pages web ou de simples fichiers audio
• Un vers plusieurs : tout appareil à portée auditive reçoit les données en une seule transaction
• Sans friction : aucun appairage, mot de passe ou configuration initiale n'est nécessaire

Ce tutoriel montre comment utiliser le SDK Chirp pour envoyer une valeur RGB et changer la couleur de la LED intégrée. Chirp fonctionne même dans les environnements bruyants grâce à des années de recherche sur la robustesse du décodeur.

Prise en main

Inscrivez-vous sur developers.chirp.io pour obtenir votre clé d'application, secret et configuration audio pour le protocole 16khz-mono-embedded.

Réception de données

La Nano 33 Sense intègre un microphone : il suffit d'installer le SDK Chirp (v3.3.0 ou ultérieure) via le gestionnaire de bibliothèques :

Outils > Gérer les bibliothèques

Puis ouvrez l'exemple :

Fichier > Exemples > ChirpSDK > Nano33SenseReceive

Copiez vos identifiants dans le fichier credentials.h. L'exemple affiche les données reçues sur le moniteur série. Pour piloter la LED RVB, modifiez la fonction onReceivedCallback :

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

void onReceivedCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
  if (length > 0) {
    // Les valeurs élevées = faible luminosité, on soustrait de 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("Échec du décodage");
  }
}

Testez en lisant les fichiers audio fournis : la LED doit passer du rouge au vert puis au bleu.

Et ensuite ?

La première version du SDK Chirp pour Arduino utilise uniquement le protocole audible 16khz-mono-embedded. Une version inaudible (proche des ultrasons) sera publiée prochainement, permettant d'intégrer des données Chirp dans de la musique ou des vidéos pour déclencher des actions.

D'autres tutoriels suivront. Partagez vos projets en nous mentionnant sur Twitter @chirp ou par email à contact@chirp.io.

Code complet

Envoi de valeurs RVB à la Nano 33 Sense (C/C++)

Utilisez les extraits sonores du tutoriel ou envoyez votre propre tableau de 3 octets.

/**--------------------------------------------------------------------
 Exemple de réception de données avec Arduino Nano 33 Sense.
 @file Nano33SenseReceive.ino
 Créez un compte développeur sur https://developers.chirp.io,
 copiez votre clé, secret et config pour le protocole "16khz-mono-embedded".
 Cet exemple écoute des valeurs RVB et change la couleur de la LED intégrée.
 Circuit : Arduino Nano 33 BLE
 Copyright © 2011-2019, Asio Ltd. Tous droits réservés.
 -------------------------------------------------------------------*/
#include <PDM.h>
#include "chirp_connect.h"

#define CHIRP_APP_KEY "VOTRE_CLE_APP"
#define CHIRP_APP_SECRET "VOTRE_SECRET_APP"
#define CHIRP_APP_CONFIG "VOTRE_CONFIG_APP"
#define SAMPLE_RATE 16000
#define BUFFER_SIZE 256
#define R_LED_PIN 22
#define G_LED_PIN 23
#define B_LED_PIN 24

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

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

void setup() {
  Serial.begin(115200);
  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("Échec du démarrage 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);
}

void onReceivingCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
  Serial.println("Réception en cours...");
  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) {
    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("Échec du décodage");
  }
}

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("Initialisation Chirp échouée.");
    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("SDK Chirp initialisé.");
  Serial.flush();
}