Il fusionne le matériel physique avec la reconnaissance de la parole, le traitement du langage naturel et le contrôle des mouvements réactifs. Que vous souhaitiez un compagnon robotique, un assistant mains libres ou une plateforme d'apprentissage pour l'IA et les systèmes embarqués, ce guide complet vous permettra de choisir des composants pour faire fonctionner un robot entièrement fonctionnel qui écoute et agit sur vos commandes orales. Chaque section comprend des considérations pratiques, des choix alternatifs et des conseils de dépannage pour vous aider à réussir à chaque étape.

Matériel et outils nécessaires

La base de toute construction de robot réussie est de choisir les bons composants. Ci-dessous est une ventilation détaillée de ce dont vous aurez besoin, ainsi que des recommandations pour chaque catégorie.

  • Microcontrôleur ou ordinateur à un seul conseil – Le cerveau de votre robot. Riz de framboise (3B+, 4B, ou 5) est idéal pour le traitement de la voix car il gère un système d'exploitation Linux complet et peut gérer des bibliothèques audio. Arduino (Uno, Mega, ou Due) est plus simple pour le contrôle moteur, mais nécessite généralement un module séparé pour la reconnaissance vocale. De nombreux constructeurs combinent un Raspberry Pi pour la parole et un Arduino pour le contrôle moteur de bas niveau connecté par série.
  • Microphone et haut-parleur – Pour une capture vocale de haute qualité, utilisez un microphone USB ou un carte de sortie I2S MEMS dédiée (par exemple INMP441). Une webcam USB avec micro intégré fonctionne aussi. Pour une sortie audio, un haut-parleur 3W ou 5W piloté par un petit amplificateur (comme l'amplificateur MAX98357 I2S) fournit une rétroaction vocale claire.
  • Servo Motors pour le mouvement – Choisissez des servomoteurs de rotation continue pour roues ou des servomoteurs standard pour bras et mouvements de tête. Pour un simple robot à roues, deux servomoteurs de rotation continue plus une roulette suffisent. Utilisez des servomoteurs de métal pour la durabilité, surtout si le robot porte du poids.
  • Châssis ou corps de robot – Un châssis acrylique pré-coupé (par exemple, d'Amazon ou Adafruit) facilite l'assemblage. Vous pouvez également imprimer votre propre conception en 3D. Assurez-vous qu'il y a suffisamment d'espace pour le microcontrôleur, la batterie et les capteurs.
  • Module Wi-Fi ou Bluetooth – La plupart des modèles modernes Raspberry Pi ont intégré Wi-Fi/Bluetooth. Pour Arduino, ajoutez un module Bluetooth ESP8266 ou HC‐05 si vous avez besoin de communication sans fil (p. ex. pour décharger le traitement de la parole vers un service cloud).
  • Alimentation électrique – Une banque d'alimentation USB portable (5V, 2A+) fonctionne pour un Raspberry Pi. Pour les moteurs et les servomoteurs, utilisez des batteries séparées (par exemple, rechargeables 4×AA) ou un seul pack Li‐ion avec régulateur de tension. Calculez le tirage de courant : un Pi 4 peut culminer à 3A; les servomoteurs peuvent ajouter 1–2A.
  • Câbles et connecteurs – Dupont file des fils de femelle à femelle, de mâle à femelle et de mâle à mâle, plus une planche à pain pour le prototypage. Utilisez un bloc de borne à vis pour la distribution de l'énergie à plusieurs servos.
  • Logiciel de programmation – Pour Raspberry Pi: Raspbian OS (Bookworm ou plus), Python 3, et les bibliothèques requises (numpy, pyaudio, speech recognition, gTTS ou pyttsx3, RPi.GPIO).Pour Arduino: Arduino IDE avec les bibliothèques pertinentes (Servo.h, SoftwareSerial, etc.).

Optionnel mais utile : un adaptateur série USB-to-TTL pour le débogage, un multimètre pour la vérification des tensions et un fer à souder pour les connexions permanentes.

Étape 1: Assembler le matériel

Commencez par la construction physique avant d'écrire un code. Une plate-forme matérielle bien organisée facilite les tests et le débogage.

1.1 Construire le châssis

Montez les servomoteurs sur le châssis en utilisant des vis ou du ruban double face. Si vous utilisez un robot à roues, attachez les roues aux arbres de sortie du servo et à une roulette à l'avant ou à l'arrière. Pour un hélico humain, les servos sont montés aux articulations. Assurez-vous que toutes les parties mobiles peuvent tourner librement sans obstruction.

1.2 Monter le microcontrôleur et les composants audio

Placez le Raspberry Pi ou Arduino sur des stands d'amplificateur de vibrations pour le protéger de la contrainte de mouvement. Connectez le microphone et l'enceinte/amplificateur. Pour un micro USB, branchez-le sur un port USB Pi. Pour un micro I2S, filez-le sur les broches GPIO appropriées (p. ex. BCK, WS, DIN, L/R). Connectez l'amplificateur à des broches de puissance et de sortie audio (généralement LRCK, BCLK, DIN).

Double-vérifiez la polarité.

1.3 Filer les moteurs

Les moteurs Servo nécessitent trois fils : puissance (rouge, 5V), sol (brun/noir) et signal (jaune/orange). Connectez tous les servomoteurs ensemble et au sol du microcontrôleur. Ne pas alimenter plusieurs servomoteurs haute torque du microcontrôleur , utilisez une alimentation 5V externe. Connectez les fils de signal aux GPIO compatibles PWM (p. ex., sur Raspberry Pi, utilisez n'importe quel GPIO pour ou PWM logiciel; sur Arduino, utilisez les broches numériques 9 et 10 pour la bibliothèque Servo intégrée).

1.4 Distribution d'électricité

Connectez la batterie ou la banque d'alimentation à un commutateur, puis au microcontrôleur d'alimentation. Utilisez un régulateur 5V séparé (par exemple LM2596) pour les moteurs si la tension de la batterie est supérieure à 6V. Ajoutez un condensateur (1000μF) entre la puissance et le sol à proximité des moteurs pour filtrer les pics.

1.5 Vérification finale

Avant d'appliquer la puissance, vérifiez visuellement toutes les connexions. Utilisez un multimètre pour vérifier la continuité et qu'il n'y a pas de short entre la puissance et le sol. Faites d'abord monter le microcontrôleur (sans moteur) pour vérifier le démarrage. Puis connectez la puissance du moteur séparément.

Étape 2: Mettre en place l'environnement logiciel

Avec le matériel assemblé, préparez la fondation du logiciel. Cette étape assure votre microcontrôleur peut contrôler les moteurs et capturer l'audio.

2.1 Installation du Pi de framboise

Flash Raspbian OS (Bookworm ou plus) sur une carte microSD à l'aide du Raspberry Pi Imager. Activer SSH et Wi‐Fi pendant le processus d'imagerie. Démarrer le Pi et mettre à jour les paquets : . Installer le Python 3 (généralement préinstallé) et les bibliothèques essentielles :

Remarque: Pour la reconnaissance hors ligne de la parole, installez (qui peut nécessiter des dépendances supplémentaires). Pour l'accès en ligne, assurez-vous d'accéder à Internet et de configurer une clé API de Google Cloud Speech-to-Text (niveau gratuit disponible).

2.2 Installation de l'Arduino

Téléchargez et installez l'IDE Arduino depuis arduino.cc. Ajoutez une prise en charge pour votre carte (Outils > Planche > Gestionnaire de cartes). Installez la bibliothèque Servo (Outils > Gérer les bibliothèques > Rechercher -Servo). Si vous utilisez un module externe de parole, installez sa bibliothèque (p. ex., module de reconnaissance vocale d'Elechouse V3).

2.3 Établir la communication (si l'on utilise Pi + Arduino)

Connectez les broches UART Raspberry Pi , GPIO 15 RX et RX (avec un diviseur de tension si l'Arduino tourne à 5V). Activez UART sur le Pi ( > Options d'interface > Port série > désactivez la console sur série). Ecrivez un protocole série : par exemple, envoyez des caractères simples comme « F » pour l'avant, « L » pour la gauche. Testez avec un script Python simple qui écrit à .

Étape 3 : Mettre en oeuvre la reconnaissance vocale

La reconnaissance vocale convertit les mots parlés en commandes texte. Vous avez deux approches principales : en ligne (fondé sur le nuage) pour une plus grande précision, ou hors ligne (sur l'appareil) pour la confidentialité et la vitesse.

3.1 Reconnaissance de la parole en ligne (Recommandé pour les débutants)

Utilisation de la Reconnaissance du discours bibliothèque en Python rend l'intégration triviale. Après avoir installé la bibliothèque et mis en place une clé API Google, écrivez une fonction comme ceci:

Testez le microphone en exécutant ce script. Parlez clairement et à un rythme normal. Si la reconnaissance est mauvaise, ajustez la durée ou utilisez un meilleur microphone. Pour une plus grande précision, configurez un Discours en nuage de Google à texte compte (gratuit jusqu'à 60 minutes par mois) et utiliser la clé API.

3.2 Reconnaissance hors ligne avec PocketSphinx

PocketSphinx fonctionne sans internet mais est moins précis. Installez . Ensuite, utilisez au lieu de . Vous pouvez former des modèles de langue personnalisés pour une meilleure précision avec un vocabulaire limité (par exemple, seulement vingt commandes).

3.3 Bruit ambiant de manipulation

Toujours calibrer le microphone pour le bruit ambiant avant chaque séance d'écoute. Dans une pièce bruyante, fixer le seuil d'énergie plus haut. Utilisez un microphone anti-bruit ou placez de la mousse autour du micro pour réduire le bruit du vent et du moteur. Si le robot se déplace en écoutant, les vibrations du moteur corrompront l'audio – considérez un mode --écoute où le robot arrête tout mouvement.

Étape 4: Programmer les réponses Robot

Une fois que vous avez des commandes texte, le robot doit les analyser et actionner en conséquence.

4.1 Définir le vocabulaire de commande

Créer un dictionnaire des commandes reconnues et de leurs actions correspondantes. Exemple:

Utilisez la correspondance floue () pour gérer de légères erreurs de reconnaissance. Par exemple, -foward , pourrait correspondre à --forward , ou limiter la grammaire dans le moteur de reconnaissance vocale à seulement ces mots.

4.2 Code de commande du moteur

Sur le Raspberry Pi, utilisez ou pour générer des signaux PWM pour les servos. Pour deux servos continus, filez le servo gauche vers GPIO 17 et le servo droit vers GPIO 18. Exemple de fonction pour le mouvement vers l'avant:

Si vous utilisez un Arduino, la bibliothèque Servo est plus facile. Commandes de carte reçues sur série à pour stop, pour inversement complet, pour aller de l'avant.

4.3 Commentaires de la voix

Faites revenir le robot pour confirmer les commandes. Utilisez (Google Text‐to‐Speech) pour générer un fichier MP3 et le lire par ou . Exemple :

Pour les TTS hors ligne, utilisez (travaille avec eSpeak ou festival).

4.4 Actions non-motionnelles

Ajoutez des fonctions pour agiter un bras de servo, clignoter des LED ou afficher du texte sur un écran OLED. Celles-ci rendent le robot plus interactif et peuvent être déclenchées par des commandes spécifiques.

Étape 5: Intégrer et tester

L'intégration est l'endroit où vous rassemblez tous les sous-systèmes et exécutez des tests de bout en bout.

5.1 Essais unitaires

Testez chaque sous-système indépendamment. Vérifiez que le micro enregistre et le reconnaissanceur de la parole retourne du texte. Testez le contrôle moteur en envoyant des commandes codées en dur. Testez le TTS en jouant un fichier sonore. Ne combinez que lorsque chaque pièce fonctionne de façon fiable.

5.2 Essai de bout en bout

Lancez la boucle principale qui écoute, reconnaît, agit et parle. Commencez dans une pièce tranquille. Parlez une commande simple comme --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

5.3 Surmonter les problèmes communs

  • Pas de réponse après le discours – Le microphone ne peut pas être réglé par défaut. Vérifiez pour les numéros de périphérique. Dans SpeechReconnaissance, spécifiez .
  • Moteurs en mouvement mais pas en mouvement – Fréquence PWM ou cycle de service incorrect. Les servos en continu ont besoin d'un signal de 50Hz et de largeurs d'impulsion spécifiques.
  • Délai de retour d'information audio – Prégénérer des réponses TTS communes et les enregistrer localement pour éviter la latence réseau sur chaque commande.
  • Robot bouge en écoutant – Arrêtez toujours les moteurs avant d'entrer dans la boucle d'écoute. Ajoutez une commande -stop-- qui remplace toutes les actions en attente.

5.4 Tuning et fiabilité

Dans les environnements bruyants, augmenter le seuil d'énergie dans . Utilisez une invitation de confirmation : le robot répète la commande et demande confirmation avant de se déplacer (par exemple, -) Avez-vous dit avant ? Dites oui pour poursuivre.

Caractéristiques et améliorations supplémentaires

Une fois le robot de base fonctionne, envisager d'étendre ses capacités.

  • Évitement des obstacles – Ajoutez un capteur à ultrasons (HC‐SR04) ou un capteur de temps de vol. Lorsque le robot détecte un obstacle à une certaine distance, il peut s'arrêter et demander une nouvelle direction.
  • Suivi du visage – Montez une caméra (p. ex., module Raspberry Pi Camera) et utilisez OpenCV pour détecter les visages. Faites tourner la tête du robot (servos de tilt/pan) pour suivre une personne.
  • Mot de réveil personnalisé – Utilisez un moteur de mot-sake comme Porcupine (petite empreinte, hors ligne) pour écouter -Hey Robot -Hey avant de traiter les commandes complètes.
  • Télécommande via l'application – Construisez une application mobile simple en utilisant MIT App Inventor ou Flutter qui envoie des commandes via Bluetooth ou Wi‐Fi, vous donnant un retour en arrière si la voix échoue.
  • Capacités d'apprentissage – Enregistrez toutes les commandes et les résultats. Utilisez une machine d'état simple pour mémoriser le contexte. Par exemple, si le robot est dit ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  • Soutien multilingue – La bibliothèque SpeechReconnaissance prend en charge de nombreux langages. Changez le paramètre de langue en ‘zh‐CN=, ‘es‐ES=, etc. Le robot peut répondre dans la même langue en utilisant gTTS.

Pour des projets plus avancés, déchargez le traitement lourd (comme la compréhension du langage naturel) vers un service cloud tel que Dialogflow ou Amazon Lex. Le robot devient alors une interface physique pour une AI conversationnelle complète.

Conclusion

En suivant ce guide, vous avez appris à sélectionner les composants, assembler le matériel, configurer le logiciel, intégrer la reconnaissance vocale et contrôler les moteurs, tout en maintenant un flux de travail clair et testable. Chaque nouveau capteur, algorithme ou raffinement mécanique rapproche votre robot d'un assistant personnel vraiment autonome. Expérimentez, itérez et profitez du processus de mise en vie d'une machine avec rien que vos propres mots.

Pour en savoir plus, explorez la Documentation sur le Raspberry Pi pour l'interface matérielle avancée, et le Bibliothèque de reconnaissance de discours Si vous décidez de passer à l'IA basée sur le cloud, consultez Flux de dialogue - Bonne construction !