Construire un robot à 2 roues commandé par la voix avec Arduino et BitVoicer Server

Composants et fournitures

Composant	Quantité	Notes
Arduino UNO	1
Shield pilote moteur Pololu Dual MC33926	1
Shield XBee SparkFun	1
Module Microchip RN171VX	1
Micro électret pré-amplifié SparkFun	1
Châssis robot 2 roues (2WD)	1
Régulateur de tension LM1117 (TO-220) 3,3V	1
Condensateur 10 µF	1
LED (générique)	4
Résistance 330 Ω	4
Piles AA 1,5V	4
Pile 9V (générique)	1
Adaptateur 9V vers prise jack	1
Fils de câblage (générique)	17
Fil de cuivre ordinaire	1
Vis et collier plastique flexible pour fixation	1

Outils nécessaires

• Fer à souder (générique)
• Pinces
• Tournevis

Applications et services en ligne

• BitVoicer Server 1.0

À propos du projet

Ce tutoriel montre comment construire un robot 2 roues commandé par la voix. Bien que je ne contrôle que des moteurs CC pour déplacer le robot, la même approche peut servir pour commander des moteurs pas-à-pas et des servomoteurs ; ce tutoriel peut donc servir de référence pour tout robot vocal effectuant des mouvements mécaniques.

Pour construire ce robot, vous aurez besoin : un châssis 2 roues, une carte Arduino, un shield pilote moteur CC, une licence BitVoicer Server, un module WiFi et un microphone pré-amplifié. Il existe une grande variété de composants sur le marché et vous pouvez obtenir les mêmes résultats avec différentes combinaisons. À l'étape 1, je donne des détails sur certains composants utilisés, afin que si vous devez en changer, vous cherchiez des caractéristiques similaires.

Les procédures suivantes transforment les commandes vocales en mouvements du robot :

1. Les ondes audio sont capturées et amplifiées par la carte SparkFun Electret Breakout.
2. Le signal amplifié est numérisé et mis en tampon dans l'Arduino via son convertisseur analogique-numérique (ADC).
3. Les échantillons audio sont transmis au BitVoicer Server via le module WiFi Microchip.
4. BitVoicer Server traite le flux audio et reconnaît la parole.
5. La parole reconnue est associée à des commandes prédéfinies envoyées à l'Arduino.
6. L'Arduino identifie la commande et détermine quels moteurs CC utiliser, pendant combien de temps et à quelle vitesse.
7. Le pilote moteur est activé pour fournir la tension et le courant nécessaires aux moteurs.

Liste du matériel (prix indicatifs)

• Arduino UNO : ~25 $
• Pololu Dual MC33926 Motor Driver Shield : 29,95 $
• SparkFun XBee Shield : 14,95 $
• Microchip RN171VX Module w/ Antenna : 34,95 $
• SparkFun Electret Microphone Breakout : 7,95 $
• BitVoicer Server 1.0 : 8,90 $
• 2WD Robot Car Chassis : 15,95 $
• Texas Instruments LM1117 (TO-220) Voltage Regulator : ~1,95 $
• Condensateur électrolytique 10µF : ~0,35 $
• 4 × LEDs : ~1,00 $
• 4 × Résistances 330 Ω : ~0,75 $
• 4 × Piles AA 1,5V : ~2,00 $
• Pile 9V : ~2,00 $
• Adaptateur 9V vers jack : ~2,50 $
• Fils de câblage et fils ordinaires : ~2,00 $
• Vis et collier plastique flexible
• Fer à souder et soudure

ÉTAPE 1 : Connaître les composants

Dans cette étape, je donne des informations importantes sur les composants du robot et comment les préparer pour le montage.

Le cœur du robot : un Arduino UNO R3. Bien que j'utilise un UNO, d'autres cartes Arduino conviennent. J'ai choisi l'UNO car c'est de loin la plus populaire, permettant à plus de gens de reproduire ce robot. Si vous avez un Arduino DUE, vous pouvez aussi ajouter des réponses vocales comme dans ce tutoriel.

Pour mouvoir les moteurs CC, j'ai utilisé ce shield Pololu. C'est un double pilote capable de contrôler des moteurs CC 5-28V et de délivrer jusqu'à 3A continu par moteur. Bien que je trouve ce shield excellent, ce qui m'a le plus impressionné chez Pololu est leur documentation claire et détaillée. De plus, Pololu fournit une bibliothèque Arduino qui rend le contrôle des moteurs très simple : il suffit de passer la vitesse et le sens (valeurs négatives ou positives) à la fonction setSpeeds. Si vous optez pour un autre pilote moteur, attention aux broches utilisées car elles ne doivent pas entrer en conflit avec celles du robot. Le shield Pololu utilise les broches Arduino suivantes : numériques 4, 7, 8, 9, 10, 12 ; analogiques 0, 1 ; GND ; 5V. L'aspect le plus important est que seules les broches 9 et 10 sont utilisées en PWM et le timer qui génère les impulsions sur ces broches n'est pas le même timer (timer 2 sur l'UNO) utilisé par la classe BVSMic de BitSophia.

Pour communiquer avec le serveur et accéder aux services BitVoicer Server, j'utilise le module WiFi Microchip RN171VX. Deux caractéristiques majeures : toute la communication se fait via le port série de manière simple ; et le module a le même format que la plupart des modules XBee populaires. En d'autres termes, si vous avez déjà un shield XBee, vous n'aurez probablement pas besoin d'acheter le shield SparkFun utilisé ici.

L'utilisation du shield XBee avec le module WiFi Microchip a rendu le montage assez facile. Cependant, j'ai identifié un problème avec cette combinaison. Travailler avec la radio est extrêmement complexe, considéré par certains comme de la « magie vaudou ». J'ai remarqué que pendant que l'adaptateur WiFi est allumé et transmet des données, une forte interférence se produit sur le signal audio mesuré par l'ADC de l'Arduino. Je n'ai pas pu identifier précisément la source, mais deux hypothèses : les pics de consommation du module (jusqu'à 240 mA) ne sont pas correctement découplés et compromettent la tension de référence fournie à l'ADC de l'Arduino ; ou le signal émis par l'antenne est capté par des broches exposées juste sous le module. Habituellement, les fabricants de modules WiFi conseillent d'éviter de placer quoi que ce soit (même des plans de masse) près de l'antenne pour prévenir ce genre de problème.

Pour corriger ce problème, j'ai soudé un régulateur 3,3V et un condensateur électrolytique 10µF sur le shield SparkFun afin qu'ils fournissent la tension de référence à l'ADC de l'Arduino. La même source alimente le microphone électret SparkFun. Cela a résolu les problèmes de volume de pointe que je voyais dans le BitVoicer Server Manager. Même pendant les périodes de silence, le niveau audio montait jusqu'à 35 (0-100) dans le moniteur serveur. Si vous observez la même chose, investiguez le signal audio mesuré par l'ADC de l'Arduino.

J'ai aussi décidé d'utiliser l'espace de prototypage du shield SparkFun pour souder quelques LEDs indiquant l'état de certaines fonctionnalités BitVoicer Server. Sur l'image ci-dessous, de gauche à droite :

• Indique si BitVoicer Server tourne et/ou si la connexion reste active ;
• Indique si le service de transfert de données tourne ;
• Indique si un moteur de reconnaissance vocale a été assigné à l'Arduino ;
• Indique si nous sommes dans la période d'activation par mot-clé. Cette LED s'allume seulement quand le mot d'activation est reconnu.

Concernant le microphone électret pré-amplifié, de nombreuses options existent : SparkFun, Adafruit, RoboCore, Hackerstore, etc. Pour utiliser le code de ce tutoriel, assurez-vous que le microphone est analogique, que la tension requise est disponible sur votre Arduino, et que l'amplification est suffisante (généralement 100x pour les micros électret) pour l'ADC de l'Arduino.

Le châssis 2WD utilisé est l'un des moins chers et plus populaires sur eBay. Le kit complet contient : une plateforme acrylique, deux roues plastique/caoutchouc, une roue folle 360°, deux moteurs CC avec réducteur (ratio 1:48), un support 4 piles AA, deux disques encodeurs de vitesse et un jeu de vis.

ÉTAPE 2 : Montage

Au travail ! Montez tous les composants sur le châssis comme montré dans les images ci-dessous.

Si vous ne voulez pas souder les LEDs et le régulateur sur le shield XBee, vous pouvez les monter sur une petite plaque d'essai comme montré ci-dessous. Choisissez une plaque de taille réduite pour la fixer quelque part sur le châssis sans problème.

Sur les photos, vous noterez que j'ai fait un support en fil de fer pour tenir le microphone. J'ai aussi collé une bande de feutre autour de la roue folle 360°. Ces deux mesures visent à réduire le bruit généré par le robot et capté par le microphone quand il bouge. J'ai même découpé un petit morceau de mousse pour isoler les fils du microphone du support. Ce n'était pas 100% efficace, mais a réduit un peu le bruit et amélioré la précision de la reconnaissance vocale.

ÉTAPE 3 : Configuration du module WiFi

Comme dit à l'étape 1, le module WiFi Microchip RN171VX peut être entièrement opéré via le port série. Cela rend la configuration très facile car toutes les commandes sont de simples chaînes envoyées via le port série de l'Arduino. Il suffit d'envoyer une chaîne contenant « $$$ » pour entrer en mode commande, d'envoyer les commandes, puis d'envoyer « exit » pour revenir en mode données.

Le code nommé WiFi Module Setup en bas de ce tutoriel est celui que j'ai utilisé pour configurer le module WiFi sur mon réseau domestique. Vous devrez remplacer les parties marquées « XXXXXX » par les informations de votre réseau WiFi. Trois commandes doivent être modifiées :

• set wlan ssid XXXXXX : remplacez XXXXXX par le nom de votre réseau (SSID) ;
• set wlan phrase XXXXXX : remplacez XXXXXX par votre mot de passe réseau ;
• set ip address XXXXXX : remplacez XXXXXX par l'adresse IP (statique) que vous souhaitez attribuer à votre module WiFi.

Sur mon réseau, l'authentification est WPA2-PSK. Si votre réseau utilise une autre méthode, vous devrez aussi changer la commande set wlan auth. Consultez la documentation du module WiFi (section 4.3 Set Commands) pour trouver la valeur correcte.

Détail important sur le shield SparkFun et son petit interrupteur (image ci-dessous). Pour téléverser du code sur l'Arduino via son interface USB, l'interrupteur doit être en position DLINE. Pour que l'Arduino envoie/reçoive des données via le module WiFi en utilisant son port série, l'interrupteur doit être en position UART. C'est nécessaire car le module WiFi et la puce USB de l'Arduino UNO utilisent le même port série de l'ATmega. Si l'interrupteur est sur UART et que vous essayez de téléverser, l'IDE Arduino affichera une erreur.

Pour téléverser le code WiFi Module Setup et permettre à l'Arduino de configurer le module WiFi, suivez ces étapes :

1. Mettez l'interrupteur en position DLINE ;
2. Ouvrez l'IDE Arduino, collez et téléversez le code ;
3. Dès que le téléversement se termine, vous avez 5 secondes (délai au début du code) pour basculer l'interrupteur sur UART avant l'envoi des commandes au module WiFi. Si la première commande est perdue, aucune des autres ne fonctionnera. Dans ce cas, réinitialisez simplement l'Arduino pour relancer le sketch depuis le début.

Pendant la configuration du module (environ 25 secondes), les LEDs du module clignotent différemment de leur motif standard. À ce moment, vous saurez que le module est en cours de configuration.

Après la configuration, essayez de faire un ping (Invite de commandes → « ping [Adresse IP] » → Entrée) sur le module avec l'adresse IP spécifiée dans set ip address. Si vous n'obtenez pas de réponse, quelque chose s'est mal passé aux étapes précédentes.

ÉTAPE 4 : Planifier les mouvements du robot

Bien que le robot n'ait que deux moteurs CC, il peut effectuer une série de mouvements complexes. Pour garder ce tutoriel simple, j'ai choisi de définir seulement une trentaine de mouvements uniformes de base et quelques mouvements complexes combinant les mouvements de base.

Comme vous le voyez dans les photos de l'étape 2, je n'utilise pas de capteurs de rotation sur les roues, de capteurs ultrasons ou d'autres capteurs pour mesurer la distance aux objets ou la distance parcourue. Cela empêche le robot d'effectuer des mouvements de haute précision. Cependant, en contrôlant seulement la direction et la vitesse des moteurs, on atteint une précision suffisante pour déplacer le robot.

La première chose à savoir pour calculer le temps d'exécution nécessaire à chaque mouvement est la vitesse moyenne du robot. Pour cela, placez un mètre ruban parallèlement au robot et activez les deux moteurs simultanément pendant une ou deux secondes, mesurez la distance parcourue et déduisez la vitesse. Dans ma configuration, j'ai obtenu 13,7 cm/s en utilisant 62,5% de la vitesse maximale du moteur (250/400, voir bibliothèque Arduino Pololu). En d'autres termes, pour avancer de 1 mètre (100 cm), les moteurs doivent être activés simultanément pendant 7,299270… secondes. J'ai choisi de garder le comptage en millisecondes, mais pour une précision plus élevée, envisagez les microsecondes. En résumé, pour avancer de 1 mètre, j'active les deux moteurs pendant 7299 ms. De là, tout devient règle de trois pour les autres distances. Pour des mouvements en arc ou circulaires, une roue doit tourner plus vite que l'autre. Pour tourner sur place, une seule roue tourne ou les deux en sens inverse. Il faudra utiliser un peu de trigonométrie pour calculer la distance parcourue par chaque roue et la durée d'activation de chaque moteur. Un bon point de départ pour ces concepts se trouve aux liens suivants (je n'irai pas plus loin ici) : CirclePath et Move two-wheeled robot.

À la fin de la vidéo ci-dessous, je fais aussi « dessiner » au robot quelques formes géométriques de base (carré, triangle, cercle) au sol. Ces mouvements sont obtenus en combinant des mouvements de base (ex. avancer, tourner, avancer, tourner…). La combinaison est faite dans le Voice Schema de BitVoicer Server et ne figure pas dans le sketch Arduino présenté à l'étape suivante.

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

Dans cette étape, vous téléverserez le sketch nommé Robot Source Code (BVS_Demo3.ino) en bas de ce tutoriel. Vous pouvez aussi le télécharger depuis le lien fourni. Rappelez-vous que pour envoyer du code à l'Arduino, l'interrupteur du shield SparkFun doit être en position DLINE comme décrit à l'étape 3. Avant de téléverser, vous devez installer correctement les bibliothèques BitVoicer Server et Pololu motor driver dans l'IDE Arduino (Importation d'une bibliothèque .zip).

Robot Source Code : BVS_Demo3.ino

Certaines parties de ce sketch ressemblent à des parties utilisées dans un tutoriel précédent et gèrent la communication avec BitVoicer Server (classes BVSP et BVSMic). Ici, je me concentrerai sur les nouvelles parties. Pour plus d'infos sur BVSP et BVSMic, reportez-vous au tutoriel mentionné.

• Déclaration des constantes : au début du sketch, je déclare une série de constantes. Le groupe des constantes de réglages moteurs définit les vitesses par défaut et deux constantes de direction. La bibliothèque Pololu accepte des valeurs de -400 à +400 pour la vitesse (0 = arrêt). Les valeurs négatives indiquent rotation inverse (ou, si vous avez inversé les fils des moteurs comme moi, rotation avant). Le groupe des constantes de valeurs de commande correspond aux commandes envoyées depuis BitVoicer Server. Dans ce sketch, j'ai défini 40 commandes de base de type byte, mais des mouvements plus complexes peuvent être combinés.
• Variables de contrôle d'exécution : cinq variables contrôlent l'exécution des commandes (motorSpeed, cmdDuration, cmdStartTime, cmdRunning, lastFwdCmd). motorSpeed contient la vitesse actuelle, mise à jour avec une des valeurs par défaut si l'Arduino reçoit une commande de changement de vitesse. cmdDuration contient la durée totale de la commande en cours, comparée à cmdStartTime à chaque itération de loop si cmdRunning est true. Si le temps expire, RunCommand est appelé pour arrêter les moteurs. lastFwdCmd mémorise la dernière commande « avancer » pour permettre la commande « revenir » (après avoir fait demi-tour).
• Connexion WiFi : à la fin du sketch, deux fonctions gèrent la connexion/déconnexion à BitVoicer Server (Connect et Disconnect). Elles mettent le module WiFi en mode commande, ouvrent/ferment une connexion TCP/IP et remettent le module en mode données. Dans loop, si connected n'est pas true, j'appelle Connect. Si la classe BVSP signale que le statut serveur a expiré (pas de réponse à la dernière requête), je considère la connexion perdue et j'appelle Disconnect, forçant une nouvelle tentative à l'itération suivante.
• Fonction RunCommand : appelée à chaque commande reçue du serveur. Prend une valeur byte correspondant à une des commandes de base définies par les constantes. Chaque commande est identifiée dans un switch pour régler les vitesses moteurs appropriées et la durée. À la fin, cmdRunning passe à true et millis() est stocké dans cmdStartTime. Les durées en millisecondes pour chaque commande ont été obtenues comme décrit à l'étape précédente.

ÉTAPE 6 : Configurer BitVoicer Server

Ici, vous devez construire le Voice Schema de BitVoicer Server avec les phrases à reconnaître et les commandes à envoyer à l'Arduino. À la fin de cette étape, deux liens vers des fichiers contenant tous les Solution Objects BitVoicer Server utilisés. Si vous ne voulez pas créer tous les objets un par un, vous pouvez les importer (Importing Solution Objects) via ces fichiers.

Avant de construire le Voice Schema, créez un dispositif représentant l'Arduino dans BitVoicer Server. Créez un dispositif mixte nommé ArduinoUnoWiFi. Dans l'onglet Communication, sélectionnez TCP/IP et entrez l'adresse IP assignée au module WiFi à l'étape 3. Dans l'onglet Cues, activez les cues Start of Activated Period et End of Activated Period. Sélectionnez des commandes Int16 SendData pour les deux cues et choisissez le dispositif ArduinoUnoWiFi comme cible. Dans le champ Data, entrez 1 pour Start of Activated Period et 0 pour End of Activated Period. Ces cues feront allumer une LED sur l'Arduino à chaque reconnaissance du mot d'activation. Quand la période d'activation (définie dans le Voice Schema) expire, la LED s'éteint.

Construisons maintenant le Voice Schema. Bien que le robot n'ait que 40 commandes de base, vous voudrez peut-être créer de nombreuses combinaisons de mots déclenchant la même commande. Exemple : « avance d'un mètre » et « va devant d'un mètre » déclenchent la même commande. Vous voudrez aussi créer des commandes complexes comme « fais un carré » qui enverra une série de commandes temporisées en séquence. Votre Voice Schema peut donc grossir et avoir bien plus de 40 commandes de base. BitVoicer Server supporte un nombre illimité de phrases (le mien en a fini avec plus de 80). Deux astuces : créez une commande par défaut dans les Options du BitVoicer Server Manager ; copiez-collez les commandes dupliquées d'une phrase à l'autre.

Les commandes de phrase enverront des données de type byte à l'Arduino. Utilisez les constantes définies au début du sketch pour savoir quelle valeur envoyer pour chaque commande. Les commandes complexes enverront plusieurs valeurs en séquence ; vous devrez contrôler l'intervalle (délai) entre elles pour qu'aucune valeur ne soit envoyée pendant l'exécution de la commande précédente. Utilisez le champ delay pour régler l'intervalle.

Fichiers Solution Objects :

• Device.sof
• VoiceSchema.sof

ÉTAPE 7 : Conclusion

Il ne reste plus qu'à mettre les piles AA et connecter la pile 9V sur la prise d'alimentation de l'Arduino pour donner vie à votre robot ! Après avoir téléversé le code, n'oubliez pas de mettre l'interrupteur du shield SparkFun sur UART. Sinon, le module WiFi ne recevra aucune donnée envoyée depuis le port série de l'Arduino.

Après mise sous tension, les LEDs de statut mettront un moment à s'allumer. Vous verrez le module WiFi démarrer la communication et quand la connexion TCP/IP sera établie, une des LEDs du module deviendra fixe. Après quelques instants, trois des quatre LEDs de statut s'allumeront. Cela signifie qu'un moteur de reconnaissance vocale a été assigné à l'Arduino. Désormais, le robot est prêt à recevoir des commandes.

Après quelques tests, j'étais assez satisfait de la reconnaissance vocale, bien qu'elle ne reconnaisse pas 100% des commandes tout le temps. Sur ce point, BitVoicer Server m'a vraiment surpris. En revanche, je n'étais pas totalement satisfait de la précision des mouvements du robot. Pour corriger, il faudrait ajouter des capteurs de rotation aux roues. Le châssis utilisé fournit déjà des disques encodeurs qui peuvent être fixés sur le réducteur. L'ajout de capteurs sur ces disques permettrait de déplacer le robot selon la distance réellement parcourue, pour des mouvements plus précis. On pourrait aussi ajouter des capteurs ultrasons pour éviter les meubles. Je le ferai probablement un jour, mais pour l'instant, je vous laisse faire.

À la prochaine !

Code

Configuration module WiFi

void setup() {
  Serial.begin(115200);
  pinMode(13, OUTPUT);
  delay(5000);
  Serial.print("$$$");
  delay(1000);
  Serial.println("set wlan auth 4");
  delay(1000);
  Serial.println("set wlan phrase XXXXXX");
  delay(1000);
  Serial.println("set wlan ssid XXXXXX");
  delay(1000);
  Serial.println("set wlan channel 0");
  delay(1000);
  Serial.println("set wlan join 1");
  delay(1000);
  Serial.println("set wlan tx 0");
  delay(1000);
  Serial.println("set ip dhcp 0");
  delay(1000);
  Serial.println("set ip address XXXXXX");
  delay(1000);
  Serial.println("set comm remote 0");
  delay(1000);
  Serial.println("set comm close 0");
  delay(1000);
  Serial.println("set comm open 0");
  delay(1000);
  Serial.println("set comm size 500");
  delay(1000);
  Serial.println("set comm time 50");
  delay(1000);
  Serial.println("set uart baud 115200");
  delay(1000);
  Serial.println("set uart flow 0");
  delay(1000);
  Serial.println("save");
  delay(1000);
  Serial.println("exit");
  delay(1000);
  digitalWrite(13, LOW);
}
void loop() { }

Code source du robot

#include 
#include 
#include 

// Broches Arduino pour LEDs et capture audio
#define BVS_RUNNING 2
#define BVS_SRE 5
#define BVS_DATA_FWD 3
#define BVS_ACT_PERIOD 6
#define BVSM_AUDIO_INPUT 3

// Paramètres BVSP
const unsigned long STATUS_REQUEST_INTERVAL = 2000;
const unsigned long STATUS_REQUEST_TIMEOUT = 1000;
const int MIC_BUFFER_SIZE = 64;

BVSP bvsp = BVSP();
BVSMic bvsm = BVSMic();
DualMC33926MotorShield ms = DualMC33926MotorShield();
byte micBuffer[MIC_BUFFER_SIZE];
boolean connected = false;

// Réglages moteurs
const int SPEED_STOP = 0;
const int SPEED_SLOW = 100;
const int SPEED_NORMAL = 250;
const int SPEED_FAST = 400;
const int DIRECTION_FRONT = -1;
const int DIRECTION_BACK = 1;

int motorSpeed = SPEED_NORMAL;
unsigned long cmdDuration = 0;
unsigned long cmdStartTime = 0;
bool cmdRunning = false;
byte lastFwdCmd = 0;

// Commandes (byte)
const byte CMD_STOP = 0;
const byte CMD_MOVE_FORWARD = 1;
const byte CMD_MOVE_FORWARD_1_CM = 2;
// ... (toutes les constantes de commande jusqu'à 39)
const byte CMD_TURN_RIGHT_45_BACKWARD = 39;

void setup() {
  Serial.begin(115200);
  pinMode(BVS_RUNNING, OUTPUT);
  pinMode(BVS_SRE, OUTPUT);
  pinMode(BVS_DATA_FWD, OUTPUT);
  pinMode(BVS_ACT_PERIOD, OUTPUT);
  AllLEDsOff();
  bvsp.begin(Serial, STATUS_REQUEST_TIMEOUT, STATUS_REQUEST_INTERVAL);
  bvsp.frameReceived = BVSP_frameReceived;
  bvsm.begin();
  ms.init();
}

void loop() {
  if (!connected) {
    Connect(Serial);
    connected = true;
    bvsp.reset();
  }
  bvsp.keepAlive();
  bvsp.receive();
  digitalWrite(BVS_RUNNING, bvsp.isBVSRunning());
  digitalWrite(BVS_DATA_FWD, bvsp.isDataFwdRunning());
  if (bvsp.isSREAvailable()) {
    digitalWrite(BVS_SRE, HIGH);
    if (!bvsm.isRecording) {
      bvsm.setAudioInput(BVSM_AUDIO_INPUT, EXTERNAL);
      bvsm.startRecording();
    }
    if (bvsm.available) {
      if (bvsp.inboundMode == FRAMED_MODE) bvsp.setInboundMode(STREAM_MODE);
      int bytesRead = bvsm.read(micBuffer, MIC_BUFFER_SIZE);
      bvsp.sendStream(micBuffer, bytesRead);
    }
  } else {
    digitalWrite(BVS_SRE, LOW);
    digitalWrite(BVS_ACT_PERIOD, LOW);
    if (bvsm.isRecording) bvsm.stopRecording();
  }
  if (bvsp.hasStatusTimedOut()) {
    if (bvsm.isRecording) bvsm.stopRecording();
    Disconnect(Serial);
    AllLEDsOff();
    connected = false;
  }
  if (cmdRunning && millis() - cmdStartTime >= cmdDuration) RunCommand(CMD_STOP);
}

void BVSP_frameReceived(byte dataType, int payloadSize) {
  switch (dataType) {
    case DATA_TYPE_BYTE:
      RunCommand(bvsp.getReceivedByte());
      break;
    case DATA_TYPE_INT16:
      digitalWrite(BVS_ACT_PERIOD, bvsp.getReceivedInt16());
      break;
  }
}

void RunCommand(byte cmd) {
  switch (cmd) {
    case CMD_STOP:
      ms.setSpeeds(SPEED_STOP, SPEED_STOP);
      cmdRunning = false;
      return;
    case CMD_MOVE_FORWARD:
      lastFwdCmd = cmd;
      ms.setSpeeds(motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT);
      cmdDuration = 60000;
      break;
    // ... (tous les cas pour chaque commande, avec durées calculées)
    case CMD_SET_SPEED_SLOW:
      motorSpeed = SPEED_SLOW;
      return;
    case CMD_SET_SPEED_NORMAL:
      motorSpeed = SPEED_NORMAL;
      return;
    case CMD_SET_SPEED_FAST:
      motorSpeed = SPEED_FAST;
      return;
  }
  cmdStartTime = millis();
  cmdRunning = true;
}

void Connect(HardwareSerial &serialPort) {
  serialPort.print("$$$");
  delay(500);
  serialPort.println("open 192.168.0.11 4194"); // IP du serveur et port TCP
  delay(1000);
  serialPort.println("exit");
  delay(500);
}

void Disconnect(HardwareSerial &serialPort) {
  serialPort.print("$$$");
  delay(500);
  serialPort.println("close");
  delay(1000);
  serialPort.println("exit");
  delay(500);
}

void AllLEDsOff() {
  digitalWrite(BVS_RUNNING, LOW);
  digitalWrite(BVS_SRE, LOW);
  digitalWrite(BVS_DATA_FWD, LOW);
  digitalWrite(BVS_ACT_PERIOD, LOW);
}

Schémas