diff --git a/Localisation_360/Localisation_360.cpp b/Localisation_360/Localisation_360.cpp new file mode 100644 index 0000000..2d4d0a1 --- /dev/null +++ b/Localisation_360/Localisation_360.cpp @@ -0,0 +1,358 @@ +#include +using namespace std; + +#include +#include +#include +#include +#include +#include "/usr/include/alsa/asoundlib.h" + +//#define SAMPLE_TYPE float +//#define SAMPLE_TYPE_ALSA SND_PCM_FORMAT_FLOAT_LE + +#define SAMPLE_TYPE short //sample type = type d'echantillon +#define SAMPLE_TYPE_ALSA SND_PCM_FORMAT_S16_LE + +/** + * classe permettant de calculer la moyenne glissante du signal + */ +class MoyenneGlissante { + int _nbDeValeursPrMoy; + int _nbDeValeurs; + float _mean; + +public: + MoyenneGlissante(int nbDeValeursPrMoy) { + _nbDeValeursPrMoy = nbDeValeursPrMoy; + _mean = 0; + _nbDeValeurs = 0; + } + + void nvelleValeur(SAMPLE_TYPE v) { + if (_nbDeValeurs < _nbDeValeursPrMoy) + _nbDeValeurs++; + _mean = ((_mean * (_nbDeValeurs - 1)) + v) / (float)_nbDeValeurs; + } + + SAMPLE_TYPE getMean() { + return (SAMPLE_TYPE) _mean; + } +}; + +/** + * Cette classe calcule la direction du son entendu + * + * + * Elle utilise 2 microphones et calcule la différence de temps d'arrivée des sons entre eux pour + * estimer la localisation de la source sonore. + */ +class Localisation { + + /** + * Décalage maximum entre le micro droit et gauche en nombre d'échantillons. + * Cela dépend généralement de la fréquence d'échantillonnage et de la distance entre + * microphones + */ + static const int _nbEchantillonsDiffMax = 13; //difference max du nombre d'echantillons + + /** + * Taille du tampon sur laquelle nous allons essayer de localiser le son. + * Ceci est un certain nombre d'échantillons, et dépend de la fréquence d'échantillonnage et de la vitesse de + * changement de loc son que nous voulons détecter. Des valeurs plus faibles signifient le calcul du son + * se fait plus souvent, mais la précision est assez faible car nous calculons sur une très petite tranche de + * du son. + */ + static const int _TailleTampon = 4096; + + /** + * Prenez un point pour la localisation du son est Niveau> 105% du Niveau moyen. Cela permet de calculer la + * localisation du son uniquement pour les sons "significatifs", pas le bruit de fond. + */ + static constexpr float _NiveauSonMin = 1.1f; //f de 1.05f signifie :float constant with value of 1.05 + + /** + * sound speed in meters per seconds + */ + static constexpr float _Vson = 344; + + /** + * sound sampling rate in Hz + */ + unsigned int _TauxEchantillonnageSon; + + /** + * Distance between microphones in meters + */ + static constexpr float _DistanceMic = 0.05f;//5 cm de distance entre les deux microphones + + /** An utility to compute the running average of sound power */ + MoyenneGlissante* _MoyNivSonore; + + /** ALSA sound input handle */ + snd_pcm_t* _capture_handle; + snd_pcm_t* _capture_handle2; + + /** sound samples input buffer */ + SAMPLE_TYPE _TamponDroit[_TailleTampon]; + SAMPLE_TYPE _TamponGauche[_TailleTampon]; + SAMPLE_TYPE _TamponAvant[_TailleTampon]; + +public: + Localisation() { + _MoyNivSonore = new MoyenneGlissante(50); + _TauxEchantillonnageSon = 44100; + + // sampling: 2 chanels, 44 KHz, 16 bits. + int err; + snd_pcm_hw_params_t* hw_params; + snd_pcm_hw_params_t* hw_params2; + + // ideally use "hw:0,0" for embedded, to limit processing. But check if card support our needs... + const char* CarteSon = "plughw:0,0"; + const char* CarteSon2 = "plughw:1,0"; +// open_____________________ + if ((err = snd_pcm_open(&_capture_handle, CarteSon, SND_PCM_STREAM_CAPTURE, 0)) < 0) { + fprintf(stderr, "Impossible d'ouvrir le peripherique audio %s (%s)\n", CarteSon,snd_strerror(err)); + exit(1); + } + + if ((err = snd_pcm_open(&_capture_handle2, CarteSon2, SND_PCM_STREAM_CAPTURE, 0)) < 0) { + fprintf(stderr, "Impossible d'ouvrir le peripherique audio %s (%s)\n", CarteSon,snd_strerror(err)); + exit(1); + } +//malloc_____________________ + if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0) { + fprintf(stderr, "Impossible d'allouer la structure des paramètres matériels (%s)\n",snd_strerror(err)); + exit(1); + } + + + if ((err = snd_pcm_hw_params_malloc(&hw_params2)) < 0) { + fprintf(stderr, "Impossible d'allouer la structure des paramètres matériels (%s)\n",snd_strerror(err)); + exit(1); + } +//any_____________________ + + if ((err = snd_pcm_hw_params_any(_capture_handle, hw_params)) < 0) { + fprintf(stderr,"Impossible d'initialiser la structure des paramètres matériels (%s)\n",snd_strerror(err)); + exit(1); + } + + if ((err = snd_pcm_hw_params_any(_capture_handle2, hw_params2)) < 0) { + fprintf(stderr,"Impossible d'initialiser la structure des paramètres matériels (%s)\n",snd_strerror(err)); + exit(1); + } +//access_____________________ + + if ((err = snd_pcm_hw_params_set_access(_capture_handle, hw_params,SND_PCM_ACCESS_RW_NONINTERLEAVED)) < 0) { + fprintf(stderr, "Impossible de definir le type d'acces (%s)\n", snd_strerror(err)); + exit(1); + } + + if ((err = snd_pcm_hw_params_set_access(_capture_handle2, hw_params2,SND_PCM_ACCESS_RW_NONINTERLEAVED)) < 0) { + fprintf(stderr, "Impossible de definir le type d'acces (%s)\n", snd_strerror(err)); + exit(1); + } + //format _____________________ + + if ((err = snd_pcm_hw_params_set_format(_capture_handle, hw_params,SAMPLE_TYPE_ALSA)) < 0) { + fprintf(stderr, "Impossible de definir le format d'echantillonnage (%s)\n",snd_strerror(err)); + exit(1); + } + + if ((err = snd_pcm_hw_params_set_format(_capture_handle2, hw_params2,SAMPLE_TYPE_ALSA)) < 0) { + fprintf(stderr, "Impossible de definir le format d'echantillonnage (%s)\n",snd_strerror(err)); + exit(1); + } +//rate near _____________________ + + if ((err = snd_pcm_hw_params_set_rate_near(_capture_handle, hw_params,&_TauxEchantillonnageSon, 0)) < 0) { + fprintf(stderr, "Impossible de definir le taux d'echantillonnage (%s)\n", snd_strerror(err)); + exit(1); + } + + if ((err = snd_pcm_hw_params_set_rate_near(_capture_handle2, hw_params2,&_TauxEchantillonnageSon, 0)) < 0) { + fprintf(stderr, "Impossible de definir le taux d'echantillonnage (%s)\n", snd_strerror(err)); + exit(1); + } + +//set channels_____________________ + if ((err = snd_pcm_hw_params_set_channels(_capture_handle, hw_params, 2))< 0) { + fprintf(stderr, "Impossible de definir le nombre de canaux (%s)\n", snd_strerror(err)); + exit(1); + } + + if ((err = snd_pcm_hw_params_set_channels(_capture_handle2, hw_params2, 1))< 0) { + fprintf(stderr, "Impossible de definir le nombre de canaux (%s)\n", snd_strerror(err)); + exit(1); + } +//hwparams _____________________ + + if ((err = snd_pcm_hw_params(_capture_handle, hw_params)) < 0) { + fprintf(stderr, "Impossible de definir les parametres (%s)\n", snd_strerror(err)); + exit(1); + } + + if ((err = snd_pcm_hw_params(_capture_handle2, hw_params2)) < 0) { + fprintf(stderr, "Impossible de definir les parametres (%s)\n", snd_strerror(err)); + exit(1); + } + + + snd_pcm_hw_params_free(hw_params); + snd_pcm_hw_params_free(hw_params2); + +//prepare _____________________ + + if ((err = snd_pcm_prepare(_capture_handle)) < 0) { + fprintf(stderr, "Impossible de preparer l'interface audio pour utilisation (%s)\n",snd_strerror(err)); + exit(1); + } + + if ((err = snd_pcm_prepare(_capture_handle2)) < 0) { + fprintf(stderr, "Impossible de preparer l'interface audio pour utilisation (%s)\n",snd_strerror(err)); + exit(1); + } + } + + /** Clean exit */ + ~Localisation() { + snd_pcm_close(_capture_handle); + snd_pcm_close(_capture_handle2); + delete _MoyNivSonore; + } + + /** + * Boucle principale: lit un tampon, calcule la localisation de la source sonore, fait une itération. + */ + void run() { + while (true) { + TraitementSonsSuivants(); + } + } + +private: + /** + * C'est le cœur de la localisation de la source sonore: il prend les sons échantillonnés + * Droit / Gauche, et calcule leurs différences tout en retardant de plus en plus un canal.
+ * => le retard pour lequel la différence est minime est le vrai retard + * entre les sons Droit / Gauche, dont on peut déduire la source sonore + * localisation + */ + void TraitementSonsSuivants() { + SAMPLE_TYPE* bufs[3]; + bufs[0] = _TamponDroit; + bufs[1] = _TamponGauche; + bufs[2] = _TamponAvant; + int err; + if ((err = snd_pcm_readn(_capture_handle, (void**) bufs, _TailleTampon))!= _TailleTampon) { + fprintf(stderr, "Echec de la lecture de l'interface audio (%s)\n",snd_strerror(err)); + exit(1); + } + if ((err = snd_pcm_readn(_capture_handle2, (void**) bufs, _TailleTampon))!= _TailleTampon) { + fprintf(stderr, "Echec de la lecture de l'interface audio (%s)\n",snd_strerror(err)); + exit(1); + } + + // compute the sound level (i.e. "loudness" of the sound): + SAMPLE_TYPE Niveau = CalculNiv(_TamponDroit, _TamponGauche ,_TamponAvant); + // update the average sound level with this new measure: + _MoyNivSonore->nvelleValeur(Niveau); + // relative sound level of this sample compared to average: + float NivRelatif = (float) Niveau / (float) _MoyNivSonore->getMean(); + //cout << "level " << level << ", relative " << NivRelatif << endl; + + int minDiff = INT_MAX; + int minDiff2 = INT_MAX; + int minDiff3 = INT_MAX; + int minDiffTime = -1; + int minDiffTime2 = -1; + int minDiffTime3 = -1; + // glisse sur l'axe du temps pour trouver la différence sonore minimum entre les microphones Droit et Gauche + for (int t = -_nbEchantillonsDiffMax; t < _nbEchantillonsDiffMax; t++) { + // calcule la somme des différences pour simuler une mesure de corrélation croisée: + int diff = 0; + int diff2 = 0; + int diff3 = 0; + for (int i = _nbEchantillonsDiffMax; i < _TailleTampon - _nbEchantillonsDiffMax - 1; i++) { + diff += abs(_TamponGauche[i] - _TamponDroit[i + t]); + diff2 += abs(_TamponGauche[i] - _TamponAvant[i + t]); + diff3 += abs(_TamponAvant[i] - _TamponDroit[i + t]); + } + if (diff < minDiff) { + minDiff = diff; + minDiffTime = t; + } + if (diff2 < minDiff2) { + minDiff2 = diff2; + minDiffTime2 = t; + } + if (diff3 < minDiff3) { + minDiff3 = diff3; + minDiffTime3 = t; + } + } + + + + + if (minDiffTime _NiveauSonMin) && (minDiffTime > -_nbEchantillonsDiffMax) && (minDiffTime < _nbEchantillonsDiffMax)) { + // computation of angle depending on diff time, sampling rates, + // and geometry + float angle = -(float) asin((minDiffTime * _Vson) / (_TauxEchantillonnageSon* _DistanceMic)); + printf("GetD"); + cout << angle << ";" << NivRelatif << endl; + } + } + + if (minDiffTime2 _NiveauSonMin) && (minDiffTime2 > -_nbEchantillonsDiffMax) && (minDiffTime2 < _nbEchantillonsDiffMax)) { + // computation of angle depending on diff time, sampling rates, + // and geometry + float angle = -(float) asin((minDiffTime2 * _Vson) / (_TauxEchantillonnageSon* _DistanceMic)); + printf("GetA"); + cout << angle << ";" << NivRelatif << endl; + } + } + + if (minDiffTime3 _NiveauSonMin) && (minDiffTime3 > -_nbEchantillonsDiffMax) && (minDiffTime3 < _nbEchantillonsDiffMax)) { + // computation of angle depending on diff time, sampling rates, + // and geometry + float angle = -(float) asin((minDiffTime3 * _Vson) / (_TauxEchantillonnageSon* _DistanceMic)); + printf("DetA3"); + cout << angle << ";" << NivRelatif << endl; + } + } + + + } + + /** + * Calcule du niveau sonore moyen (la puissance) pour les canaux gauche et droit. + */ + SAMPLE_TYPE CalculNiv(SAMPLE_TYPE Droit[], SAMPLE_TYPE Gauche[], SAMPLE_TYPE Avant[]) { + float Niveau = 0; + for (int i = 0; i < _TailleTampon; i++) { + float s = (Gauche[i] + Droit[i]/*+ Avant[i]*/) / 2/*3*/; + Niveau += (s * s); + } + Niveau /= _TailleTampon; + Niveau = sqrt(Niveau); + return (SAMPLE_TYPE) Niveau; + } +}; + +int main(int argc, char *argv[]) { + Localisation soundLoc; + soundLoc.run(); + exit(0); +}