Transmisión de datos de audio con Arduino Nano 33 BLE Sense

Componentes y suministros

Arduino Nano 33 BLE Sense

×

1

Acerca de este proyecto

En Chirp HQ estábamos muy entusiasmados con el anuncio de Arduino sobre una nueva placa con numerosas características innovadoras: una amplia gama de sensores, un procesador potente y, lo más importante, ¡un micrófono integrado! El equipo de Arduino nos envió una versión preliminar de la Nano 33 BLE Sense, totalmente compatible con Chirp, lo que permite a la comunidad maker enviar y recibir datos mediante sonido.

Chirp añade un mecanismo de transporte único a las placas Arduino. La capacidad de transmitir datos por sonido brinda a los desarrolladores más opciones de conectividad. Algunas ventajas de la transmisión de datos por sonido incluyen:

• Agnóstica al dispositivo: los datos pueden enviarse desde aplicaciones móviles, páginas web o incluso archivos de audio
• Uno a muchos: cualquier dispositivo dentro del rango de audición puede recibir datos en una sola transacción
• Sin fricción: no requiere emparejamiento, contraseñas ni configuración inicial

En este tutorial demostraremos cómo usar el SDK de Chirp para enviar un valor RGB y cambiar el color del LED integrado. Chirp funciona incluso en entornos ruidosos, gracias a años de investigación para hacer el decodificador robusto contra el sonido de fondo. Lee más sobre los beneficios de la transmisión de datos por sonido.

Si aún eres escéptico, pruébalo tú mismo. Empezar con Chirp es más fácil que nunca...

Primeros pasos

Si no lo has hecho, regístrate en Chirp en developers.chirp.io. Una vez registrado, obtendrás tu clave de aplicación (app key), secreto (secret) y configuración de audio para tu aplicación.

Recepción de datos

Como la Nano 33 BLE Sense incluye un micrófono integrado, solo necesitas el SDK de Chirp, disponible directamente desde el Gestor de Librerías de Arduino.

1. Abre el Gestor de Librerías (Herramientas > Gestionar librerías)
2. Busca "Chirp SDK"
3. Instala la versión 3.3.0 o posterior

Abre el código de ejemplo:

Archivo > Ejemplos > ChirpSDK > Nano33SenseReceive

Copia y pega tus credenciales para el protocolo 16khz-mono-embedded desde developers.chirp.io en el archivo credentials.h.

El código de ejemplo imprime los datos recibidos en el Monitor Serie. Podemos modificar el comportamiento para encender los LEDs integrados editando la función onReceivedCallback.

Configuración de los pines GPIO para los LEDs

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

Extracción de valores RGB del payload

void onReceivedCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
  if (length > 0) {
    // Valores altos significan menor brillo, restamos 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("Decodificación fallida");
  }
}

Ahora puedes probar tu código reproduciendo los archivos de audio a continuación; cada uno debería cambiar el color del LED de rojo a verde a azul.

¿Qué sigue?

La primera versión del SDK de Chirp para Arduino opera solo en el protocolo audible 16khz-mono-embedded. En los próximos meses lanzaremos una versión inaudible que funcionará a frecuencias cercanas a los ultrasónicos. Esto permitirá enviar datos a frecuencias que el oído humano no percibe, por ejemplo, incrustar datos Chirp en audio existente como canciones o videos para desencadenar acciones.

También publicaremos más tutoriales sobre cómo aprovechar la transmisión de datos por sonido con Arduino. Cuéntanos dónde has usado Chirp en tus proyectos etiquetándonos en Twitter @chirp o contactándonos en contact@chirp.io.

Código

Valores RGB Chirp a Nano 33 Sense C/C++

Envía valores RGB usando Chirp para cambiar el color del LED integrado. Puedes usar nuestros clips de sonido adjuntos en este tutorial o hacerlo tú mismo enviando un array de 3 bytes.

/**--------------------------------------------------------------------
  Código de ejemplo para recibir datos usando la placa Arduino Nano 33 Sense.
  @file Nano33SenseReceive.ino
  @brief Crea una cuenta de desarrollador en https://developers.chirp.io,
  y copia y pega tu clave, secreto y cadena de configuración para el
  protocolo "16khz-mono-embedded" en los defines de chirp a continuación.
  Este ejemplo comenzará a escuchar valores RGB y cambiará el color
  del LED integrado.
  Circuito:
  - Placa Arduino Nano 33 BLE
  Copyright © 2011-2019, Asio Ltd. Todos los derechos reservados.
  -------------------------------------------------------------------*/
#include <PDM.h>
#include "chirp_connect.h"

#define CHIRP_APP_KEY "TU_APP_KEY"
#define CHIRP_APP_SECRET "TU_APP_SECRET"
#define CHIRP_APP_CONFIG "TU_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

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

// Definiciones de funciones
void setupChirp(void);
void chirpErrorHandler(chirp_connect_error_code_t code);
void onPDMdata(void);

// Principal
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("¡Fallo al iniciar 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);
}

// Callbacks de Chirp
void onReceivingCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
  Serial.println("Recibiendo datos...");
  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) {
    // Valores altos significan menor brillo
    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("Decodificación fallida");
  }
}

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("Inicialización de Chirp fallida.");
    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 de Chirp inicializado.");
  Serial.flush();
}