From 1618b03843752d9ec861d45d96d70b9c4704be5f Mon Sep 17 00:00:00 2001 From: QLeblanc Date: Tue, 2 Jun 2020 15:43:40 +0200 Subject: [PATCH] =?UTF-8?q?Transf=C3=A9rer=20les=20fichiers=20vers=20'Loca?= =?UTF-8?q?lisation=5F360'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Localisation_360/Localisation_v2.0.0.cpp | 251 +++++++++++++++++++++++ Localisation_360/test.cpp | 116 +++++++++++ Localisation_360/test2.cpp | 100 +++++++++ 3 files changed, 467 insertions(+) create mode 100644 Localisation_360/Localisation_v2.0.0.cpp create mode 100644 Localisation_360/test.cpp create mode 100644 Localisation_360/test2.cpp diff --git a/Localisation_360/Localisation_v2.0.0.cpp b/Localisation_360/Localisation_v2.0.0.cpp new file mode 100644 index 0000000..1273939 --- /dev/null +++ b/Localisation_360/Localisation_v2.0.0.cpp @@ -0,0 +1,251 @@ +#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; + + /** sound samples input buffer */ + SAMPLE_TYPE _TamponDroit[_TailleTampon]; + SAMPLE_TYPE _TamponGauche[_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; + + // ideally use "hw:0,0" for embedded, to limit processing. But check if card support our needs... + const char* CarteSon = "plughw:0,0"; + 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_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_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_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_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_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_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(_capture_handle, hw_params)) < 0) { + fprintf(stderr, "Impossible de definir les parametres (%s)\n", snd_strerror(err)); + exit(1); + } + + snd_pcm_hw_params_free(hw_params); + + 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); + } + } + + /** Clean exit */ + ~Localisation() { + snd_pcm_close(_capture_handle); + 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); + } + + // 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 minDiffTime = -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; + for (int i = _nbEchantillonsDiffMax; i < _TailleTampon - _nbEchantillonsDiffMax - 1; i++) { + diff += abs(_TamponGauche[i] - _TamponDroit[i + t]); + diff2 += abs(_TamponGauche[i] - _TamponDroit[i + t]); + } + if (diff < minDiff) { + minDiff = diff; + minDiffTime = t; + } + + if (diff2 < minDiff) { + minDiff = diff; + minDiffTime = t; + } + } + + // Si le son est assez fort et pas extrême (= ce qui entraine généralement de fausses + // mesures), alors on le dessine: + if ((NivRelatif > _NiveauSonMin) && (minDiffTime > -_nbEchantillonsDiffMax) && (minDiffTime < _nbEchantillonsDiffMax)) { + // computation of angle depending on diff time, sampling rates, + // and geometry + float angle = -(float) asin((minDiffTime * _Vson) / (_TauxEchantillonnageSon* _DistanceMic)); + 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]) / 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); +} diff --git a/Localisation_360/test.cpp b/Localisation_360/test.cpp new file mode 100644 index 0000000..52aaf87 --- /dev/null +++ b/Localisation_360/test.cpp @@ -0,0 +1,116 @@ + 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); + } + + // 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; + for (int i = _nbEchantillonsDiffMax; i < _TailleTampon - _nbEchantillonsDiffMax - 1; i++) { + diff += abs(_TamponGauche[i] - _TamponDroit[i + t]); + } + if (diff < minDiff) { + minDiff = diff; + minDiffTime = t; + } + } + + + for (int t2 = -_nbEchantillonsDiffMax; t2 < _nbEchantillonsDiffMax; t2++) { + int diff2 = 0; + for (int i = _nbEchantillonsDiffMax; i < _TailleTampon - _nbEchantillonsDiffMax - 1; i++) { + diff2 += abs(_TamponGauche[i] - _TamponAvant[i + t2]); + } + + if (diff2 < minDiff2) { + minDiff2 = diff2; + minDiffTime2 = t2; + } + + } + + for (int t3 = -_nbEchantillonsDiffMax; t3 < _nbEchantillonsDiffMax; t3++) { + int diff3 = 0; + for (int i = _nbEchantillonsDiffMax; i < _TailleTampon - _nbEchantillonsDiffMax - 1; i++) { + diff3 += abs(_TamponAvant[i] - _TamponDroit[i + t3]); + } + + if (diff3 < minDiff3) { + minDiff3 = diff3; + minDiffTime3 = t3; + } + + } + + + if (t _NiveauSonMin) && (minDiffTime > -_nbEchantillonsDiffMax) && (minDiffTime < _nbEchantillonsDiffMax)) { + // computation of angle depending on diff time, sampling rates, + // and geometry + float angle = -(float) asin((minDiffTime * _Vson) / (_TauxEchantillonnageSon* _DistanceMic)); + cout << angle << ";" << NivRelatif << endl; + } + } + + if (t2 _NiveauSonMin) && (minDiffTime2 > -_nbEchantillonsDiffMax) && (minDiffTime2 < _nbEchantillonsDiffMax)) { + // computation of angle depending on diff time, sampling rates, + // and geometry + float angle = -(float) asin((minDiffTime2 * _Vson) / (_TauxEchantillonnageSon* _DistanceMic)); + cout << angle << ";" << NivRelatif << endl; + } + } + + if (t3 _NiveauSonMin) && (minDiffTime3 > -_nbEchantillonsDiffMax) && (minDiffTime3 < _nbEchantillonsDiffMax)) { + // computation of angle depending on diff time, sampling rates, + // and geometry + float angle = -(float) asin((minDiffTime3 * _Vson) / (_TauxEchantillonnageSon* _DistanceMic)); + 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]) / 3; + Niveau += (s * s); + } + Niveau /= _TailleTampon; + Niveau = sqrt(Niveau); + return (SAMPLE_TYPE) Niveau; + } +}; diff --git a/Localisation_360/test2.cpp b/Localisation_360/test2.cpp new file mode 100644 index 0000000..48bc99d --- /dev/null +++ b/Localisation_360/test2.cpp @@ -0,0 +1,100 @@ + 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); + } + + // 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; + 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)); + 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)); + 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)); + 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]) / 3; + Niveau += (s * s); + } + Niveau /= _TailleTampon; + Niveau = sqrt(Niveau); + return (SAMPLE_TYPE) Niveau; + } +};