Transmissão de Dados de Áudio com Arduino Nano 33 BLE Sense

Componentes e materiais

Arduino Nano 33 BLE Sense

×

1

Sobre este projeto

Aqui na Chirp, ficamos extremamente entusiasmados com o anúncio de que a Arduino lançaria uma nova placa com uma série de novos recursos. Entre eles, uma ampla gama de sensores, um processador potente e, o mais importante, um microfone integrado! A equipe da Arduino nos enviou uma versão prévia da nova Nano 33 Sense, totalmente compatível com a Chirp, permitindo que a comunidade maker envie e receba dados usando som.

A Chirp adiciona um mecanismo de transporte totalmente exclusivo às placas Arduino: a capacidade de transmissão de dados por som oferece aos makers mais opções de conectividade. Algumas vantagens do data-over-sound incluem:

• Independente de dispositivo: dados podem ser enviados a partir de aplicativos móveis, páginas da web ou até mesmo arquivos de áudio
• Um para muitos: qualquer dispositivo dentro do alcance auditivo recebe os dados em uma única transação
• Sem atrito: não requer emparelhamento, senhas ou configuração inicial

Neste tutorial, demonstraremos como usar o Chirp SDK para enviar um valor RGB e alterar a cor do LED integrado.

A Chirp funciona mesmo em ambientes ruidosos, graças a anos de pesquisa para tornar o decodificador robusto contra sons de fundo. Saiba mais sobre os benefícios do data-over-sound.

Se ainda está cético, experimente você mesmo. Começar com a Chirp é mais fácil do que nunca...

Primeiros passos

Caso ainda não tenha feito, você precisará se cadastrar na Chirp em developers.chirp.io. Após o cadastro, obtenha sua chave de aplicativo (app key), segredo (secret) e configuração de áudio para sua aplicação.

Recebendo dados

Como a Nano 33 Sense já possui microfone integrado, tudo o que você precisa para receber dados com a Chirp é o Chirp SDK, disponível diretamente no Gerenciador de Bibliotecas.

1. Abra o Gerenciador de Bibliotecas (Ferramentas > Gerenciar Bibliotecas)
2. Pesquise por Chirp SDK
3. Instale a versão 3.3.0 ou posterior

Você pode abrir nosso código de exemplo para começar:

Arquivo > Exemplos > ChirpSDK > Nano33SenseReceive

Copie e cole suas credenciais do protocolo 16khz-mono-embedded do developers.chirp.io no arquivo credentials.h.

O código de exemplo apenas imprime os dados recebidos no Monitor Serial. Porém, podemos facilmente alterar o comportamento para acender os LEDs integrados editando a função onReceivedCallback.

Configuração dos pinos do LED

Na função setup(), configure os pinos GPIO conectados aos LEDs como saídas:

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

Controlando os LEDs com os valores RGB

Extraia os valores RGB do payload de dados:

void onReceivedCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
  if (length > 0) {
    // Valores altos significam menor brilho, então subtraímos 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("Decodificação falhou");
  }
}

Agora você pode testar seu código reproduzindo os arquivos de áudio abaixo; cada um deve alterar a cor do LED de vermelho para verde e depois para azul.

O que vem a seguir?

A primeira versão do Chirp SDK para Arduino opera apenas no protocolo audível 16khz-mono-embedded. Nos próximos meses, lançaremos uma versão inaudível que funcionará em frequências quase ultrassônicas. Com ela, você poderá enviar dados em frequências que humanos não ouvem, permitindo, por exemplo, embutir dados Chirp em áudios existentes como músicas ou vídeos para disparar ações.

Também publicaremos mais tutoriais sobre como utilizar data-over-sound com Arduino. Conte-nos onde você usou a Chirp em seus projetos marcando @chirp no Twitter ou entre em contato em contact@chirp.io.

Código completo

Envio de valores RGB via Chirp para Nano 33 Sense

Envie valores RGB usando Chirp para alterar a cor do LED integrado. Você pode usar nossos clipes de som anexados neste tutorial ou enviar um array de 3 bytes.

/**--------------------------------------------------------------------
  Código de exemplo para receber dados usando a placa Arduino Nano 33 Sense.
  @file Nano33SenseReceive.ino
  @brief Crie uma conta de desenvolvedor em https://developers.chirp.io,
  e copie sua chave, segredo e string de configuração para o protocolo
  "16khz-mono-embedded" nos defines abaixo.
  Este exemplo inicia a escuta de valores RGB e altera a cor do LED integrado.
  Circuito:
  - Placa Arduino Nano 33 BLE
  Copyright © 2011-2019, Asio Ltd. Todos os direitos reservados.
  -------------------------------------------------------------------*/
#include <PDM.h>
#include "chirp_connect.h"

#define CHIRP_APP_KEY "SUA_APP_KEY"
#define CHIRP_APP_SECRET "SEU_APP_SECRET"
#define CHIRP_APP_CONFIG "SUA_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

// Variáveis globais
static chirp_connect_t *chirp = NULL;
short sampleBuffer[BUFFER_SIZE];
volatile int samplesRead;

// Declarações de funções
void setupChirp(void);
void chirpErrorHandler(chirp_connect_error_code_t code);
void onPDMdata(void);

// Função 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("Falha ao 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 Chirp
void onReceivingCallback(void *chirp, uint8_t *payload, size_t length, uint8_t channel) {
  Serial.println("Recebendo dados...");
  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("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("Falha na inicialização da Chirp.");
    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 inicializado.");
  Serial.flush();
}