Club robotique de Sophia-Antipolis

Accueil > Projets et études > Etudes techniques > Son > La localisation des sources de son : portage sur la Raspberry (...)

La localisation des sources de son : portage sur la Raspberry Pi

jeudi 17 octobre 2013, par Frédéric P.

Cet article présentait les bases de la localisation des sources de son, et celui ci le portage du code Java vers C++/ALSA. L’objectif avoué était de faire fonctionner tout cela sur une Raspberry Pi. C’est l’objet de cet article.

 Le Matériel et l’installation de base

Pour effectuer le portage, il nous faut :

  • une Raspberry Pi
  • un micro stéréo : le PS3 Eye

L’installation de la Raspberry Pi est classique. J’ai utilisé la distribution Raspbian référencée sur le site raspberrypi.org.
Apres installation, j’ai autorisé les connections ssh via le menu de raspi-config (section advanced). => dès lors, on peut se connecter à la carte via ssh, plus besoin d’écran ou de clavier sur celle ci.

Pour plus de confort, un petit setup de VNC : vous avez un tuto ici, j’ai suivi le même chemin.
Donc :

Je voulais aussi que le serveur VNC se lance automatiquement à chaque démarrage, donc j’ai ajouté à la fin de /etc/rc.local (avant le exit 0) la ligne magique :

Bon, voila, une Raspberry Pi en pleine forme.

Pour la PS3 Eye, j’ai suivi le tuto ici : rien à dire, tout marche sans problème, son et image.

 Premier essai de portage

On reprend les sources en C++ de l’article précédent :

Pour compiler avec ALSA, il nous faut les headers de la librairie, donc :

On peut maintenant tenter de compiler :

Ca compile sans probleme, on peut lancer :

Oups, ce n’est pas le bon device. Il faut quelques adaptations pour la PS3 Eye...

 Adaptation à la PS3 Eye

Sur la PS3 Eye, le device n’est pas le même que pour le micro utilisé dans mes essais précédents.
Rien de bien sorcier, le device son de la PS3 Eye est 1, donc on change :

De même, la distance entre les microphones est différente, donc le calcul du temps de décalage entre l’arrivée des son sur chaque microphone et l’angle de l’interlocuteur doit être adapté.
Au passage, une petite modification pour calculer le nombre d’échantillons max de décalage en fonction de la distance entre les microphones et de la vitesse du son :

 /**
         * Max time shift between right and left mic in number of samples.
         * This typically depends on the sample rate and the distance between
         * microphones. <br/>
         * You have max_samples_shifts=(dist_between_mic/speed_of_sound) * sample_rate
         */

        int _nbSamplesMaxDiff;
        /**
         * sound speed in meters per seconds
         */

        static const float _soundSpeed = 344;
        /**
         * Distance between microphones in meters
         * for PS3 eye: http://www.rrfx.net/2009/11/ps3-eye-4-channel-audio-tests-on-ubuntu.html
         */

        static const float _distanceBetweenMicrophones = 0.062f;
SoundSourceLoc() {
                ....
                // compute extreme sample diff
                _nbSamplesMaxDiff = (_distanceBetweenMicrophones/_soundSpeed)*_soundSamplingRate+1;
        }

Le code final est lié à cet article.

Voila, on peut recompiler et relancer :

Mieux !

 Visualisation des résultats : un peu de ssh ?

Il n’y a plus qu’à visualiser les informations d’angle sorties par ce programme, pour voir si ça fonctionne toujours bien.
Pour ce faire, on reprend le programme Java SoundSourceDraw utilisé lors du précédent article.
On pourrait le lancer sur la Raspberry Pi aussi, mais ce n’est pas très adapté (d’autant que je passe par VNC !) pour de l’affichage rapide.
Donc pour le fun, lançons le programme sur une autre machine (de bureau), et connectons la à la Raspberry Pi.
Le plus simple est de tout simplement lancer le programme sur la Raspberry par ssh, exactement comme lorsqu’on le lançait localement, sauf que cette fois il est sur une autre machine.
Ainsi on avait initialement pour le lancement local :

public class SoundSourceDraw extends JFrame {
....
        public void run() throws IOException {
                ProcessBuilder pb = new ProcessBuilder(
                                "/home/colbot/workspace_eclipse/sound-source-loc/Debug/sound-source-loc");

Il suffit de le remplacer par :

public class SoundSourceDraw extends JFrame {
....
        public void run() throws IOException {
                public void run() throws IOException {
                ProcessBuilder pb = new ProcessBuilder("ssh",
                                "pi@raspberrypi",
                                "/home/pi/sound-source-loc/src/sound-source-loc");

 Setup de la connexion ssh sans mot de passe

Pour que cela fonctionne, il faut une connexion ssh sans mot de passe, donc avec un petit setup de clés ssh.
Il y a plusieurs tuto la dessus, par exemple ici, mais en résumé :
Sur la machine de bureau (un Linux, ou un Windows avec cygwin et openssh) :

Sur la Raspberry Pi :

On peut alors se connecter à la rapsberrypi depuis la machine de bureau sans mot de passe :
Sur la machine de bureau :

ne doit pas demander de mot de passe et ouvrir un shell sur la raspberry directement.

 Visualisation des résultats : ça fonctionne !

Voila ! Une fois cette mise en place ssh terminée, il n’y a plus qu’à lancer le programme Java, qui à son tour va lancer le programme ’sound-source-loc’ sur la Raspberry Pi, et visualiser les résultats.
Un petit bruit à droite, puis à gauche...
Ça fonctionne ! Comme avant, mais sur la Raspberry :-)

 Et après ?

Le programme sound-source-loc tourne maintenant sur une carte apte à être intégrée dans un robot.
On se rapproche de l’objectif, faire tourner la tête d’un robot lorsqu’il entend un son d’un coté. Il ne reste plus qu’à commander un servomoteur par exemple, en fonction de l’angle du son incident renvoyé par le programme sound-source-loc.
Ce sera l’objet d’un prochain article...

Vos commentaires

  • Le 23 octobre 2013 à 14:11, par N En réponse à : La localisation des sources de son : portage sur la Raspberry Pi

    Une petite modification pourrait être de créer une image, chaque pixel d’une image correspond au même décalage de temps entre les microphones. Sur un ensemble de point, on soustraie la moyenne à ces mesures. Ensuite, on multiplie les mesures décalées entre elle, puis on somme (corrélation, si je me souviens bien). Un point claire devrait se former sur l’image à l’origine d’un son.

    • Le 23 octobre 2013 à 15:04, par Julien H. En réponse à : La localisation des sources de son : portage sur la Raspberry Pi

      Pour ce qui me concerne je n’ai rien compris à cette modification. Comment faire correspondre un pixel et un décalage de temps ? En hauteur ou en largeur ?

      Bref, quel est l’objectif et peut-on avoir une illustration de ce que ça donnerait ?

    Répondre à ce message

Un message, un commentaire ?

modération a priori

Attention, votre message n’apparaîtra qu’après avoir été relu et approuvé.

Qui êtes-vous ?

Pour afficher votre trombine avec votre message, enregistrez-la d’abord sur gravatar.com (gratuit et indolore) et n’oubliez pas d’indiquer votre adresse e-mail ici.

Ajoutez votre commentaire ici
  • Ce formulaire accepte les raccourcis SPIP [->url] {{gras}} {italique} <quote> <code> et le code HTML <q> <del> <ins>. Pour créer des paragraphes, laissez simplement des lignes vides.

Ajouter un document