Tête de mannequin de localisation sonore avec Kinect : 9 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Rencontrez Margaret, un mannequin d'essai pour un système de surveillance de la fatigue du conducteur. Elle a récemment pris sa retraite de ses fonctions et a trouvé le chemin de nos bureaux, et a depuis attiré l'attention de ceux qui pensent qu'elle est «effrayante». Dans l'intérêt de la justice, je lui ai donné la possibilité d'affronter ses accusateurs de front; au lieu de vous suivre apparemment avec son regard sans âme, maintenant elle le fait réellement. Le système utilise le réseau de microphones d'un Microsoft Kinect et un servo pour l'orienter dans la direction des personnes qui parlent près d'elle.

Étape 1: Théorie

Calcul de l'angle

Lorsque nous entendons quelque chose, à moins que ce bruit ne soit directement devant nous, il atteint une oreille avant l'autre. Notre cerveau perçoit ce délai d'arrivée et le convertit en une direction générale d'où vient le bruit, ce qui nous permet de trouver la source. Nous pouvons obtenir exactement le même type de localisation en utilisant une paire de microphones. Considérez le schéma illustré, qui contient une paire de microphones et une source sonore. Si nous regardons de haut en bas, les ondes sonores sont circulaires, mais si la distance à la source est grande par rapport à l'espacement entre les microphones, alors du point de vue de nos capteurs, l'onde est approximativement plane. Ceci est connu comme l'hypothèse du champ lointain et simplifie la géométrie de notre problème.

Supposons donc que le front d'onde est une ligne droite. Si le son vient de la droite, il frappera le microphone #2 à l'instant t2 et le microphone #1 à l'instant t1. La distance d parcourue par le son entre le microphone n°2 et le microphone n°1 est la différence de temps de détection du son multipliée par la vitesse du son v s:

d = v s *(t1-t2) = vs*Δt

On peut rapporter cette distance à la distance d 12 entre la paire de microphones et l'angle de la paire à la source sonore avec la relation:

cos(θ) = d/d 12 = vs*Δt /d12

Comme nous n'avons que deux microphones, il y aura une ambiguïté dans notre calcul quant à savoir si la source sonore est devant ou derrière nous. Dans ce système, nous supposerons que la source sonore est devant la paire et serrer l'angle entre 0 degrés (complètement à droite de la paire) à 180 degrés (complètement à gauche).

Enfin, nous pouvons résoudre pour thêta en prenant le cosinus inverse:

θ = acos(vs*Δt/d12), 0 <= θ <= π

Pour rendre l'angle un peu plus naturel, nous pouvons soustraire 90 degrés de thêta, de sorte que 0 degré soit directement devant la paire et +/- 90 degrés soit complètement à gauche ou complètement à droite. Cela fait passer notre expression du cosinus inverse au sinus inverse.

• cos(θ-π/2) = sin(θ) = d/d12 = vs*Δt/d12

• θ = asin(vs*Δt/d12), -π/2 <= θ <= π/2

Trouver le retard

Comme vous pouvez le voir dans l'équation ci-dessus, tout ce que nous devons résoudre pour l'angle est le retard de l'onde sonore arrivant au microphone un par rapport au microphone deux; la vitesse du son et la distance entre les microphones sont à la fois fixes et connues. Pour ce faire, nous échantillonnons d'abord les signaux audio à la fréquence fs, les convertissons de l'analogique au numérique et stockons les données pour une utilisation ultérieure. Nous échantillonnons pendant une période connue sous le nom de fenêtre d'échantillonnage, qui est suffisamment longue pour capturer les caractéristiques distinctes de notre onde sonore. Par exemple, notre fenêtre pourrait être la valeur de la dernière demi-seconde de données audio.

Après avoir obtenu les signaux audio fenêtrés, nous trouvons le retard entre les deux en calculant leur corrélation croisée. Pour calculer la corrélation croisée, nous maintenons le signal fenêtré d'un microphone fixe et faisons glisser le deuxième signal le long de l'axe du temps de tout derrière le premier à tout en avant du premier. À chaque étape de notre diapositive, nous multiplions chaque point de notre signal fixe par son point correspondant dans notre signal coulissant, puis additionnons tous les résultats pour calculer notre coefficient de corrélation pour cette étape. Après avoir terminé notre diapositive, l'étape qui a le coefficient de corrélation le plus élevé correspond au point où les deux signaux sont les plus similaires, et à quelle étape nous sommes nous dit combien d'échantillons n le signal deux est décalé par rapport au signal 1. Si n est négatif, alors le signal deux est en retard sur le signal un, s'il est positif alors le signal deux est en avance, et s'il est à zéro alors les deux sont déjà alignés. Nous convertissons ce décalage d'échantillon en un retard temporel en utilisant notre fréquence d'échantillonnage avec la relation Δt = n/fs, donc:

θ = asin(vs*n/(d12*fs)), -π/2 <= θ <= π/2

Étape 2: Composants

les pièces

• Microsoft Kinect pour Xbox 360, modèle 1414 ou 1473. Le Kinect dispose de quatre microphones disposés en réseau linéaire que nous utiliserons.
• Adaptateur pour convertir le connecteur propriétaire du Kinect en alimentation USB + AC comme celui-ci.
• Raspberry Pi 2 ou 3 exécutant Raspbian Stretch. J'ai initialement essayé d'utiliser un Pi 1 modèle B+, mais il n'était pas assez puissant. J'ai continué à avoir des problèmes de déconnexion de la Kinect.
• La tête de mannequin la plus effrayante que vous puissiez trouver
• Un servo analogique assez puissant pour faire tourner la tête de votre mannequin
• Un chargeur mural USB 5V avec un ampérage suffisant pour alimenter à la fois le Pi et le servo et au moins deux ports. (J'ai utilisé une prise 5A 3 ports similaire à celle-ci
• Une rallonge avec deux prises (une pour le chargeur mural USB et l'autre pour l'adaptateur secteur Kinect.
• Deux câbles USB: un câble de type A vers micro-USB pour alimenter le Pi et un autre pour alimenter le servo que cela ne vous dérange pas de couper
• Une plate-forme pour tout s'asseoir et une autre plate-forme plus petite pour la tête de mannequin. J'ai utilisé un plateau de service en plastique comme base et une assiette en plastique comme plate-forme de tête. Les deux provenaient de Walmart et ne coûtaient que quelques dollars
• 4x #8-32 1/2" boulons et écrous pour fixer votre servo à la plus grande plate-forme
• 2x boulons M3 de 8 mm avec rondelles (ou la taille dont vous avez besoin pour attacher votre palonnier à la plus petite plate-forme)
• Deux cavaliers mâle-mâle, un rouge et un noir, et un cavalier femelle-mâle
• Bandes Velcro à dos adhésif
• Ruban électrique
• Ruban adhésif pour la gestion des câbles

Outils

• Dremel avec molette
• Percer
• Forets 7/64", 11/16" et 5/16"
• Robinet M3 (En option, selon votre palonnier)
• Tournevis
• Fer à souder avec soudure
• Coup de main (facultatif)
• Marqueur
• Boussole
• Pince à dénuder
• Multimètre (facultatif)

EPI

• Lunettes de protection

• Masque facial (pour les embouts en plastique à dremmel).

Étape 3: Assemblage de la plate-forme inférieure

La première partie que nous allons fabriquer est la plate-forme inférieure, qui contiendra notre Kinect, notre servo et toute notre électronique. Pour créer la plateforme, vous aurez besoin de:

• Plateau de service en plastique
• Servomoteur
• 4x #8-32 1/2" boulons avec écrous
• Dremel avec molette
• Tournevis
• Percer
• Foret 11/16"
• Marqueur

Comment faire

1. Retournez votre plateau à l'envers.
2. Placez votre servo sur le côté près de l'arrière du plateau, assurez-vous que l'engrenage de sortie du servo se trouve le long de la ligne médiane du plateau, puis marquez autour de la base du servo.
3. À l'aide de votre dremel et de votre molette de découpe, découpez la zone que vous avez marquée, puis glissez votre servo dans sa fente.
4. Marquez les centres des trous de montage du boîtier du servo sur le plateau, puis retirez le servo et percez ces trous avec votre foret de 11/16". faire tourner la perceuse à l'envers et tailler lentement le matériau. C'est beaucoup plus lent que de percer les trous correctement mais cela garantit qu'il n'y a pas de fissures.
5. Replacez votre servo dans la fente, puis montez-le sur le plateau avec les boulons et écrous #8-32.

Étape 4: Assemblage de la plate-forme de tête

La prochaine partie que nous ferons sera une plate-forme pour connecter la tête du mannequin au servo. Pour fabriquer la plate-forme de tête, vous aurez besoin de:

• Assiette en plastique
• Avertisseur sonore
• 2x boulon M3 8mm avec rondelles
• Tournevis
• Percer
• Forets 7/64" et 5/16"
• Boussole
• Dremel avec molette

Comment faire

1. Réglez votre boussole sur le rayon de la base de votre tête de mannequin.
2. Utilisez votre boussole pour marquer un cercle centré sur le centre de la plaque. Ce sera la taille réelle de notre plate-forme principale.
3. Utilisez votre dremel et votre molette pour découper la plus petite plate-forme de la plaque.
4. Percez le centre de votre nouvelle plate-forme avec un foret de 5/16". Cela nous donnera accès à la vis qui monte notre palonnier sur notre servo. Pour donner à la plate-forme une stabilité pendant que j'ai percé le trou, j'ai mis une bobine de fil en dessous et percé à travers le centre de la bobine.
5. Alignez votre palonnier avec le centre de la plate-forme et marquez deux trous pour fixer le palonnier à la plate-forme. Assurez-vous que ces trous de montage sont suffisamment éloignés les uns des autres pour qu'il y ait de la place pour vos têtes de boulons et rondelles M3.
6. Percez ces trous marqués avec un foret de 7/64".
7. Le trou inférieur de mon palonnier était lisse, c'est-à-dire qu'il n'avait pas les filetages pour le boulon M3. Ainsi, j'ai utilisé ma perceuse et un taraud M3 pour faire les filetages.
8. Utilisez les boulons et les rondelles pour fixer le palonnier à la plate-forme de tête.

Étape 5: Câble d'alimentation servo

Les servos analogiques sont généralement alimentés en 4,8-6V. Étant donné que le Raspberry Pi va déjà être alimenté en 5V à partir de l'USB, nous simplifierons notre système en alimentant également le servo à partir de l'USB. Pour ce faire, nous devrons modifier un câble USB. Pour fabriquer le câble d'alimentation du servo, vous aurez besoin de:

• Câble USB de rechange avec une extrémité de type A (le genre qui se branche sur votre ordinateur)
• Un cavalier rouge et un noir
• Fer à souder
• Souder
• Pince à dénuder
• Ruban électrique
• Coup de main (facultatif)
• Multimètre (facultatif)

Comment faire

1. Coupez le connecteur non USB de type A de votre câble, puis enlevez un peu d'isolant pour révéler les quatre fils internes. Coupez le blindage entourant les fils exposés.
2. Typiquement, le câble USB aura quatre fils: deux pour la transmission et la réception de données et deux pour l'alimentation et la terre. Nous nous intéressons à la puissance et à la terre, qui sont généralement respectivement rouge et noire. Dénudez une partie de l'isolant des fils rouge et noir et coupez les fils vert et blanc. Si vous craignez de ne pas avoir les bons fils d'alimentation et de terre, vous pouvez brancher votre câble sur votre adaptateur secteur USB et vérifier la tension de sortie avec un multimètre.
3. Ensuite, coupez une extrémité de vos câbles de démarrage rouge et noir et dénudez une partie de l'isolant.
4. Maintenant, torsadez ensemble les fils noirs exposés de votre cavalier et les câbles USB. Traversez les centres des fils exposés et torsadez-les les uns autour des autres. Ensuite, appliquez de la soudure sur les fils accouplés pour les maintenir ensemble. Des mains secourables vous faciliteront la tâche en maintenant vos câbles en place.
5. Répétez l'étape 4 pour les fils rouges.
6. Couvrez le câblage exposé avec du ruban isolant ou un tube thermorétractable si vous vous sentez d'humeur. Ces joints seront fragiles car les fils sont si petits, alors ajoutez une deuxième couche de ruban adhésif maintenant les câbles de démarrage à l'isolation extérieure du câble USB. Cela rendra l'assemblage plus rigide et donc moins susceptible de se casser en se pliant.

Étape 6: Montage de l'électronique

Enfin, nous allons tout rassembler, en montant notre électronique et tout le reste sur la plate-forme inférieure. Tu auras besoin de:

• Plate-forme inférieure
• Plate-forme de tête
• Tête de mannequin
• Kinect avec adaptateur USB+AC
• Adaptateur secteur USB
• Rallonge électrique
• Câble micro-USB
• Câble d'alimentation servo
• Tarte aux framboises
• Câble de raccordement mâle-femelle
• Velcro adhésif
• Ciseaux

Comment faire

1. Montez le Pi au fond du plateau avec du velcro.
2. Fixez l'adaptateur d'alimentation USB avec du Velcro.
3. Branchez le servo et le Pi sur l'adaptateur secteur USB.
4. Connectez la broche 12 (GPIO18) du Pi au câble de signal du servo. C'est la 6ème broche en bas à droite.
5. Faites passer votre rallonge dans la poignée arrière du plateau et branchez l'adaptateur d'alimentation USB sur un côté.
6. Prenez l'adaptateur Kinect USB+AC et branchez l'adaptateur secteur de l'autre côté de la rallonge et l'USB dans le Pi.
7. Faites passer le cordon du Kinect à travers la poignée avant du plateau et branchez-le dans l'adaptateur Kinect.
8. J'ai utilisé du ruban adhésif pour maintenir les câbles sous la plate-forme. Cela n'a pas l'air des plus élégants, mais heureusement, tout cela est caché.
9. Retournez la plate-forme à l'endroit et utilisez du Velcro pour monter le Kinect à l'avant de la plate-forme.
10. Utilisez du Velcro pour monter la tête du mannequin sur la plate-forme de la tête. Une fois que tout est aligné, cependant, séparez les deux pièces afin que nous puissions accéder à la vis de montage du palonnier du servo. Ne vissez pas encore le klaxon au servo, car nous devons d'abord nous assurer que le servo est dans sa position centrale afin que nous puissions tout aligner. Nous le ferons dans une étape ultérieure.

Étape 7: Logiciel et algorithme

Aperçu

Le logiciel de ce projet est écrit en C++ et est intégré à Robot Operating System (ROS), un framework pour l'écriture de logiciels de robotique. Dans ROS, le logiciel d'un système est divisé en une collection de programmes appelés nœuds, où chaque nœud implémente une sous-section spécifique des fonctionnalités du système. Les données sont transmises entre les nœuds à l'aide d'une méthode de publication/abonnement, où les nœuds qui produisent les données les publient et les nœuds qui consomment les données s'y abonnent. Le découplage du code de cette manière permet d'étendre facilement les fonctionnalités du système et de partager les nœuds entre les systèmes pour un développement plus rapide.

Dans ce système, ROS est principalement utilisé pour séparer le code calculant la direction d'arrivée (DOA) de la source sonore du code contrôlant le servo, permettant à d'autres projets d'inclure l'estimation Kinect DOA sans inclure le code servo dont ils n'ont peut-être pas besoin ou ne veulent pas.. Si vous souhaitez consulter le code lui-même, vous pouvez le trouver sur GitHub:

github.com/raikaDial/kinect_doa

Nœud DOA Kinect

Le nœud kinect_doa est la viande et les os de ce système, faisant fondamentalement tout ce qui est intéressant. Au démarrage, il initialise le nœud ROS, rendant toute la magie ROS possible, puis télécharge le firmware sur le Kinect afin que les flux audio deviennent disponibles. Il génère ensuite un nouveau thread qui ouvre les flux audio et commence à lire les données du microphone. Le Kinect échantillonne ses quatre microphones à une fréquence de 16 kHz chacun, il est donc bon d'avoir la corrélation croisée et la collecte de données dans des threads séparés pour éviter les données manquantes en raison de la charge de calcul. L'interfaçage avec le Kinect s'effectue à l'aide de libfreenect, un pilote open source populaire.

Le thread de collecte exécute une fonction de rappel chaque fois que de nouvelles données sont reçues, et les deux stockent les données et déterminent quand estimer le DOA. Les données de chaque microphone sont stockées dans des tampons roulants de longueur égale à notre fenêtre d'échantillonnage, qui est ici de 8192 échantillons. Cela se traduit par le calcul de la corrélation croisée avec environ la dernière demi-seconde de données, ce que j'ai trouvé en expérimentant comme étant un bon équilibre entre les performances et la charge de calcul. L'estimation DOA est déclenchée tous les 4096 échantillons en signalant le thread principal, de sorte que les corrélations croisées consécutives se chevauchent de 50 %. Prenons un cas où il n'y a pas de chevauchement, et vous faites un bruit très rapide qui est réduit de moitié par la fenêtre d'échantillonnage. Avant et après votre son distinctif sera probablement un bruit blanc, qui peut être difficile à aligner avec la corrélation croisée. Le chevauchement des fenêtres nous fournit un échantillon plus complet du son, augmentant la fiabilité de notre corrélation croisée en nous donnant plus de fonctionnalités distinctes à aligner.

Le thread principal attend le signal du thread de collecte, puis calcule l'estimation DOA. Tout d'abord, cependant, il vérifie si les formes d'onde capturées sont significativement différentes du bruit blanc. Sans cette vérification, nous calculerions notre estimation quatre fois par seconde, qu'il y ait ou non des bruits intéressants, et notre tête de mannequin serait un désordre spastique. L'algorithme de détection de bruit blanc utilisé dans ce système est le premier des deux répertoriés ici. Nous calculons le rapport de l'intégrale absolue de la dérivée de notre forme d'onde à son intégrale absolue; pour les signaux à forte teneur en bruit blanc, ce rapport est plus élevé que pour les signaux moins bruités. En fixant un seuil pour ce rapport séparant le bruit du non-bruit, nous ne pouvons déclencher la corrélation croisée que lorsque cela est approprié. Bien sûr, ce ratio est quelque chose qui doit être réajusté chaque fois que le système est déplacé vers un nouvel environnement.

Une fois déterminé que les formes d'onde contiennent un contenu non-bruit significatif, le programme procède aux corrélations croisées. Il y a cependant trois optimisations importantes intégrées dans ces calculs:

1. Il y a quatre microphones sur le Kinect, ce qui signifie qu'il y a au total six paires de formes d'onde que nous pouvons croiser. Cependant, si vous regardez la disposition spatiale du réseau de microphones, vous pouvez voir que les microphones 2, 3 et 4 sont très proches les uns des autres. En fait, ils sont si proches qu'en raison de la vitesse du son et de notre fréquence d'échantillonnage, les formes d'onde reçues à 2, 3 et 4 seront séparées par au plus un échantillon en avant ou en arrière, ce que nous pouvons vérifier avec le calcul maxlag = Δd *fs/vs, où d est la séparation de la paire de microphones, fs est la fréquence d'échantillonnage et vs est la vitesse du son. Ainsi, la corrélation des paires entre ces trois est inutile, et nous n'avons besoin que de corréler le microphone 1 avec 2, 3 et 4.
2. La corrélation croisée standard des signaux audio est connue pour ses performances médiocres en présence de réverbérations (échos). Une alternative robuste est connue sous le nom de corrélation croisée généralisée avec transformation de phase (GCC-PHAT). Cette méthode se résume à appliquer une fonction de pondération qui amplifie les pics de la corrélation croisée, facilitant ainsi la distinction entre le signal d'origine et les échos. J'ai comparé les performances de GCC-PHAT à la simple corrélation croisée dans une chambre de réverbération (lire: salle de bain en béton en cours de rénovation), et j'ai trouvé que GCC-PHAT était 7 fois plus efficace pour estimer l'angle correct.
3. Lors de l'exécution de la corrélation croisée, nous prenons les deux signaux, glissant l'un sur l'autre, et à chaque étape, multiplions chaque point de notre signal fixe par chaque point de notre signal glissant. Pour deux signaux de longueur n, cela donne n^2 calculs. Nous pourrions améliorer cela en effectuant à la place la corrélation croisée dans le domaine fréquentiel, ce qui implique une transformée de Fourier rapide (calculs nlogn), en multipliant chaque point d'un signal transformé par le point correspondant dans l'autre (n calculs), puis en effectuant un inverse transformée de Fourier pour revenir dans le domaine temporel (calculs nlogn), aboutissant à n+2*nlogn calculs, inférieur à n^2. Cependant, c'est l'approche naïve. Les microphones de notre réseau sont si proches les uns des autres et la vitesse du son est si relativement lente que les formes d'onde audio seront déjà pour la plupart alignées. Ainsi, nous pouvons fenêtrer notre corrélation croisée pour ne considérer que les décalages légèrement en avance ou en retard. Pour les microphones 1 et 4, le décalage doit se situer entre +/-12 échantillons, ce qui signifie que pour chaque corrélation croisée, nous n'avons besoin d'effectuer que 24*n calculs, ce qui entraîne des économies de calcul lorsque nos formes d'onde sont plus longues que 2900 échantillons.

Ce système exploite la bibliothèque minidsp, qui implémente l'algorithme GCC-PHAT avec optimisation 3.

Une fois le décalage trouvé dans les signaux de chaque paire de microphones, le programme choisit la valeur médiane du décalage, l'utilise pour calculer l'angle estimé et publie le résultat afin qu'il puisse être utilisé pour contrôler le servo.

Nœud de servocommande

Comparé au nœud kinect_doa, le nœud servo est relativement simple. Son travail consiste uniquement à prendre le DOA estimé et à déplacer le servo à cet angle. Il utilise la bibliothèque wirePi pour accéder au module matériel PWM du Raspberry Pi, en l'utilisant pour définir l'angle du servo. La plupart des servos analogiques sont contrôlés par un signal PWM avec une largeur d'impulsion allant de 1000 µs à 2000 µs, correspondant à un angle de 0° à 180°, mais le servo que j'ai utilisé était contrôlé avec 500 µs à 2500 µs, correspondant à un angle de 0° à 270°. Ainsi, le nœud est configurable pour différents matériels d'asservissement en définissant des paramètres pour la largeur d'impulsion minimale, la largeur d'impulsion maximale et la différence entre les angles maximum et minimum. De plus, le servo ne se déplace pas immédiatement vers l'angle cible, mais se déplace plutôt vers l'angle à une vitesse configurable, donnant à Margaret une ambiance plus progressive et effrayante (de plus, le son d'un servo se déplaçant rapidement d'avant en arrière devient très ennuyeux).

Étape 8: Construire et installer

Installer les dépendances:

Tout d'abord, installez libfreenect. Nous devons le construire à partir des sources car la version que vous pouvez obtenir avec le gestionnaire de packages n'inclut pas la prise en charge de l'audio. C'est parce que nous devons télécharger le micrologiciel sur le Kinect pour activer l'audio, et la redistribution de ce micrologiciel n'est pas légale dans certaines juridictions. De plus, nous pouvons éviter de construire les exemples qui nécessitent OpenGL et surabondance, inutiles pour les installations sans tête Raspbian.

sudo apt-get install git cmake build-essential libusb-1.0-0-dev

cd git clone https://github.com/OpenKinect/libfreenect cd libfreenect mkdir build cd build cmake.. -DCMAKE_BUILD_REDIST_PACKAGE=OFF -DCMAKE_BUILD_EXAMPLES=OFF make sudo make install sudo cp ~/libfreenect/platform/linux/udev/.rules /etc/udev/rules.d udevadm control --reload-rules && udevadm trigger

Ensuite, nous devons installer le package câblagePi, qui nous permet de contrôler les broches GPIO du Pi:

CD

git clone git://git.drogon.net/wiringPi cd ~/wiringPi./build

Attachez la tête de mannequin:

Une fois le câblage Pi installé, nous pouvons maintenant faire un rapide détour par le matériel pour attacher la tête du mannequin sur la plate-forme inférieure. Pour centrer le servo via la ligne de commande, entrez les commandes suivantes:

gpio pwm-ms

gpio pwmc 192 gpio pwmr 2000 gpio -g pwm 18 150

S'il n'y a pas de mouvement, alors votre servo est probablement déjà centré. Pour être sûr, cependant, vous pouvez régler le servo sur une valeur non centrale, par ex. gpio -g pwm 18 200, puis remettez-le à 150.

Une fois que vous êtes sûr que le servo est centré, fixez le palonnier de la plate-forme de tête au servo de sorte que votre tête de mannequin regarde droit vers l'avant. Ensuite, vissez le klaxon sur le servo et fixez votre tête via les embouts Velcro.

Installez ROS:

Ensuite, installez ROS sur votre Pi. Un excellent guide d'installation peut être trouvé ici; pour notre système, nous n'avons pas besoin d'OpenCV, vous pouvez donc ignorer l'étape 3. Cette construction prendra plusieurs heures. Lorsque vous avez terminé de suivre le guide d'installation, ajoutez le sourcing de l'installation à votre bashrc afin que nous puissions utiliser nos packages ROS nouvellement installés:

echo "source /opt/ros/kinetic/setup.bash" >> ~/.bashrc

Construire le package Kinect DOA:

Après tout cela, créez un espace de travail catkin pour notre projet et entrez dans le répertoire src:

mkdir -p ~/kinect_doa_ws/src

cd ~/kinect_doa_ws/src

Le code de ce projet est contenu dans le package kinect_doa, donc clonez-le dans le répertoire src de votre nouvel espace de travail:

git clone

Le package robot_upstart fournit un outil facile à utiliser pour installer les fichiers de lancement afin qu'ils s'exécutent au démarrage, alors clonez-le également dans votre espace de travail:

git clone

Maintenant, nous pouvons construire le code du projet en appelant catkin_make à partir du répertoire de niveau supérieur de notre espace de travail, puis sourcer notre build pour que nos packages soient disponibles:

cd ~/kinect_doa_ws

catkin_make echo "source /home/pi/kinect_doa_ws/devel/setup.bash" >> ~/.bashrc

Exécution et réglage:

En supposant que tout soit branché et sous tension, vous devriez maintenant être en mesure de lancer le système et de faire suivre votre voix par Kinect ! Cependant, si vous avez un Kinect 1473, ouvrez d'abord le fichier ~/kinect_doa_ws/src/kinect_doa/launch/kinect_doa.launch dans un éditeur de texte et définissez le paramètre using_kinect_1473 sur true. De plus, si vous avez utilisé un servo différent de celui que j'ai utilisé, il s'agit probablement d'un servo analogique standard. Ainsi, dans le fichier de lancement, modifiez le paramètre min_us à 1000, max_us à 2000 et max_deg à 180.

roslaunch kinect_doa kinect_doa.launch

Jouez avec pendant un moment. Si vous pensez que le système est trop sensible (en regardant dans des directions aléatoires qui ne correspondent pas à des voix ou à des bruits distinctifs), essayez de modifier le paramètre white_noise_ratio dans le fichier de lancement et de relancer le système jusqu'à ce que la réactivité soit à un niveau avec lequel vous êtes à l'aise. Augmenter le ratio rendra le système moins réactif et vice versa. Vous devrez probablement effectuer ce réglage chaque fois que vous déplacerez le système vers un emplacement différent pour obtenir les performances souhaitées.

Pour lancer le programme lorsque nous mettons le Pi sous tension, nous utilisons le package robot_upstart pour installer notre fichier de lancement. Si ROS n'est pas en cours d'exécution, démarrez-le avec la commande roscore. Ensuite, ouvrez un nouveau terminal et installez le lancement avec:

rosrun robot_upstart installer kinect_doa/launch/kinect_doa.launch --user root --symlink

Nous créons un lien symbolique vers le fichier de lancement au lieu de le copier afin de pouvoir modifier les paramètres en éditant ~/kinect_doa_ws/src/kinect_doa/launch/kinect_doa.launch.

Étape 9: le cacher au bureau

Maintenant pour la partie amusante. Dirigez-vous vers le travail après les heures et placez votre tête de mannequin en secret. Ensuite, asseyez-vous et voyez combien de temps il faut à vos collègues pour comprendre ! Votre nouvelle création est garantie de faire tourner quelques têtes…