Robot à commande vocale 2WD avec serveur Arduino et BitVoicer

Outils et machines nécessaires

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

Applications et services en ligne

À propos de ce projet

Dans ce tutoriel, je vais montrer comment construire un robot à commande vocale 2WD. Bien que je ne contrôle que des moteurs à courant continu pour déplacer le robot, la même approche peut être utilisée pour la commande vocale des moteurs pas à pas et des servomoteurs, donc si vous envisagez de construire un robot à commande vocale qui effectue des mouvements mécaniques, ce didacticiel peut servir de référence pour votre projet.

Pour construire ce robot, vous aurez essentiellement besoin d'un châssis à 2 roues, d'une carte Arduino, d'un bouclier de pilote de moteur à courant continu, d'une licence BitVoicer Server, d'un module WiFi et d'un microphone pré-amplifié. En ce qui concerne les composants, il en existe une grande variété sur le marché et vous pouvez obtenir les mêmes résultats en utilisant différentes combinaisons. À l'étape 1, je donne quelques détails sur certains composants utilisés dans le robot, donc si vous devez en modifier certains, recherchez simplement des composants ayant des caractéristiques similaires.

Les procédures suivantes seront exécutées pour transformer les commandes vocales en mouvements du robot :

• 1. Les ondes audio seront capturées et amplifiées par la carte Sparkfun Electret Breakout ;
• 2. Le signal amplifié sera numérisé et mis en mémoire tampon dans l'Arduino à l'aide de son convertisseur analogique-numérique (ADC) ;
• 3. Les échantillons audio seront diffusés sur BitVoicer Server à l'aide du module Microchip WiFi ;
• 4. BitVoicer Server traitera le flux audio et reconnaîtra la parole qu'il contient ;
• 5. La parole reconnue sera mappée sur des commandes prédéfinies qui seront envoyées à l'Arduino ;
• 6. L'Arduino identifiera la commande et définira quels moteurs à courant continu seront utilisés, pendant combien de temps et à quelle vitesse ;
• 7. Le pilote de moteur sera activé pour fournir la tension et le courant requis pour déplacer les moteurs.

Liste des matériaux :

• Arduino UNO :~25,00 $
• Bouclier de pilote de moteur Pololu Dual MC33926 :29,95 US
• Bouclier SparkFun XBee :14,95 USD
• Module de puce RN171VX avec antenne :34,95 USD
• Répartition du microphone à électret SparkFun :7,95 USD
• BitVoicer Server 1.0 :8,90 USD
• Châssis de voiture-robot à 2 roues motrices :15,95 USD
• Régulateur de tension Texas Instruments LM1117 (TO-220) :~ 1,95 USD
• Condensateur électrolytique 10μF :~0,35 USD
• 4 LED :~ 1,00 US
• 4 résistances de 330 ohms :~ 0,75 USD
• 4 piles AA 1,5 V :~ 2,00 US
• Batterie 9 V :~ 2,00 US
• Adaptateur 9 V vers Barrel Jack :~ 2,50 US
• Câbles de pontage et fils normaux :~ 2,00 $ US
• Vis et pince en plastique souple pour la fixation
• Fer à souder et soudure

ÉTAPE 1 :Apprendre à 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.

En premier lieu, le cœur du robot :un Arduino UNO R3. Bien que j'utilise un Arduino UNO, vous pouvez utiliser d'autres cartes Arduino pour monter votre robot. J'ai décidé d'utiliser un Arduino UNO car c'est de loin la carte Arduino la plus populaire et plus de gens seraient capables de reconstruire ce robot. Si vous avez un Arduino DUE, vous pouvez également ajouter des réponses vocales à votre robot comme je l'ai fait dans ce tutoriel.

Pour déplacer les moteurs à courant continu, j'ai utilisé ce bouclier Pololu. Il s'agit d'un pilote de moteur double capable de contrôler des moteurs de 5 à 28 V CC et de fournir jusqu'à 3 A de courant continu par moteur. Bien que je pense que c'est un très bon bouclier, ce qui m'a le plus impressionné dans les produits Pololu, c'est leur documentation claire et détaillée. En outre, Pololu fournit une bibliothèque Arduino qui permet de contrôler très simplement les moteurs. Il suffit de passer la vitesse et la direction (valeurs négatives ou positives) au setSpeeds une fonction. Si vous choisissez d'utiliser un autre pilote de moteur à courant continu, faites attention aux broches utilisées par le pilote car elles ne peuvent entrer en conflit avec aucune autre broche utilisée par le robot. Le shield Pololu utilise les broches Arduino suivantes :numérique 4, 7, 8, 9, 10 et 12; 0 et 1 analogiques; terre; et 5V. L'aspect le plus important ici est que seules les broches 9 et 10 sont utilisées comme broches PWM et la minuterie utilisée pour générer des impulsions sur ces broches n'est pas la même minuterie (minuterie 2 sur l'UNO) utilisée par la classe BVSMic de BitSophia.

Pour établir la communication avec le serveur et accéder aux services BitVoicer Server, j'utilise le module Microchip WiFi RN171VX. Deux caractéristiques principales ressortent de ce module :toutes les communications peuvent se faire via le port série de manière simple; et le module a le même facteur de forme que la plupart des modules XBee populaires. En d'autres termes, si vous possédez déjà un shield XBee, vous n'aurez probablement pas besoin d'acheter le shield Sparkfun que j'utilise dans ce robot.

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

Pour corriger le problème décrit ci-dessus, j'ai soudé un régulateur de tension de 3,3 V et un condensateur électrolytique de 10 F au blindage Sparkfun afin qu'ils puissent fournir la tension de référence à l'Arduino ADC. La même source d'alimentation est utilisée par le microphone à électret Sparkfun. Cela a résolu les problèmes de volume de pointe que je voyais dans le gestionnaire de serveur BitVoicer. Même pendant les périodes de silence, le niveau audio atteignait 35 (0-100) dans le moniteur de serveur. Si vous voyez la même chose se produire dans votre projet, étudiez ce qui se passe avec le signal audio mesuré par l'Arduino ADC.

J'ai décidé que j'allais également utiliser l'espace de prototypage disponible dans le shield Sparkfun pour souder quelques LED qui indiquent l'état de certaines fonctionnalités du serveur BitVoicer. Dans l'image ci-dessous, de gauche à droite, les informations suivantes sont exposées par les LED :

• Indique si BitVoicer Server est en cours d'exécution et/ou si la connexion reste active ;
• Indique si le service de transfert de données est en cours d'exécution ;
• Indique si un moteur de reconnaissance vocale a été attribué à l'Arduino ;
• Indique si nous sommes dans la période d'activation-word-activated. Cette LED ne s'allume que lorsque le mot d'activation est identifié.

Concernant le microphone électret préamplifié, il existe de nombreuses options disponibles sur le marché :Sparkfun, Adafruit, RoboCore, Hackerstore et probablement bien d'autres. Pour utiliser le code que je publie sur ce tutoriel, assurez-vous que le microphone que vous achetez est analogique, que la tension requise est disponible dans votre carte Arduino et que l'amplification est suffisamment élevée (généralement 100x pour les microphones à électret) pour l'Arduino ADC.

Le châssis 2WD utilisé dans le robot est l'un des moins chers et des plus populaires sur ebay. Le kit complet contient une plate-forme en acrylique, deux roues en plastique/caoutchouc, une roue 360º, deux moteurs à courant continu avec engrenage (rapport 1:48), un support de batterie 4xAA, deux disques d'encodeur de vitesse et un jeu de vis.

ÉTAPE 2 : Montage

Mettons-nous au travail! Dans cette étape, vous devez monter tous les composants sur le châssis comme indiqué dans les images ci-dessous.

Si vous ne souhaitez pas souder les LED et le régulateur de tension sur le shield XBee, vous pouvez les monter sur une petite maquette comme le montre l'image ci-dessous. Dans ce cas, choisissez une maquette de taille réduite afin de pouvoir la fixer quelque part sur le châssis sans autre problème.

Sur les photos ci-dessus, vous pouvez noter que j'ai réalisé un support en fil de fer pour tenir le microphone. Vous pouvez également voir que j'ai collé une bande de tissu feutré autour de la roue à 360º. J'ai pris ces deux mesures pour essayer de réduire le bruit généré par le robot et capté par le microphone lorsque le robot se déplace. J'ai même coupé un petit morceau d'éponge pour isoler les fils du micro du support. Bien sûr, ce n'était pas efficace à 100 %, mais cela a réduit un peu le bruit et amélioré la précision de la reconnaissance vocale.

ÉTAPE 3 :Configuration du module Wi-Fi

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

Le code nommé Configuration du module WiFi au bas de ce tutoriel se trouve le code que j'ai utilisé pour configurer le module WiFi dans mon réseau domestique. Vous devrez modifier les parties du code marquées « XXXXXX » avec les informations de votre réseau WiFi. Trois commandes devront être modifiées :

• définir wlan ssid XXXXXX :remplacez le XXXXXX par votre nom de réseau (SSID) ;
• définir la phrase WLAN XXXXXX :remplacez le XXXXXX par votre mot de passe réseau ;
• définir l'adresse IP XXXXXX :remplacez le XXXXXX par l'adresse IP (statique) que vous souhaitez paramétrer sur votre module WiFi.

Dans mon réseau WiFi, la méthode d'authentification est WPA2-PSK. Si votre réseau utilise une méthode d'authentification différente, vous devrez également modifier le set wlan auth commander. Consultez la documentation du module WiFi (section 4.3 Définir les commandes) pour savoir quelle valeur est la bonne pour votre réseau.

Il y a un important détail sur le shield Sparkfun et son petit interrupteur (photo ci-dessous). Pour télécharger du code sur l'Arduino à l'aide de son interface USB, le commutateur doit être réglé sur la position DLINE. Pour que l'Arduino envoie/reçoive des données via le module WiFi en utilisant son port série, le commutateur doit être réglé sur la position UART. Cela est nécessaire car le module WiFi et la puce USB de l'Arduino UNO utilisent le même port série dans le microcontrôleur ATmega. Si le commutateur est réglé sur UART et que vous essayez de télécharger du code sur l'Arduino, un message d'erreur s'affichera dans l'IDE Arduino.

Pour télécharger la Configuration du module Wi-Fi  code à l'Arduino et permettre à l'Arduino de configurer le module WiFi, suivez les étapes ci-dessous :

• 1. Réglez le commutateur sur la position DLINE ;
• 2. Ouvrez l'IDE Arduino, collez et téléchargez le code sur l'Arduino ;
• 3. Dès que le téléchargement est terminé, vous aurez 5 secondes (délai au début du code) pour passer le commutateur en position UART avant que les commandes ne soient envoyées au module WiFi. Si la première commande est perdue, aucune des autres ne fonctionnera. Dans ce cas, réinitialisez simplement l'Arduino pour que l'esquisse puisse recommencer depuis le début.

Pendant la configuration du module, qui prend environ 25 secondes, les LED du module clignoteront différemment de son modèle standard. À ce moment, vous saurez que le module WiFi est en cours de configuration.

Une fois le module configuré, essayez de cingler (Invite de commandes --> « ping [Adresse IP] » --> appuyez sur Entrée) le module en utilisant l'adresse IP spécifiée dans définir l'adresse IP commander. Si vous n'obtenez pas de réponse du module, une erreur s'est produite lors des étapes précédentes.

ÉTAPE 4 : Planifier les mouvements du robot

Bien que le robot ne dispose que de deux moteurs à courant continu, il est capable d'effectuer une série de mouvements complexes. Pour garder ce tutoriel aussi simple que possible, j'ai choisi de définir seulement environ trois douzaines de mouvements uniformes de base et quelques mouvements complexes formés par la combinaison des mouvements de base.

Comme vous pouvez le voir sur les images de l'étape 2, je n'utilise pas de capteurs de rotation dans les roues, de capteurs à ultrasons ou tout autre type de capteur pour mesurer la distance par rapport aux objets ou la distance parcourue. Cela empêche le robot d'effectuer des mouvements de haute précision. Cependant, en contrôlant uniquement la direction et la vitesse des moteurs, vous pouvez atteindre un niveau de précision suffisamment bon pour déplacer le robot.

La première chose que vous devez savoir pour pouvoir calculer le temps d'exécution nécessaire pour 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 en déduire la vitesse. Dans ma configuration, j'ai obtenu 13,7 centimètres par seconde en utilisant 62,5% de la vitesse maximale du moteur (250/400, voir la bibliothèque Pololu Arduino). En d'autres termes, pour avancer le robot de 1 mètre (100 cm) en avant, les moteurs devaient être activés simultanément pendant 7,299270… secondes. J'ai choisi de conserver le comptage du temps dans la résolution en millisecondes, mais si vous souhaitez obtenir une précision de mouvement plus élevée, envisagez d'augmenter la résolution à des microsecondes. Pour faire court, pour déplacer le robot de 1 mètre, je dois activer les deux moteurs simultanément pendant 7299 millisecondes. A partir de ce nombre, tout devient règle de trois pour les autres distances. Pour effectuer des mouvements en arc ou circulaires, une roue doit se déplacer plus rapidement que l'autre. Pour faire tourner le robot sur les côtés, une seule roue doit être activée ou les deux dans des directions opposées (pour tourner sur son propre axe). Ici, vous devrez utiliser une trigonométrie pour déterminer la distance parcourue par chaque roue et pendant combien de temps chaque moteur doit être activé. Un bon point de départ pour ces concepts peut être trouvé dans les liens suivants (je n'ai pas l'intention d'aller plus loin ici) :http://rossum.sourceforge.net/papers/CalculationsForRobotics/CirclePath.htm et http://math .stackexchange.com/questions/60176/move-two-wheeled-robot-from-one-point-to-another.

Comme vous pouvez le voir à la fin de la vidéo ci-dessous, je fais également "dessiner" au robot des formes géométriques de base (carré, triangle et cercle) sur le sol. Ces mouvements sont obtenus par la combinaison de mouvements de base (par exemple, avancer, tourner, avancer, tourner, etc.). La combinaison de ces mouvements est faite dans le schéma de voix du serveur BitVoicer et vous ne les verrez pas dans le croquis Arduino présenté à l'étape suivante.

ÉTAPE 5 : Téléchargement du code sur l'Arduino

Dans cette étape, vous devrez télécharger le croquis nommé Robot Source Code , situé au bas de ce didacticiel, à l'Arduino. Vous pouvez également télécharger le croquis Arduino à partir du lien ci-dessous. N'oubliez pas que pour envoyer du code à l'Arduino, vous devez régler le commutateur du bouclier Sparkfun sur la position DLINE comme décrit à l'étape 3. Avant de télécharger le code, vous devez installer correctement le serveur BitVoicer et les bibliothèques de pilotes de moteur Pololu dans l'IDE Arduino. (Importation d'une bibliothèque .zip).

Code source du robot :BVS_Demo3.ino

Certaines parties de ce croquis sont similaires aux parties que j'ai utilisées dans l'un de mes tutoriels précédents et traitent de la communication avec BitVoicer Server (classes BVSP et BVSMic). Dans ce tutoriel, je m'en tiendrai à l'explication des nouvelles parties du croquis. Si vous souhaitez obtenir plus d'informations sur l'utilisation des classes BVSP et BVSMic, je vous suggère de vous référer au tutoriel que j'ai mentionné ci-dessus.

• Déclaration des constantes :au début du sketch, je déclare une série de constantes utilisées tout au long du code. Le groupe de constantes avec les paramètres du moteur définit les vitesses du moteur par défaut et les deux constantes de direction. La bibliothèque de pilotes de moteur Pololu accepte des valeurs de -400 à +400 pour la vitesse du moteur, où zéro signifie éteint. Les valeurs négatives indiquent une rotation inverse ou, si vous avez inversé les fils du moteur comme moi, une rotation avant. Le groupe de constantes avec des valeurs de commande fait référence aux commandes qui seront envoyées depuis BitVoicer Server. Dans cette esquisse, je n'ai défini que 40 commandes de base de byte taper, mais des mouvements plus complexes peuvent être effectués en combinant ces commandes.
• Variables de contrôle d'exécution :cinq variables sont définies au début du code pour contrôler l'exécution des commandes (motorSpeed , cmdDurée , cmdStartTime , cmdRunning et lastFwdCmd ). Le motorSpeed ​​ variable maintient la vitesse actuelle du moteur. Cette variable est mise à jour avec l'une des valeurs par défaut définies par les constantes de vitesse si l'Arduino reçoit une commande du serveur BitVoicer pour mettre à jour les vitesses du moteur. La cmdDurée variable contient la durée totale de la commande en cours. Cette variable est vérifiée par rapport au cmdStartTime variable dans toutes les itérations de la boucle fonction si cmdRunning est vrai . Si le temps d'exécution de la commande a expiré, la RunCommand fonction est appelée pour arrêter les moteurs. Le lastFwdCmd La variable contient la dernière commande « aller/avancer ». Cette variable est utilisée pour connaître la dernière distance parcourue afin que la commande « revenir » puisse être exécutée. Notez que pour utiliser cette commande, vous devez d'abord dire au robot de se retourner.
• Connexion Wi-Fi :à la fin du sketch je définis deux fonctions pour se connecter et se déconnecter de BitVoicer Server (Connect et Déconnecter ). Ces fonctions mettent le module Microchip WiFi en mode commande, ouvrent ou ferment une connexion TCP/IP et remettent le module en mode données. Dans la boucle fonction, si la variable connectée n'est pas true , j'appelle le Connect une fonction. Si la classe BVSP signale que le statut du serveur a expiré, c'est-à-dire qu'aucune réponse n'a été reçue pour la dernière demande de statut, je suppose que la connexion a été perdue et j'appelle le Déconnecter une fonction. Cela forcera une nouvelle tentative de connexion dans la prochaine itération de boucle.
• ExécuterCommande fonction :cette fonction est appelée à chaque fois qu'une commande est reçue de BitVoicer Server. Cela prend un octet valeur qui correspond à l'une des commandes de base définies par les constantes au début de l'esquisse. Chaque commande de base est identifiée à l'intérieur du commutateur afin que les vitesses de moteur appropriées puissent être définies ainsi que la durée de la commande. A la fin de la fonction, le cmdRunning la variable est définie sur true et l'heure renvoyée par les millis la fonction est stockée dans le cmdStartTime variable. Cela permet à l'Arduino de contrôler l'exécution de la commande comme décrit ci-dessus. Les temps, en millisecondes, pour chaque commande ont été obtenus comme décrit à l'étape précédente.

ÉTAPE 6 :Configuration du serveur BitVoicer

Dans cette étape, vous devez créer le schéma vocal du serveur BitVoicer avec les phrases à reconnaître et les commandes qui seront envoyées à l'Arduino. À la fin de cette étape, il existe deux liens vers des fichiers contenant tous les objets de solution BitVoicer Server utilisés dans ce didacticiel. Si vous ne souhaitez pas créer tous les objets de solution un par un, vous pouvez les importer (Importation d'objets de solution) à l'aide de ces fichiers.

Avant de commencer à créer le schéma vocal, vous devez créer un appareil qui représentera l'Arduino dans BitVoicer Server. Créez un appareil mixte et nommez-le ArduinoUnoWiFi. Dans l'onglet Communication, sélectionnez TCP/IP et saisissez l'adresse IP attribuée au module WiFi à l'étape 3. Dans l'onglet Cues, activez le Début de la période d'activation et Fin de la période activée indices. Sélectionnez les commandes Int16 SendData pour les deux repères et sélectionnez le périphérique ArduinoUnoWiFi comme cible des commandes. Dans le champ Données, saisissez 1 pour le Début de la période d'activation cue et 0 pour la Fin de Période Activée signal. Ces signaux feront que l'Arduino allumera une LED à chaque fois que le mot d'activation est reconnu. Lorsque la période activée (définie dans le schéma vocal) expire, cette LED s'éteint.

Créons maintenant le schéma vocal. Bien que le robot n'ait que 40 commandes de base, vous souhaiterez peut-être créer de nombreuses combinaisons de mots qui déclenchent la même commande. Par exemple, vous pouvez souhaiter que les phrases « avancer d'un mètre » et « avancer d'un mètre » déclenchent la même commande. En outre, vous souhaiterez peut-être créer des commandes complexes comme « faire un carré » qui déclencheront une série de commandes temporisées en séquence. Pour cette raison, votre schéma vocal peut considérablement grandir et contenir plus de 40 commandes de base. BitVoicer Server prend en charge des phrases illimitées afin que vous puissiez définir autant de phrases que vous le souhaitez (la mienne a fini avec plus de 80 phrases). Ici, je voudrais donner deux conseils :créez une commande par défaut dans les options du gestionnaire de serveur BitVoicer ; et copiez et collez les commandes dupliquées d'une phrase à l'autre.

Les commandes de phrases enverront byte types de données à l'Arduino. Utilisez les constantes définies au début du croquis pour savoir quelle valeur doit être envoyée pour chaque commande. Les commandes complexes enverront de nombreuses valeurs en séquence et vous devrez contrôler l'intervalle (délai) entre elles afin qu'aucune valeur ne soit envoyée pendant que la commande précédente est en cours d'exécution. Utilisez le champ de délai pour définir l'intervalle entre les commandes.

Fichiers d'objet de solution :

Appareil.sof

VoiceSchema.sof

ÉTAPE 7 : Conclusion

Il ne vous reste plus qu'à mettre les piles AA et à connecter la pile 9V à la prise d'alimentation Arduino pour que votre robot prenne vie ! Après avoir téléchargé le code sur l'Arduino, n'oubliez pas de tourner le commutateur monté sur le shield Sparkfun en position UART. Sinon, le module WiFi ne recevra aucune donnée envoyée depuis le port série Arduino.

Après avoir allumé le robot, les LED d'état mettront un peu de temps avant de s'allumer. Vous verrez le module WiFi commencer la communication et lorsque la connexion TCP/IP est établie, l'un des voyants du module s'allumera en continu. Après quelques instants, trois des quatre LED d'état s'allumeront également. Cela signifie qu'un moteur de reconnaissance vocale a été attribué à l'Arduino. Désormais, le robot est prêt à prendre des commandes.

Après quelques tests avec le robot, j'étais assez satisfait de la reconnaissance vocale, même s'il ne reconnaissait pas à chaque fois 100 % des commandes. Dans cet aspect, BitVoicer Server m'a vraiment surpris. Cependant, je n'étais pas très satisfait de la précision des mouvements du robot. Pour résoudre ce problème, je devrais ajouter des capteurs de rotation aux roues. Le kit de châssis que j'ai utilisé dans le robot est déjà livré avec des disques décodeurs qui peuvent être fixés à l'engrenage. L'application de capteurs sur ces disques me permettrait de déplacer le robot en fonction de la distance réelle parcourue afin que son mouvement soit plus précis. Je pourrais aussi ajouter des capteurs à ultrasons pour éviter de se cogner autour de mes meubles. Je le ferai probablement un jour, mais pour l'instant, je vous laisse le choix.

A la prochaine !

Code

• Configuration du module Wi-Fi
• Code source du robot

Configuration du module WiFiArduino

void setup() { Serial.begin (115200); pinMode(13, SORTIE); retard (5000); Serial.print("$$$"); retard(1000); Serial.println("set wlan auth 4"); retard(1000); Serial.println("définir la phrase wlan XXXXXX"); retard(1000); Serial.println("définir wlan ssid XXXXXX"); retard(1000); Serial.println("définir le canal wlan 0"); retard(1000); Serial.println("set wlan join 1"); retard(1000); Serial.println("définir wlan tx 0"); retard(1000); Serial.println("définir ip dhcp 0"); retard(1000); Serial.println("définir l'adresse IP XXXXXX"); retard(1000); Serial.println("set comm remote 0"); retard(1000); Serial.println("set comm close 0"); retard(1000); Serial.println("set comm open 0"); retard(1000); Serial.println("définir la taille de communication 500"); retard(1000); Serial.println("définir le temps de communication 50"); retard(1000); Serial.println("set uart baud 115200"); retard(1000); Serial.println("définir le flux uart 0"); retard(1000); Serial.println("enregistrer"); retard(1000); Serial.println("exit"); retard(1000); digitalWrite(13, LOW);}boucle vide() { }

Code source du robotArduino

#include #include #include // Définit les broches Arduino that will be used to control// LEDs and 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// Defines the constants that will be passed as parameters to // the BVSP.begin functionconst unsigned long STATUS_REQUEST_INTERVAL =2000;const unsigned long STATUS_REQUEST_TIMEOUT =1000;// Defines the size of the mic bufferconst int MIC_BUFFER_SIZE =64;// Initializes a new global instance of the BVSP classBVSP bvsp =BVSP();// Initializes a new global instance of the BVSMic classBVSMic bvsm =BVSMic();// Initializes a new global instance of the // DualMC33926MotorShield classDualMC33926MotorShield ms =DualMC33926MotorShield();// Creates a buffer that will be used to read recorded s amples // from the BVSMic classbyte micBuffer[MIC_BUFFER_SIZE];// Creates a global variable that indicates whether the // Arduino is connected to BitVoicer Serverboolean connected =false;// Defines some constants for the motor settingsconst 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;// Declares a global variables to hold the current motor speed.// The default is SPEED_NORMAL, but there are voice // commands that change this setting.int motorSpeed =SPEED_NORMAL;// Stores the command duration in millisecondsunsigned long cmdDuration =0;// Stores the time the command started runningunsigned long cmdStartTime =0;// Stores whether a command is running or notbool cmdRunning =false;// Stores the last MOVE_FORWARD command. This variable // is used only for the COME_BACK command.byte lastFwdCmd =0;// Defines some constants for command names/values// Just to make the code more readableconst byte CMD_STOP =0;const byte CMD_MOVE_FORWARD =1;const byte CMD_MOVE_FORWARD_1_CM =2;const byte CMD_MOVE_FORWARD_2_CM =3;const byte CMD_MOVE_FORWARD_5_CM =4;const byte CMD_MOVE_FORWARD_10_CM =5;const byte CMD_MOVE_FORWARD_25_CM =6;const byte CMD_MOVE_FORWARD_50_CM =7;const byte CMD_MOVE_FORWARD_1_M =8;const byte CMD_MOVE_BACKWARD =9;const byte CMD_MOVE_BACKWARD_1_CM =10;const byte CMD_MOVE_BACKWARD_2_CM =11;const byte CMD_MOVE_BACKWARD_5_CM =12;const byte CMD_MOVE_BACKWARD_10_CM =13;const byte CMD_MOVE_BACKWARD_25_CM =14;const byte CMD_MOVE_BACKWARD_50_CM =15;const byte CMD_MOVE_BACKWARD_1_M =16;const byte CMD_TURN_AROUND =17;const byte CMD_TURN_AROUND_RIGHT =18;const byte CMD_TURN_AROUND_LEFT =19;const byte CMD_DO_360 =20;const byte CMD_TURN_RIGHT =21;const byte CMD_TURN_RIGHT_10 =22;const byte C MD_TURN_RIGHT_25 =23;const byte CMD_TURN_RIGHT_45 =24;const byte CMD_TURN_LEFT =25;const byte CMD_TURN_LEFT_10 =26;const byte CMD_TURN_LEFT_25 =27;const byte CMD_TURN_LEFT_45 =28;const byte CMD_DO_CIRCLE =29;const byte CMD_COME_BACK =30;const byte CMD_MOVE_FORWARD_2_M =31;const byte CMD_MOVE_FORWARD_3_M =32;const byte CMD_MOVE_BACKWARD_2_M =33;const byte CMD_MOVE_BACKWARD_3_M =34;const byte CMD_SET_SPEED_SLOW =35;const byte CMD_SET_SPEED_NORMAL =36;const byte CMD_SET_SPEED_FAST =37;const byte CMD_TURN_LEFT_45_BACKWARD =38;const byte CMD_TURN_RIGHT_45_BACKWARD =39;void setup(){ // Starts serial communication at 115200 bps Serial.begin(115200); // Sets the Arduino pin modes pinMode(BVS_RUNNING, OUTPUT); pinMode(BVS_SRE, OUTPUT); pinMode(BVS_DATA_FWD, OUTPUT); pinMode(BVS_ACT_PERIOD, OUTPUT); AllLEDsOff(); // Sets the Arduino serial port that will be used for // communication, how long it will take before a status request // times out and how often status requests should be sent to // BitVoicer Server bvsp.begin(Serial, STATUS_REQUEST_TIMEOUT, STATUS_REQUEST_INTERVAL); // Sets the function that will handle the frameReceived // event bvsp.frameReceived =BVSP_frameReceived; // Prepares the BVSMic class timer bvsm.begin(); // Prepares the motor shield class (pins and timer1) ms.init();}void loop() { // If it is not connected to the server, opens a TCP/IP // connection, sets connected to true and resets the BVSP // class if (!connected) { Connect(Serial); connected =true; bvsp.reset(); } // Checks if the status request interval has elapsed and if it // has, sends a status request to BitVoicer Server bvsp.keepAlive(); // Checks if there is data available at the serial port buffer // and processes its content according to the specifications // of the BitVoicer Server Protocol bvsp.receive(); // Gets the respective status from the BVSP class and sets // the LEDs on or off digitalWrite(BVS_RUNNING, bvsp.isBVSRunning()); digitalWrite(BVS_DATA_FWD, bvsp.isDataFwdRunning()); // Checks if there is a SRE assigned to the Arduino if (bvsp.isSREAvailable()) { // Turns on the SRE available LED digitalWrite(BVS_SRE, HIGH); // If the BVSMic class is not recording, sets up the audio // input and starts recording if (!bvsm.isRecording) { bvsm.setAudioInput(BVSM_AUDIO_INPUT, EXTERNAL); bvsm.startRecording(); } // Checks if the BVSMic class has available samples if (bvsm.available) { // Makes sure the inbound mode is STREAM_MODE before // transmitting the stream if (bvsp.inboundMode ==FRAMED_MODE) bvsp.setInboundMode(STREAM_MODE); // Reads the audio samples from the BVSMic class int bytesRead =bvsm.read(micBuffer, MIC_BUFFER_SIZE); // Sends the audio stream to BitVoicer Server bvsp.sendStream(micBuffer, bytesRead); } } else { // There is no SRE available // Turns off the SRE and ACT_PERIOD LEDs digitalWrite(BVS_SRE, LOW); digitalWrite(BVS_ACT_PERIOD, LOW); // If the BVSMic class is recording, stops it if (bvsm.isRecording) bvsm.stopRecording(); } // If the status has timed out, the connection is considered // lost if (bvsp.hasStatusTimedOut()) { // If the BVSMic is recording, stops it if (bvsm.isRecording) bvsm.stopRecording(); // Closes the TCP/IP connection Disconnect(Serial); AllLEDsOff(); connected =false; } // If a command is running, checks if its duration has // expired. If it has, stop the motors. if (cmdRunning) if (millis() - cmdStartTime>=cmdDuration) RunCommand(CMD_STOP);}// Handles the frameReceived eventvoid BVSP_frameReceived(byte dataType, int payloadSize){ // Performs the appropriate actions based on the frame // data type. If the data type is byte, it is a command. // If the data type is int, changes the activated // period LED. switch (dataType) { case DATA_TYPE_BYTE:RunCommand(bvsp.getReceivedByte()); Pause; case DATA_TYPE_INT16:digitalWrite(BVS_ACT_PERIOD, bvsp.getReceivedInt16()); Pause; }}// Runs the command received from the servervoid RunCommand(byte cmd){ switch (cmd) { case CMD_STOP:ms.setSpeeds(SPEED_STOP, SPEED_STOP); cmdRunning =false; retourner; case CMD_MOVE_FORWARD:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =60000; Pause; case CMD_MOVE_FORWARD_1_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =23; Pause; case CMD_MOVE_FORWARD_2_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =47; Pause; case CMD_MOVE_FORWARD_5_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =117; Pause; case CMD_MOVE_FORWARD_10_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =234; Pause; case CMD_MOVE_FORWARD_25_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =468; Pause; case CMD_MOVE_FORWARD_50_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =1170; Pause; case CMD_MOVE_FORWARD_1_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =2339; Pause; case CMD_MOVE_FORWARD_2_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =4678; Pause; case CMD_MOVE_FORWARD_3_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =7018; Pause; case CMD_MOVE_BACKWARD:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =60000; Pause; case CMD_MOVE_BACKWARD_1_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =23; Pause; case CMD_MOVE_BACKWARD_2_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =47; Pause; case CMD_MOVE_BACKWARD_5_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =117; Pause; case CMD_MOVE_BACKWARD_10_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =234; Pause; case CMD_MOVE_BACKWARD_25_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =468; Pause; case CMD_MOVE_BACKWARD_50_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =1170; Pause; case CMD_MOVE_BACKWARD_1_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =2339; Pause; case CMD_MOVE_BACKWARD_2_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =4678; Pause; case CMD_MOVE_BACKWARD_3_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =7017; Pause; case CMD_TURN_AROUND:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =540; Pause; case CMD_TURN_AROUND_RIGHT:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =540; Pause; case CMD_TURN_AROUND_LEFT:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_FRONT); cmdDuration =540; Pause; case CMD_DO_360:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =1065; Pause; case CMD_TURN_RIGHT:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =503; Pause; case CMD_TURN_RIGHT_10:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =56; Pause; case CMD_TURN_RIGHT_25:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =140; Pause; case CMD_TURN_RIGHT_45:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =252; Pause; case CMD_TURN_LEFT:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =503; Pause; case CMD_TURN_LEFT_10:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =56; Pause; case CMD_TURN_LEFT_25:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =140; Pause; case CMD_TURN_LEFT_45:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =252; Pause; case CMD_DO_CIRCLE:ms.setSpeeds( SPEED_NORMAL * DIRECTION_FRONT, SPEED_NORMAL * DIRECTION_FRONT * 0.60); cmdDuration =4587; Pause; case CMD_COME_BACK:RunCommand(lastFwdCmd); retourner; case CMD_SET_SPEED_SLOW:motorSpeed =SPEED_SLOW; retourner; case CMD_SET_SPEED_NORMAL:motorSpeed =SPEED_NORMAL; retourner; case CMD_SET_SPEED_FAST:motorSpeed =SPEED_FAST; retourner; case CMD_TURN_LEFT_45_BACKWARD:ms.setSpeeds(motorSpeed * DIRECTION_BACK, 0); cmdDuration =252; Pause; case CMD_TURN_RIGHT_45_BACKWARD:ms.setSpeeds(0, motorSpeed * DIRECTION_BACK); cmdDuration =252; Pause; } // Sets the command start time cmdStartTime =millis(); // Sets cmdRunning to true cmdRunning =true;}// Opens a TCP/IP connection with the BitVoicer Servervoid Connect(HardwareSerial &serialPort){ serialPort.print("$$$"); retard (500); // Use the IP address of the server and the TCP port set // in the server properties serialPort.println("open 192.168.0.11 4194"); retard(1000); serialPort.println("exit"); delay(500);}// Closes the TCP/IP connection with the BitVoicer Servervoid Disconnect(HardwareSerial &serialPort){ serialPort.print("$$$"); retard (500); serialPort.println("close"); retard(1000); serialPort.println("exit"); delay(500);}// Turns all LEDs offvoid AllLEDsOff(){ digitalWrite(BVS_RUNNING, LOW); digitalWrite(BVS_SRE, LOW); digitalWrite(BVS_DATA_FWD, LOW); digitalWrite(BVS_ACT_PERIOD, LOW);}

Schémas