Projet LED à commande vocale : Arduino Micro + Serveur BitVoicer pour reconnaissance vocale

Composants et fournitures

	Arduino Micro	×	1
	Sparkfun Electret Microphone Breakout	×	1
	BitVoicer Server	×	1
	BitVoicer Server 1.0	×	1
	LED (générique)	×	3
	Résistance 330 ohm	×	3

À propos de ce projet

Dans cet article, je vais montrer comment utiliser une carte Arduino et le serveur BitVoicer pour contrôler quelques LEDs avec des commandes vocales. J'utiliserai l'Arduino Micro dans cet article, mais vous pouvez utiliser n'importe quelle carte Arduino que vous avez sous la main.

Les procédures suivantes seront exécutées pour transformer les commandes vocales en activité des LEDs :

• Les ondes audio seront capturées et amplifiées par la carte Sparkfun Electret Breakout ;
• Le signal amplifié sera numérisé et mis en tampon dans l'Arduino à l'aide de son convertisseur analogique-numérique (CAN) ;
• Les échantillons audio seront transmis en flux au serveur BitVoicer via le port série de l'Arduino ;
• Le serveur BitVoicer traitera le flux audio et reconnaîtra la parole qu'il contient ;
• La parole reconnue sera associée à des commandes prédéfinies qui seront renvoyées à l'Arduino ;
• L'Arduino identifiera les commandes et effectuera l'action appropriée.

La vidéo ci-dessus montre le résultat final de cet article. Notez dans la vidéo que le serveur BitVoicer fournit également une rétroaction vocale synthétisée. Cette rétroaction vocale est définie dans le serveur et reproduite par l'adaptateur audio du serveur, mais l'audio synthétisé pourrait aussi être envoyé à l'Arduino et reproduit à l'aide d'un convertisseur numérique-analogique (CNA). Dans mon prochain article, je vais montrer comment utiliser l'Arduino DUE, un amplificateur et un haut-parleur pour reproduire la parole synthétisée en utilisant l'Arduino lui-même.

Liste du matériel :

• Arduino Micro (ou toute autre carte Arduino) : ~20 $ US
• Sparkfun Electret Microphone Breakout : 7,95 $ US
• BitVoicer Server 1.0 : 9,90 $ US
• Platine d'essai : ~10 $ US
• 3 x LEDs : ~1 $ US
• 3 x résistances 330 Ohms : ~0,75 $ US
• Fils de câblage : ~0,30 $ US

ÉTAPE 1 : Câblage

La première étape est de câbler l'Arduino et la platine d'essai avec les composants comme montré dans les images ci-dessous.

Le détail le plus important ici concerne la référence analogique fournie au CAN de l'Arduino. Dans mes tests, j'ai obtenu de meilleurs résultats en utilisant 3,3 V avec la carte Sparkfun Electret Breakout. C'est pourquoi j'ai ajouté un cavalier entre la broche 3,3 V et la broche AREF. Si vous décidez d'utiliser la fonction analogRead (pour une raison quelconque) alors que 3,3 V est appliqué sur la broche AREF, vous DEVEZ appeler analogReference(EXTERNAL) avant d'utiliser la fonction analogRead. Sinon, vous mettrez en court-circuit la tension de référence active (générée en interne) et la broche AREF, risquant d'endommager le microcontrôleur de votre carte Arduino.

ÉTAPE 2 : Téléverser le code sur l'Arduino

Maintenant, vous devez téléverser le code ci-dessous sur votre Arduino. Pour plus de commodité, le sketch Arduino est également disponible dans la section Pièces jointes au bas de cet article. Avant de téléverser le code, vous devez installer correctement les bibliothèques du serveur BitVoicer dans l'IDE Arduino (Importation d'une bibliothèque .zip).

BVS_Demo1.ino

Ce sketch a quatre parties principales :

• Références de bibliothèques et déclaration de variables : Les deux premières lignes incluent les références aux bibliothèques BVSP et BVSMic. Ces bibliothèques sont fournies par BitSophia et se trouvent dans le dossier d'installation du serveur BitVoicer. Les autres lignes déclarent les constantes et variables utilisées dans tout le sketch. La classe BVSP est utilisée pour communiquer avec le serveur BitVoicer et la classe BVSMic est utilisée pour capturer et stocker les échantillons audio.
• Fonction setup : Cette fonction initialise la communication série, la classe BVSP, la classe BVSMic et définit le « gestionnaire d'événement » (en fait un pointeur de fonction) pour l'événement frameReceived.
• Fonction loop : Cette fonction effectue trois actions importantes : demande des informations d'état au serveur (fonction keepAlive()), vérifie si le serveur a envoyé des données et traite les données reçues (fonction receive()), et contrôle l'enregistrement et l'envoi des flux audio (fonctions isSREAvailable(), startRecording(), stopRecording() et sendStream()).
• Fonction BVSP_frameReceived : Cette fonction est appelée chaque fois que la fonction receive() identifie qu'une trame complète a été reçue. Ici, j'exécute la commande envoyée depuis le serveur BitVoicer. La commande contient 2 octets. Le premier octet indique la broche et le second la valeur de la broche. J'utilise la fonction analogWrite() pour définir la valeur appropriée sur la broche.

ÉTAPE 3 : Importer les objets de solution du serveur BitVoicer

Maintenant, vous devez configurer le serveur BitVoicer pour qu'il fonctionne avec l'Arduino. Le serveur BitVoicer a quatre objets de solution majeurs : Emplacements, Périphériques, Données binaires et Schémas vocaux.

Les emplacements représentent l'emplacement physique où un périphérique est installé. Dans mon cas, j'ai créé un emplacement appelé Home (Maison).

Les périphériques sont les clients du serveur BitVoicer. J'ai créé un périphérique mixte, nommé ArduinoMicro et entré les paramètres de communication. NOTE SUR L'ARDUINO MICRO : il utilise RTS et DTR donc vous devez activer ces paramètres dans l'onglet communication. J'ai aussi créé un périphérique SystemSpeaker pour synthétiser la parole en utilisant l'adaptateur audio du serveur.

Les données binaires sont un type de commande que le serveur BitVoicer peut envoyer aux périphériques clients. Ce sont en fait des tableaux d'octets que vous pouvez lier à des commandes. Quand le serveur BitVoicer reconnaît une parole liée à cette commande, il envoie le tableau d'octets au périphérique cible. J'ai créé un objet Données binaires pour chaque valeur de broche et je les ai nommés ArduinoMicroGreenLedOn, ArduinoMicroGreenLedOff, etc. J'ai fini avec 18 objets Données binaires dans ma solution, donc je vous suggère de les télécharger et importer depuis le fichier VoiceSchema.sof ci-dessous.

Les schémas vocaux sont là où tout se réunit. Ils définissent quelles phrases doivent être reconnues et quelles commandes exécuter. Pour chaque phrase, vous pouvez définir autant de commandes que nécessaire et l'ordre dans lequel elles seront exécutées. Vous pouvez aussi définir des délais entre les commandes. C'est ainsi que j'ai réussi à effectuer la séquence d'actions que vous voyez dans la vidéo.

Vous pouvez importer (Importation d'objets de solution) tous les objets de solution que j'ai utilisés dans cet article depuis les fichiers ci-dessous. L'un contient les Périphériques et l'autre contient le Schéma vocal et ses Commandes.

Devices.sof VoiceSchema.sof

ÉTAPE 4 : Conclusion

C'est tout ! J'espère que vous avez aimé.

Vous avez tout ce qu'il faut pour exécuter la démo montrée dans la vidéo. Notez que dans la vidéo, j'ai commencé par activer le périphérique ArduinoMicro dans le gestionnaire du serveur BitVoicer. Dès qu'il est activé, l'Arduino identifie un moteur de reconnaissance vocale disponible et commence à diffuser l'audio vers le serveur BitVoicer.

Vous pouvez suivre les résultats de la reconnaissance dans l'outil Moniteur du serveur disponible dans le gestionnaire du serveur BitVoicer.

Dans mon prochain article, je montrerai comment vous pouvez reproduire la parole synthétisée en utilisant un Arduino DUE.

Code

• BVS_Demo1.ino

BVS_Demo1.inoArduino

#include <BVSP.h>
#include <BVSMic.h>

// Définit la broche Arduino qui sera utilisée pour capturer l'audio
#define BVSM_AUDIO_INPUT 5

// Définit les broches des LEDs
#define RED_LED_PIN 6
#define YELLOW_LED_PIN 9
#define GREEN_LED_PIN 10

// Définit les constantes qui seront passées en paramètres à
// la fonction BVSP.begin
const unsigned long STATUS_REQUEST_TIMEOUT = 1000;
const unsigned long STATUS_REQUEST_INTERVAL = 2000;

// Définit la taille du tampon audio
const int AUDIO_BUFFER_SIZE = 64;

// Définit la taille du tampon de réception
const int RECEIVE_BUFFER_SIZE = 2;

// Initialise une nouvelle instance globale de la classe BVSP
BVSP bvsp = BVSP();

// Initialise une nouvelle instance globale de la classe BVSMic
BVSMic bvsm = BVSMic();

// Crée un tampon qui sera utilisé pour lire les échantillons enregistrés
// depuis la classe BVSMic
byte audioBuffer[AUDIO_BUFFER_SIZE];

// Crée un tampon qui sera utilisé pour lire les commandes envoyées
// depuis le serveur BitVoicer.
// Octet 0 = numéro de broche
// Octet 1 = valeur de la broche
byte receiveBuffer[RECEIVE_BUFFER_SIZE];

void setup() {
  // Configure les modes des broches
  pinMode(RED_LED_PIN, OUTPUT);
  pinMode(YELLOW_LED_PIN, OUTPUT);
  pinMode(GREEN_LED_PIN, OUTPUT);

  // Démarre la communication série à 115200 bauds
  Serial.begin(115200);

  // Définit le port série Arduino qui sera utilisé pour
  // la communication, combien de temps avant qu'une demande d'état
  // n'expire et à quelle fréquence les demandes d'état doivent être envoyées
  // au serveur BitVoicer.
  bvsp.begin(Serial, STATUS_REQUEST_TIMEOUT, STATUS_REQUEST_INTERVAL);

  // Définit la fonction qui gérera l'événement
  // frameReceived
  bvsp.frameReceived = BVSP_frameReceived;

  // Prépare le minuteur de la classe BVSMic
  bvsm.begin();
}

void loop() {
  // Vérifie si l'intervalle de demande d'état s'est écoulé et si
  // c'est le cas, envoie une demande d'état au serveur BitVoicer
  bvsp.keepAlive();

  // Vérifie s'il y a des données disponibles dans le tampon du port série
  // et traite son contenu selon les spécifications
  // du protocole du serveur BitVoicer
  bvsp.receive();

  // Vérifie s'il y a un MRE disponible. S'il y en a un,
  // commence l'enregistrement.
  if (bvsp.isSREAvailable()) {
    // Si la classe BVSMic n'enregistre pas, configure l'entrée
    // audio et commence l'enregistrement
    if (!bvsm.isRecording) {
      bvsm.setAudioInput(BVSM_AUDIO_INPUT, EXTERNAL);
      bvsm.startRecording();
    }

    // Vérifie si la classe BVSMic a des échantillons disponibles
    if (bvsm.available) {
      // S'assure que le mode entrant est STREAM_MODE avant
      // de transmettre le flux
      if (bvsp.inboundMode == FRAMED_MODE)
        bvsp.setInboundMode(STREAM_MODE);

      // Lit les échantillons audio depuis la classe BVSMic
      int bytesRead = bvsm.read(audioBuffer, AUDIO_BUFFER_SIZE);

      // Envoie le flux audio au serveur BitVoicer
      bvsp.sendStream(audioBuffer, bytesRead);
    }
  } else {
    // Aucun MRE n'est disponible. Si la classe BVSMic enregistre,
    // l'arrête.
    if (bvsm.isRecording)
      bvsm.stopRecording();
  }
}

// Gère l'événement frameReceived
void BVSP_frameReceived(byte dataType, int payloadSize) {
  // Vérifie si la trame reçue contient des données binaires
  // 0x07 = Données binaires (tableau d'octets)
  if (dataType == DATA_TYPE_BINARY) {
    // Si 2 octets ont été reçus, traite la commande.
    if (bvsp.getReceivedBytes(receiveBuffer, RECEIVE_BUFFER_SIZE) == RECEIVE_BUFFER_SIZE) {
      analogWrite(receiveBuffer[0], receiveBuffer[1]);
    }
  }
}

Schémas