https://air.imag.fr/api.php?action=feedcontributions&user=Fred&feedformat=atomair - User contributions [en]2024-03-29T10:37:47ZUser contributionsMediaWiki 1.35.13https://air.imag.fr/index.php?title=Interface_graphique_du_client&diff=1624Interface graphique du client2011-03-13T18:34:25Z<p>Fred: /* IHM concrète: */</p>
<hr />
<div>== Fonctionnalités de l'IHM ==<br />
<br />
<br />
*Réglage du seuil de tolérance de comparaison<br />
*Bouton de lancement de test<br />
*Acquisition / Execution des fichiers sonores : externe via un logiciel dédiée dans un premier temps pour faciliter le développement<br />
<br />
<u>Affichage</u><br />
<br />
*Texte décrivant l'état du système et affichage graphique<br />
*Affichage des clés<br />
*Distance au seuil<br />
*Menu aide<br />
<br />
==== Extensions ====<br />
*Enregistrement des fichiers sonores directement dans l'application<br />
*2 modes<br />
*Gestionnaire de modèles de voix (Ajout/Modification/Suppression de modèle) dans l'application<br />
<br />
== Etat du système : ==<br />
<br />
<br />
Bouton rouge / vert : Porte fermée / ouverte<br />
<br />
*Attente d'un fichier<br />
<br />
*Chargement<br />
*Traitement<br />
<br />
*Accès autorisé<br />
*Accès refusé<br />
<br />
== IHM concrète: ==<br />
<br />
<br />
[[File:Interface1.jpg|500px]]<br />
<br />
En mode test, on sélectionne via un explorateur, le fichier à tester puis on décide du seuil de tolérance à appliquer lors de la comparaison,<br />
ensuite on peut lancer le test, et le processus s'enclenche. En sortie, on obtient le résultat de la comparaison de façon textuelle et graphique, et<br />
également réelle (gache ouverte ou fermée).<br />
<br />
<br />
<br />
[[File:Interface2.jpg|500px]]<br />
<br />
En mode acquisition, on fournit au logiciel différents samples de voix pour un Sujet X. On valide, et un profil est réalisé pour cet individu.</div>Fredhttps://air.imag.fr/index.php?title=Interface_graphique_du_client&diff=1623Interface graphique du client2011-03-13T18:34:09Z<p>Fred: /* IHM concrète: */</p>
<hr />
<div>== Fonctionnalités de l'IHM ==<br />
<br />
<br />
*Réglage du seuil de tolérance de comparaison<br />
*Bouton de lancement de test<br />
*Acquisition / Execution des fichiers sonores : externe via un logiciel dédiée dans un premier temps pour faciliter le développement<br />
<br />
<u>Affichage</u><br />
<br />
*Texte décrivant l'état du système et affichage graphique<br />
*Affichage des clés<br />
*Distance au seuil<br />
*Menu aide<br />
<br />
==== Extensions ====<br />
*Enregistrement des fichiers sonores directement dans l'application<br />
*2 modes<br />
*Gestionnaire de modèles de voix (Ajout/Modification/Suppression de modèle) dans l'application<br />
<br />
== Etat du système : ==<br />
<br />
<br />
Bouton rouge / vert : Porte fermée / ouverte<br />
<br />
*Attente d'un fichier<br />
<br />
*Chargement<br />
*Traitement<br />
<br />
*Accès autorisé<br />
*Accès refusé<br />
<br />
== IHM concrète: ==<br />
<br />
<br />
[[File:Interface1.jpg|300px]]<br />
<br />
En mode test, on sélectionne via un explorateur, le fichier à tester puis on décide du seuil de tolérance à appliquer lors de la comparaison,<br />
ensuite on peut lancer le test, et le processus s'enclenche. En sortie, on obtient le résultat de la comparaison de façon textuelle et graphique, et<br />
également réelle (gache ouverte ou fermée).<br />
<br />
<br />
<br />
[[File:Interface2.jpg|300px]]<br />
<br />
En mode acquisition, on fournit au logiciel différents samples de voix pour un Sujet X. On valide, et un profil est réalisé pour cet individu.</div>Fredhttps://air.imag.fr/index.php?title=G%C3%A2che_%C3%A9lectrique_et_montage_TouchKey&diff=1622Gâche électrique et montage TouchKey2011-03-13T18:25:00Z<p>Fred: </p>
<hr />
<div>== La gâche électrique ==<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
<br />
La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
<br />
* Gache électrique réversible gauche ou droite.<br />
* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
* Référence :<br />
<br />
<br />
== Le circuit électronique ==<br />
<br />
<br />
<br />
Le circuit électronique provient également du projet TouchKey.<br />
<br />
* Contenu : deux résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation. <br />
* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
* Photos d'illustration :<br />
<br />
<br />
== La conversion numérique/analogique (CAN)==<br />
<br />
<br />
* Technologie utilisée : Micro-contrôleur</div>Fredhttps://air.imag.fr/index.php?title=G%C3%A2che_%C3%A9lectrique_et_montage_TouchKey&diff=1621Gâche électrique et montage TouchKey2011-03-13T18:24:36Z<p>Fred: /* La gâche électrique */</p>
<hr />
<div>== La gâche électrique ==<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
<br />
La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
<br />
* Gache électrique réversible gauche ou droite.<br />
* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
* Référence :<br />
<br />
== Le circuit électronique ==<br />
<br />
<br />
<br />
Le circuit électronique provient également du projet TouchKey.<br />
<br />
* Contenu : deux résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation. <br />
* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
* Photos d'illustration :<br />
<br />
== La conversion numérique/analogique (CAN)==<br />
<br />
<br />
* Technologie utilisée : Micro-contrôleur</div>Fredhttps://air.imag.fr/index.php?title=G%C3%A2che_%C3%A9lectrique_et_montage_TouchKey&diff=1620Gâche électrique et montage TouchKey2011-03-13T18:24:06Z<p>Fred: /* Le circuit électronique */</p>
<hr />
<div>== La gâche électrique ==<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
<br />
La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
<br />
* Gache électrique réversible gauche ou droite.<br />
* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
* Référence : <br />
<br />
<br />
== Le circuit électronique ==<br />
<br />
<br />
<br />
Le circuit électronique provient également du projet TouchKey.<br />
<br />
* Contenu : deux résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation. <br />
* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
* Photos d'illustration :<br />
<br />
== La conversion numérique/analogique (CAN)==<br />
<br />
<br />
* Technologie utilisée : Micro-contrôleur</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1619PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T18:23:51Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
----<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
:Lors d'un rendez-vous pris avec les enseignants 3I de 5ème année ainsi qu'avec une partie des étudiants 3I4, une autre solution a été pensée. Il s'agirait d'utiliser la sortie son du pc afin de générer un son (signal) disposant d'une caractéristique précise (fréquence rapide, amplitude élevée, répétitif, durée fixe) permettant l'ouverture de la gâche. La sortie Jack utilise une plage de son atteignant une fréquence maximale de 20Khz, suffisamment rapide pour que ce son soit assimilé à une fonction porte (soit un 1 logique). Toutefois cette solution n'a pu être testée. Elle reste donc une voie d'expérimentation à poursuivre.<br />
<br />
<br />
'''Solution retenue'''<br />
----<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
Puisque la finalité de ce projet est de proposer '''une''' solution, nous avons décider de réutiliser un micro-contrôleur. Cette solution est somme toute onéreuse mais simple et efficace.<br />
<br />
Dans la pratique, nous utilisons un Arduino Uno. Celui-ci reste à l'écoute de son port série (port série virtuel car en réalité, on passe par de l'USB) et si il reçoit l'ordre d'ouverture, il envoi un état haut sur l'une des ses broches (la broche "digital 13"). Le courant envoyé sur la broche est suffisant pour commander le transistor. <br />
Pour envoyer des données sur le port série virtuel, nous avons réalisé un programme java qui, à la réception d'un booléen, envoie la commande d'ouverture. Concernant le protocole, nous utilisons la librairie RXTX, comme recommandé sur le site de l'Arduino. <br />
<br />
Cependant, une erreur non résolue à ce jour dans l'installation de la librairie nous à empecher de réaliser l'ouverture de façon automatique. Seul une ouverture manuelle est fonctionnelle (envoi de la commande via le "serial monitor" de l'IDE Arduino).<br />
<br />
:''Ressources''<br />
:* [[Schéma électronique]]<br />
:* [[Media:SerialTest.txt|Code Java]]<br />
:* [[Media:test.pde|Code Arduino]]<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1618PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T18:22:53Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
----<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
:Lors d'un rendez-vous pris avec les enseignants 3I de 5ème année ainsi qu'avec une partie des étudiants 3I4, une autre solution a été pensée. Il s'agirait d'utiliser la sortie son du pc afin de générer un son (signal) disposant d'une caractéristique précise (fréquence rapide, amplitude élevée, répétitif, durée fixe) permettant l'ouverture de la gâche. La sortie Jack utilise une plage de son atteignant une fréquence maximale de 20Khz, suffisamment rapide pour que ce son soit assimilé à une fonction porte (soit un 1 logique). Toutefois cette solution n'a pu être testée. Elle reste donc une voie d'expérimentation à poursuivre.<br />
<br />
<br />
'''Solution retenue'''<br />
----<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
Puisque la finalité de ce projet est de proposer '''une''' solution, nous avons décider de réutiliser un micro-contrôleur. Cette solution est somme toute onéreuse mais simple et efficace.<br />
<br />
Dans la pratique, nous utilisons un Arduino Uno. Celui-ci reste à l'écoute de son port série (port série virtuel car en réalité, on passe par de l'USB) et si il reçoit l'ordre d'ouverture, il envoi un état haut sur l'une des ses broches (la broche "digital 13"). Le courant envoyé sur la broche est suffisant pour commander le transistor. <br />
Pour envoyer des données sur le port série virtuel, nous avons réalisé un programme java qui, à la réception d'un booléen, envoie la commande d'ouverture. Concernant le protocole, nous utilisons la librairie RXTX, comme recommandé sur le site de l'Arduino. <br />
<br />
Cependant, une erreur non résolu à ce jours dans l'installatino de la librairie nous à empecher de réaliser l'ouverture de façon automatique. Seul une ouverture manuel est fonction (envoi de la commande via le "serial monitor" de l'ide arduino).<br />
<br />
:''Ressources''<br />
:* [[Schéma électronique]]<br />
:* [[Media:SerialTest.txt|Code Java]]<br />
:* [[Media:test.pde|Code Arduino]]<br />
:<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1617PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T18:22:13Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
----<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
:Lors d'un rendez-vous pris avec les enseignants 3I de 5ème année ainsi qu'avec une partie des étudiants 3I4, une autre solution a été pensée. Il s'agirait d'utiliser la sortie son du pc afin de générer un son (signal) disposant d'une caractéristique précise (fréquence rapide, amplitude élevée, répétitif, durée fixe) permettant l'ouverture de la gâche. La sortie Jack utilise une plage de son atteignant une fréquence maximale de 20Khz, suffisamment rapide pour que ce son soit assimilé à une fonction porte (soit un 1 logique). Toutefois cette solution n'a pu être testée. Elle reste donc une voie d'expérimentation à poursuivre.<br />
<br />
<br />
'''Solution retenue'''<br />
----<br />
<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
Puisque la finalité de ce projet est de proposer '''une''' solution, nous avons décider de réutiliser un micro-contrôleur. Cette solution est somme toute onéreuse mais simple et efficace.<br />
<br />
Dans la pratique, nous utilisons un Arduino Uno. Celui-ci reste à l'écoute de son port série (port série virtuel car en réalité, on passe par de l'USB) et si il reçoit l'ordre d'ouverture, il envoi un état haut sur l'une des ses broches (la broche "digital 13"). Le courant envoyé sur la broche est suffisant pour commander le transistor. <br />
Pour envoyer des données sur le port série virtuel, nous avons réalisé un programme java qui, à la réception d'un booléen, envoie la commande d'ouverture. Concernant le protocole, nous utilisons la librairie RXTX, comme recommandé sur le site de l'Arduino. <br />
<br />
Cependant, une erreur non résolu à ce jours dans l'installatino de la librairie nous à empecher de réaliser l'ouverture de façon automatique. Seul une ouverture manuel est fonction (envoi de la commande via le "serial monitor" de l'ide arduino).<br />
<br />
:''Ressources''<br />
:* [[Schéma électronique]]<br />
:* [[Media:SerialTest.txt|Code Java]]<br />
:* [[Media:test.pde|Code Arduino]]<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1616PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T18:18:12Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
----<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
:Lors d'un rendez-vous pris avec les enseignants 3I de 5ème année ainsi qu'avec une partie des étudiants 3I4, une autre solution a été pensée. Il s'agirait d'utiliser la sortie son du pc afin de générer un son (signal) disposant d'une caractéristique précise (fréquence rapide, amplitude élevée, répétitif, durée fixe) permettant l'ouverture de la gâche. La sortie Jack utilise une plage de son atteignant une fréquence maximale de 20Khz, suffisamment rapide pour que ce son soit assimilé à une fonction porte (soit un 1 logique). Toutefois cette solution n'a pu être testée. Elle reste donc une voie d'expérimentation à poursuivre.<br />
<br />
<br />
'''Solution retenue'''<br />
----<br />
<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
Puisque la finalité de ce projet est de proposer '''une''' solution, nous avons décider de réutiliser un micro-contrôleur. Cette solution est somme toute onéreuse mais simple et efficace.<br />
<br />
Dans la pratique, nous utilisons un Arduino Uno. Celui-ci reste à l'écoute de son port série (port série virtuel car en réalité, on passe par de l'USB) et si il reçoit l'ordre d'ouverture, il envoi un état haut sur l'une des ses broches (la broche "digital 13"). Le courant envoyé sur la broche est suffisant pour commander le transistor. <br />
Pour envoyer des données sur le port série virtuel, nous avons réalisé un programme java qui, à la réception d'un booléen, envoie la commande d'ouverture. Concernant le protocole, nous utilisons la librairie RXTX, comme recommandé sur le site de l'Arduino. <br />
<br />
Cependant, une erreur non résolu à ce jours dans l'installatino de la librairie nous à empecher de réaliser l'ouverture de façon automatique. Seul une ouverture manuel est fonction (envoi de la commande via le "serial monitor" de l'ide arduino).<br />
<br />
:''Ressources''<br />
:* [[Schéma électronique]]<br />
:* [[Media:SerialTest.txt|Code Java]]<br />
:* [[Media:test.pde|Code Arduino]]<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1615PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T18:14:48Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
----<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
:Lors d'un rendez-vous pris avec les enseignants 3I de 5ème année ainsi qu'avec une partie des étudiants 3I4, une autre solution a été pensée. Il s'agirait d'utiliser la sortie son du pc afin de générer un son (signal) disposant d'une caractéristique précise (fréquence rapide, amplitude élevée, répétitif, durée fixe) permettant l'ouverture de la gâche. La sortie Jack utilise une plage de son atteignant une fréquence maximale de 20Khz, suffisamment rapide pour que ce son soit assimilé à une fonction porte (soit un 1 logique). Toutefois cette solution n'a pu être testée. Elle reste donc une voie d'expérimentation à poursuivre.<br />
<br />
<br />
'''Solution retenue'''<br />
----<br />
<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
Puisque la finalité de ce projet est de proposer '''une''' solution, nous avons décider de réutiliser un micro-contrôleur. Cette solution est somme toute onéreuse mais simple et efficace.<br />
<br />
Dans la pratique, nous utilisons un Arduino Uno. Celui-ci reste à l'écoute de son port série (port série virtuel car en réalité, on passe par de l'USB) et si il reçoit l'ordre d'ouverture, il envoi un état haut sur l'une des ses broches (la broche "digital 13"). Le courant envoyé sur la broche est suffisant pour commander le transistor. <br />
Pour envoyer des données sur le port série virtuel, nous avons réalisé un programme java qui, à la réception d'un booléen, envoie la commande d'ouverture. Concernant le protocole, nous utilisons la librairie RXTX, comme recommandé sur le site de l'Arduino. <br />
<br />
Cependant, une erreur non résolu à ce jours dans l'installatino de la librairie nous à empecher de réaliser l'ouverture de façon automatique. Seul une ouverture manuel est fonction (envoi de la commande via le "serial monitor" de l'ide arduino).<br />
<br />
:''Ressources''<br />
:* [[Schéma électronique]]<br />
:* [[Media:SerialTest.txt|Code Java]]<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=File:SerialTest.txt&diff=1614File:SerialTest.txt2011-03-13T18:11:11Z<p>Fred: Programme de test en JAVA utilisant la librairie RXTX et le port USB pour commander l'ouverture de la gâche.
(A renommer en .java)</p>
<hr />
<div>Programme de test en JAVA utilisant la librairie RXTX et le port USB pour commander l'ouverture de la gâche.<br />
(A renommer en .java)</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1613PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T18:05:27Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
----<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
:Lors d'un rendez-vous pris avec les enseignants 3I de 5ème année ainsi qu'avec une partie des étudiants 3I4, une autre solution a été pensée. Il s'agirait d'utiliser la sortie son du pc afin de générer un son (signal) disposant d'une caractéristique précise (fréquence rapide, amplitude élevée, répétitif, durée fixe) permettant l'ouverture de la gâche. La sortie Jack utilise une plage de son atteignant une fréquence maximale de 20Khz, suffisamment rapide pour que ce son soit assimilé à une fonction porte (soit un 1 logique). Toutefois cette solution n'a pu être testée. Elle reste donc une voie d'expérimentation à poursuivre.<br />
<br />
<br />
'''Solution retenue'''<br />
----<br />
<br />
<br />
:Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
:Puisque la finalité de ce projet est de proposer '''une''' solution, nous avons décider de réutiliser un micro-contrôleur. Cette solution est somme toute onéreuse mais simple et efficace.<br />
<br />
:Dans la pratique, nous utilisons un Arduino Uno. Celui-ci reste à l'écoute de son port série (port série virtuel car en réalité, on passe par de l'USB) et si il reçoit l'ordre d'ouverture, il envoi un état haut sur l'une des ses broches (la broche "digital 13"). Le courant envoyé sur la broche est suffisant pour commander le transistor. <br />
:Pour envoyer des données sur le port série virtuel, nous avons réalisé un programme java qui, à la réception d'un booléen, envoie la commande d'ouverture. Concernant le protocole, nous utilisons la librairie RXTX, comme recommandé sur le site de l'Arduino. <br />
<br />
:Cependant, une erreur non résolu à ce jours dans l'installatino de la librairie nous à empecher de réaliser l'ouverture de façon automatique. Seul une ouverture manuel est fonction (envoi de la commande via le "serial monitor" de l'ide arduino).<br />
<br />
:''Ressources''<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1612PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T18:04:52Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
----<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
:Lors d'un rendez-vous pris avec les enseignants 3I de 5ème année ainsi qu'avec une partie des étudiants 3I4, une autre solution a été pensée. Il s'agirait d'utiliser la sortie son du pc afin de générer un son (signal) disposant d'une caractéristique précise (fréquence rapide, amplitude élevée, répétitif, durée fixe) permettant l'ouverture de la gâche. La sortie Jack utilise une plage de son atteignant une fréquence maximale de 20Khz, suffisamment rapide pour que ce son soit assimilé à une fonction porte (soit un 1 logique). Toutefois cette solution n'a pu être testée. Elle reste donc une voie d'expérimentation à poursuivre.<br />
<br />
<br />
'''Solution retenue'''<br />
----<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
Puisque la finalité de ce projet est de proposer '''une''' solution, nous avons décider de réutiliser un micro-contrôleur. Cette solution est somme toute onéreuse mais simple et efficace.<br />
<br />
Dans la pratique, nous utilisons un Arduino Uno. Celui-ci reste à l'écoute de son port série (port série virtuel car en réalité, on passe par de l'USB) et si il reçoit l'ordre d'ouverture, il envoi un état haut sur l'une des ses broches (la broche "digital 13"). Le courant envoyé sur la broche est suffisant pour commander le transistor. <br />
Pour envoyer des données sur le port série virtuel, nous avons réalisé un programme java qui, à la réception d'un booléen, envoie la commande d'ouverture. Concernant le protocole, nous utilisons la librairie RXTX, comme recommandé sur le site de l'Arduino. <br />
<br />
Cependant, une erreur non résolu à ce jours dans l'installatino de la librairie nous à empecher de réaliser l'ouverture de façon automatique. Seul une ouverture manuel est fonction (envoi de la commande via le "serial monitor" de l'ide arduino).<br />
<br />
:''Ressources''<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1611PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T18:02:01Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
:Lors d'un rendez-vous pris avec les enseignants 3I de 5ème année ainsi qu'avec une partie des étudiants 3I4, une autre solution a été pensée. Il s'agirait d'utiliser la sortie son du pc afin de générer un son (signal) disposant d'une caractéristique précise (fréquence rapide, amplitude élevée, répétitif, durée fixe) permettant l'ouverture de la gâche. La sortie Jack utilise une plage de son atteignant une fréquence maximale de 20Khz, suffisamment rapide pour que ce son soit assimilé à une fonction porte (soit un 1 logique). Toutefois cette solution n'a pu être testée. Elle reste donc une voie d'expérimentation à poursuivre.<br />
<br />
<br />
'''Solution retenue'''<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
Puisque la finalité de ce projet est de proposer '''une''' solution, nous avons décider de réutiliser un micro-contrôleur. Cette solution est somme toute onéreuse mais simple et efficace.<br />
<br />
Dans la pratique, nous utilisons un Arduino Uno. Celui-ci reste à l'écoute de son port série (port série virtuel car en réalité, on passe par de l'USB) et si il reçoit l'ordre d'ouverture, il envoi un état haut sur l'une des ses broches (la broche "digital 13"). Le courant envoyé sur la broche est suffisant pour commander le transistor. <br />
Pour envoyer des donnée sur le port série virtuel, nous avons réalisé un programme java qui, à la réception d'un booléen, envoie la commande d'ouverture. Concernant le protocole, nous utilisons la librairie RXTX, comme recommandé sur le site de l'Arduino. <br />
<br />
Cependant, une erreur non résolu à ce jours dans l'installatino de la librairie nous à empecher de réaliser l'ouverture de façon automatique. Seul une ouverture manuel est fonction (envoi de la commande via le "serial monitor" de l'ide arduino).<br />
<br />
<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1610PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T17:56:38Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
:Lors d'un rendez-vous pris avec les enseignants 3I de 5ème année ainsi qu'avec une partie des étudiants 3I4, une autre solution a été pensée. Il s'agirait d'utiliser la sortie son du pc afin de générer un son (signal) disposant d'une caractéristique précise (fréquence rapide, amplitude élevée, répétitif, durée fixe) permettant l'ouverture de la gâche. La sortie Jack utilise une plage de son atteignant une fréquence maximale de20Khz, suffisamment rapide pour que ce son soit assimilé à une fonction porte (soit un 1 logique). Toutefois cette solution n'a pu être testée. Elle reste donc une voie d'expérimentation à poursuivre.<br />
<br />
<br />
'''Solution retenue'''<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1609PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T17:50:36Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
:Cette solution a donc été abandonnée.<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
:En raisons des mêmes contraintes que celles du port USB évoquées ci-dessus, cette solution a du être abandonnée également. Notons toutefois que les librairies sont beaucoup plus répandues et stables et disposent d'une communauté plus présente.<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
<br />
<br />
'''Solution retenue'''<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1608PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T17:47:36Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
<br />
<br />
'''Solution retenue'''<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1607PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T17:47:23Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].''<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
:Une première idée afin de commander la gâche à partir du pc a été d'utiliser le port USB. Le courant générer aurait suffit à déclencher le transistor et ainsi ouvrir la gache. Après quelques recherches et expérimentations, nous avons rencontré plusieurs problèmes majeurs :<br />
:#Il faut savoir que l'ordinateur n'apprécie absolument pas que l'on se serve du port USB comme prise de courant (mise à part les nouveaux ports estampillés d'un "éclair"). Nous avons provoqué des court-circuits en effectuant certain de nos tests, ce qui a failli nous coûter un pc portable.<br />
:#Le protocole USB est un protocole gérer par le système d'exploitation et dont nous n'avons pas la main, notamment sur les entêtes. Devant cette impossibilité de contrôler avec précision les messages envoyés, cette solution générerait des problèmes d'ouverture/fermeture intempestive lors de l'envoi d'un signal d'ouverture à cause des ces dites entêtes.<br />
:#Les librairies JAVA pour USB sont à la fois très peu nombreuses (jusb et jsr80) et relativement instables et ce sans parler de la difficulté à les mettre en œuvre.<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
<br />
<br />
'''Solution retenue'''<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=G%C3%A2che_%C3%A9lectrique_et_montage_TouchKey&diff=1606Gâche électrique et montage TouchKey2011-03-13T17:29:23Z<p>Fred: </p>
<hr />
<div>== La gâche électrique ==<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
<br />
La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
<br />
* Gache électrique réversible gauche ou droite.<br />
* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
* Référence : <br />
<br />
<br />
== Le circuit électronique ==<br />
<br />
<br />
<br />
Le circuit électronique provient également du projet TouchKey.<br />
<br />
* Contenu : deux résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
* Schéma : <br />
* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
* Photos d'illustration :<br />
<br />
<br />
== La conversion numérique/analogique (CAN)==<br />
<br />
<br />
* Technologie utilisée : Micro-contrôleur</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1605PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T17:23:25Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:'''Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].'''<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
<br />
<br />
'''Solution retenue'''<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1604PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T17:23:01Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
:'Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].'<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
<br />
<br />
'''Solution retenue'''<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1603PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T17:22:37Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
Voici la liste des solutions envisagées :<br />
<br />
* '''''Réutilisation de la solution du projet TouchKey'''''<br />
<br />
:Au début du projet, il nous a été fournit une gâche électrique ainsi qu'un circuit électronique provenant d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey. La gâche est totalement réutilisable puisqu'il s'agit d'une simple gâche commandable à 2 états : ouverte (alimentée) ou fermée (non alimentée). Le circuit électronique n'est pas utilisable tel quel. En effet lors de ce projet était utilisé un micro-contrôleur, est celui-ci commandait l'ouverture de la gâche par commande électrique. Il servait donc de CNA. Dans notre cas, nous souhaitons une utilisation directe par le pc pour la commande d'ouverture. Pour cela, il suffit alors d'utiliser le circuit en modifiant la connexion et le type de commande.<br />
<br />
Plus d'informations techniques sur la gâche et le circuit suivant ce lien [[Gâche électrique et montage TouchKey]].<br />
<br />
<br />
* '''''Commande via port USB'''''<br />
<br />
<br />
<br />
* '''''Commande via port série'''''<br />
<br />
<br />
<br />
* '''''Utilisation de la sortie son (prise Jack)'''''<br />
<br />
<br />
<br />
'''Solution retenue'''<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
'''Pour la suite'''<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=G%C3%A2che_%C3%A9lectrique_et_montage_TouchKey&diff=1602Gâche électrique et montage TouchKey2011-03-13T17:21:47Z<p>Fred: Created page with "Gache électrique pour biométrie # La gâche électrique: #: #: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 prom…"</p>
<hr />
<div>[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : deux résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : Micro-contrôleur</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1601PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T17:00:52Z<p>Fred: /* Solution retenue */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
Voici la liste des solutions envisagées :<br />
* Réutilisation de la solution du projet TouchKey<br />
* Commande via port USB<br />
* Commande via port série<br />
* Utilisation de la sortie son (prise Jack)<br />
<br />
'''Solution retenue'''<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1600PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T17:00:40Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
'''Solutions envisagées'''<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
Voici la liste des solutions envisagées :<br />
* Réutilisation de la solution du projet TouchKey<br />
* Commande via port USB<br />
* Commande via port série<br />
* Utilisation de la sortie son (prise Jack)<br />
<br />
== Solution retenue ==<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1599PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T16:53:18Z<p>Fred: /* Solutions envisagées */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
Solutions envisagées<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
Voici la liste des solutions envisagées :<br />
* Réutilisation de la solution du projet TouchKey<br />
* Commande via port USB<br />
* Commande via port série<br />
* Utilisation de la sortie son (prise Jack)<br />
<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : deux résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : Micro-contrôleur<br />
<br />
== Solution retenue ==<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1598PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T16:52:44Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
<br />
== Gâche électronique: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
== Solutions envisagées ==<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
Voici la liste des solutions envisagées :<br />
* Réutilisation de la solution du projet TouchKey<br />
* Commande via port USB<br />
* Commande via port série<br />
* Utilisation de la sortie son (prise Jack)<br />
<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : deux résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : Micro-contrôleur<br />
<br />
<br />
== Solution retenue ==<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1597PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T16:44:13Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
= Gâche électronique: =<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/]. Cela nous a donné une base de travail et de recherche pour notre réalisation. Nous avons également rencontrés des enseignants de 3I qui ont su nous conseiller et aiguiller vers d'autres solutions.<br />
<br />
<br />
== Solutions envisagées ==<br />
<br />
Dans cette partie, nous allons tout d'abord vous présenter l'ensemble des solutions qui ont été étudiées. Certaines ont pu être réalisées d'autres non, certaines sont abouties, d'autres demandent encore à être explorer d'avantage. La plupart des solutions sont tout de même basées sur le projet TouchKey.<br />
<br />
Voici la liste des solutions envisagées :<br />
* Réutilisation de la solution du projet TouchKey<br />
* Commande via port USB<br />
* Commande via port série<br />
* Utilisation de la sortie son (prise Jack)<br />
<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : deux résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : Micro-contrôleur<br />
<br />
<br />
== Solution retenue ==<br />
<br />
Dans cette partie, nous allons vous présenter la solution retenue. Cette solution utilise le circuit électronique du projet TouchKey - auquel ont été apportées quelques modifications - un Arduino Uno[http://arduino.cc/en/Main/ArduinoBoardUno] (interface de communication et de commande) et la librairie RXTX [http://rxtx.qbang.org] (protocole) entre l'ordinateur et la carte électronique.<br />
<br />
<br />
<br />
----<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1596PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T15:52:58Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système '''d'ouvrir une porte''' simplement par la parole. C'est ici qu'entre en jeu la serrure électronique. Avant de commencer le projet, nous avons étudié une réalisation d'un groupe de l'an dernier à l'origine du projet TouchKey[http://www.touchkey.fr/].<br />
<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : une résistance (220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=Sch%C3%A9ma_%C3%A9lectronique&diff=1595Schéma électronique2011-03-13T12:19:33Z<p>Fred: </p>
<hr />
<div>[[File:Schema.gif]]</div>Fredhttps://air.imag.fr/index.php?title=Sch%C3%A9ma_%C3%A9lectronique&diff=1594Schéma électronique2011-03-13T12:19:21Z<p>Fred: Blanked the page</p>
<hr />
<div></div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1593PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T12:17:39Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : une résistance (220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=File:Schema.gif&diff=1592File:Schema.gif2011-03-13T12:15:42Z<p>Fred: </p>
<hr />
<div></div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1591PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T12:15:20Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : une résistance (220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[File:Schema.gif]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=Sch%C3%A9ma_%C3%A9lectronique&diff=1590Schéma électronique2011-03-13T12:14:26Z<p>Fred: Created page with "File:Schema.gif"</p>
<hr />
<div>[[File:Schema.gif]]</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1589PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-13T12:11:18Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : une résistance (220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1137PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-02-21T14:19:34Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1136PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-02-21T14:12:22Z<p>Fred: /* Gâche électronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet similaire réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1135PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-02-21T14:12:09Z<p>Fred: /* Gâche élétronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet similaire réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
tutorial à faire (allume LED verte/rouge)<br />
[http://processors.wiki.ti.com/images/f/f7/LaunchPadSimpleProject.pdf <br />
]<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=File:Gache.jpg&diff=1134File:Gache.jpg2011-02-21T14:06:08Z<p>Fred: </p>
<hr />
<div></div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1132PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-02-21T14:04:13Z<p>Fred: /* Gâche élétronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche élétronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet similaire réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
tutorial à faire (allume LED verte/rouge)<br />
[http://processors.wiki.ti.com/images/f/f7/LaunchPadSimpleProject.pdf <br />
]<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1130PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-02-21T13:48:31Z<p>Fred: /* Gache élétronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche élétronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet similaire réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:* Référence : CFI/0641 09W40/5821<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Consommation très réduite à 2,4 watts seulement permettant de l'installer sur toutes les installation.<br />
#:* Dimension du corps: 150x40x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 12VDC avec une tolérance importante de 20% soit entre 9.6 volts et 14,4 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 20 degrée centigrade à + 70 degrée centigrade<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
<br />
tutorial à faire (allume LED verte/rouge)<br />
[http://processors.wiki.ti.com/images/f/f7/LaunchPadSimpleProject.pdf <br />
]<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1128PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-02-21T13:35:18Z<p>Fred: /* Gache élétronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gache élétronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gache electronique.<br />
<br />
tutorial à faire (allume LED verte/rouge)<br />
[http://processors.wiki.ti.com/images/f/f7/LaunchPadSimpleProject.pdf <br />
]<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1127PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-02-21T13:23:46Z<p>Fred: /* Interface Graphique */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gache élétronique: ==<br />
<br />
tutorial à faire (allume LED verte/rouge)<br />
[http://processors.wiki.ti.com/images/f/f7/LaunchPadSimpleProject.pdf <br />
]<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1126PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-02-21T13:23:33Z<p>Fred: /* Interface Graphique */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gache élétronique: ==<br />
<br />
tutorial à faire (allume LED verte/rouge)<br />
[http://processors.wiki.ti.com/images/f/f7/LaunchPadSimpleProject.pdf <br />
]<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Fredhttps://air.imag.fr/index.php?title=Projet_%22Biom%C3%A9trie%22&diff=1125Projet "Biométrie"2011-02-21T13:23:13Z<p>Fred: /* Avancement du projet */</p>
<hr />
<div>* Enseignant: Laurent Besacier<br />
* UE/Module: Biométrie en RICM5 option CM<br />
<br />
'''<br />
Chaque groupe doit me rendre le compte rendu sous forme de pages Wiki !!!'''<br />
<br />
=Introduction=<br />
<br />
Ce mini-projet porte sur la biométrie. Il se fait en 2 demi-promos d’option Multimedia (à vous de vous répartir en 2 demi-promos-multimédia de taille équivalente). Ces deux projets consistent à faire l’acquisition de modalités biométriques (voix ou signatures), et à appliquer des algorithmes « état de l’art » du domaine (reconnaissance de signatures ou reconnaissance du locuteur) sur ces modalités acquises.<br />
<br />
---------------------<br />
=Mini-projet 1 : Serrure vocale (10 personnes)=<br />
<br />
[[PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE]] <br />
<br />
Décomposition de l’équipe :<br />
<br />
a-Chef de projet (1 ou 2 personnes)<br />
<br />
b-Analyses / Mise en place d’algorithmes de reconnaissance du locuteur (3 personnes, plutôt soft) : voir http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/ <br />
Ces algos tournerons sur un PC pour l’instant. Le PC renverra une réponse du type acceptation / rejet et il faudra réaliser l’interfaçage avec la [http://www.sparkfun.com/tutorial/AIK/ARDX-EG-SPAR-PRINT-85.pdf#page=30 gâche électrique WECA].<br />
<br />
c- Interfaçage avec la gâche électrique (3 personnes, un peu à l’aise en électronique) voir le montage [http://ardx.org/CIRC11/ CIRC11] [http://www.sparkfun.com/tutorial/AIK/ARDX-EG-SPAR-PRINT-85.pdf#page=30 plus...]<br />
<br />
d- Organisation de l’acquisition des échantillons de parole, interface (3 personnes, polyvalentes)<br />
<br />
==== Avancement du projet ====<br />
<br />
---------------------------<br />
<u>Problèmatique</u><br />
<br />
Dans le cadre de la gache électrique à commande vocale, dans un premier temps, le système ne sera pas autonome.<br />
De fait, c'est l'ordinateur qui s'interface avec la gache électrique afin de la controler.<br />
<br />
Dans cette optique, l'acquisition et la comparaison sonore se fait sur ordinateur. L'ordinateur se charge ensuite d'envoyer un signal binaire <br />
de type "ouverture"/"non ouverture". Afin de réaliser ces étapes, nous créons une interface graphique détaillée ci-après.<br />
<br />
<u>Liens de documentation</u><br />
<br />
[[Utilistation du SVN]]<br />
<br />
=Mini projet 2 : Acquisition et reconnaissance de signatures (10 personnes)=<br />
<br />
[[PAGE WIKI ETUDIANTS 2010-11 SIGNATURES]] <br />
<br />
a-Chef de projet (1 ou 2 personnes)<br />
<br />
b-Recherche technologique sur les algorithmes de reconnaissance de signatures (3 personnes, plutôt soft) : <br />
Ces algos tournerons sur un PC pour l’instant. Le PC renverra une réponse du type acceptation / rejet et il faudra réaliser l’acquisition de signatures sur les « touch screen » (écrans de Nintendo DS).<br />
<br />
c- Acquisition de signatures sur les « touch screen (3 personnes, un peu à l’aise en électronique)<br />
<br />
d- Organisation de l’acquisition des échantillons de signature, interface (3 personnes, polyvalentes)<br />
<br />
Aide : voir http://kalshagar.wikispaces.com/Arduino+and+a+Nintendo+DS+touch+screen <br />
http://www.sparkfun.com/commerce/tutorial_info.php?tutorials_id=139<br />
http://www.sparkfun.com/datasheets/LCD/HOW%20DOES%20IT%20WORK.pdf <br />
<br />
voir aussi<br />
http://www.youtube.com/watch?v=1cfQT7WioxI <br />
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1232390262 <br />
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1243499684<br />
<br />
Aide : telecharger et installer l’application « arduino » sur http://arduino.cc/en/Main/Software (version Windows ou Linux, au choix)<br />
Récuperez le fichier DSTouch.pde<br />
Pour le branchement suivre les indications dans le code ;<br />
<br />
// Touch panel wiring<br />
// Connect to Arduino these wires (used to drive power)<br />
#define Lo 2 // LEFT to digital output 2 (X1)<br />
#define Bo 3 // BOTTOM to digital output 3 (Y2)<br />
#define Ro 4 // RIGHT to digital output 4 (X2)<br />
#define To 5 // TOP to Digital output 5 (Y1)<br />
<br />
// Connect to Arduino these wires (used to read the touch position)<br />
#define Ti 3 // TOP also to analog input 3 (Y1)<br />
#define Ri 4 // RIGHT also to analog input 4 (X2)<br />
<br />
Lancer l’ampli + charger l’appli DSTouch<br />
=> On récupère les coordonnées via la liaison serie<br />
* soit depuis une application [http://processing.org/ Processing]<br />
* soit depuis une application (comme [http://websvn.ow2.org/filedetails.php?repname=aspire&path=%2Ftrunk%2Fbundles%2Fcommon%2Frxtx.cmd%2Fsrc%2Fmain%2Fjava%2Forg%2Fow2%2Faspirerfid%2Frxtx%2Fcmd%2Fconsole%2FSerialConsole.java SerialConsole] que vous pourrez modifier) utilisant l'API [http://rxtx.qbang.org/wiki/index.php/Main_Page RXTX]</div>Fredhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1124PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-02-21T13:22:00Z<p>Fred: /* Gache élétronique: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gache élétronique: ==<br />
<br />
tutorial à faire (allume LED verte/rouge)<br />
[http://processors.wiki.ti.com/images/f/f7/LaunchPadSimpleProject.pdf <br />
]<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==</div>Fredhttps://air.imag.fr/index.php?title=Projet_%22Biom%C3%A9trie%22&diff=1123Projet "Biométrie"2011-02-21T13:21:16Z<p>Fred: /* Avancement du projet */</p>
<hr />
<div>* Enseignant: Laurent Besacier<br />
* UE/Module: Biométrie en RICM5 option CM<br />
<br />
'''<br />
Chaque groupe doit me rendre le compte rendu sous forme de pages Wiki !!!'''<br />
<br />
=Introduction=<br />
<br />
Ce mini-projet porte sur la biométrie. Il se fait en 2 demi-promos d’option Multimedia (à vous de vous répartir en 2 demi-promos-multimédia de taille équivalente). Ces deux projets consistent à faire l’acquisition de modalités biométriques (voix ou signatures), et à appliquer des algorithmes « état de l’art » du domaine (reconnaissance de signatures ou reconnaissance du locuteur) sur ces modalités acquises.<br />
<br />
---------------------<br />
=Mini-projet 1 : Serrure vocale (10 personnes)=<br />
<br />
[[PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE]] <br />
<br />
Décomposition de l’équipe :<br />
<br />
a-Chef de projet (1 ou 2 personnes)<br />
<br />
b-Analyses / Mise en place d’algorithmes de reconnaissance du locuteur (3 personnes, plutôt soft) : voir http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/ <br />
Ces algos tournerons sur un PC pour l’instant. Le PC renverra une réponse du type acceptation / rejet et il faudra réaliser l’interfaçage avec la [http://www.sparkfun.com/tutorial/AIK/ARDX-EG-SPAR-PRINT-85.pdf#page=30 gâche électrique WECA].<br />
<br />
c- Interfaçage avec la gâche électrique (3 personnes, un peu à l’aise en électronique) voir le montage [http://ardx.org/CIRC11/ CIRC11] [http://www.sparkfun.com/tutorial/AIK/ARDX-EG-SPAR-PRINT-85.pdf#page=30 plus...]<br />
<br />
d- Organisation de l’acquisition des échantillons de parole, interface (3 personnes, polyvalentes)<br />
<br />
==== Avancement du projet ====<br />
<br />
---------------------------<br />
<u>Problèmatique</u><br />
<br />
Dans le cadre de la gache électrique à commande vocale, dans un premier temps, le système ne sera pas autonome.<br />
De fait, c'est l'ordinateur qui s'interface avec la gache électrique afin de la controler.<br />
<br />
Dans cette optique, l'acquisition et la comparaison sonore se fait sur ordinateur. L'ordinateur se charge ensuite d'envoyer un signal binaire <br />
de type "ouverture"/"non ouverture". Afin de réaliser ces étapes, nous créons une interface graphique détaillée ci-après.<br />
<br />
<u>Liens de documentation</u><br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM<br />
<br />
[[Utilistation du SVN]]<br />
<br />
=Mini projet 2 : Acquisition et reconnaissance de signatures (10 personnes)=<br />
<br />
[[PAGE WIKI ETUDIANTS 2010-11 SIGNATURES]] <br />
<br />
a-Chef de projet (1 ou 2 personnes)<br />
<br />
b-Recherche technologique sur les algorithmes de reconnaissance de signatures (3 personnes, plutôt soft) : <br />
Ces algos tournerons sur un PC pour l’instant. Le PC renverra une réponse du type acceptation / rejet et il faudra réaliser l’acquisition de signatures sur les « touch screen » (écrans de Nintendo DS).<br />
<br />
c- Acquisition de signatures sur les « touch screen (3 personnes, un peu à l’aise en électronique)<br />
<br />
d- Organisation de l’acquisition des échantillons de signature, interface (3 personnes, polyvalentes)<br />
<br />
Aide : voir http://kalshagar.wikispaces.com/Arduino+and+a+Nintendo+DS+touch+screen <br />
http://www.sparkfun.com/commerce/tutorial_info.php?tutorials_id=139<br />
http://www.sparkfun.com/datasheets/LCD/HOW%20DOES%20IT%20WORK.pdf <br />
<br />
voir aussi<br />
http://www.youtube.com/watch?v=1cfQT7WioxI <br />
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1232390262 <br />
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1243499684<br />
<br />
Aide : telecharger et installer l’application « arduino » sur http://arduino.cc/en/Main/Software (version Windows ou Linux, au choix)<br />
Récuperez le fichier DSTouch.pde<br />
Pour le branchement suivre les indications dans le code ;<br />
<br />
// Touch panel wiring<br />
// Connect to Arduino these wires (used to drive power)<br />
#define Lo 2 // LEFT to digital output 2 (X1)<br />
#define Bo 3 // BOTTOM to digital output 3 (Y2)<br />
#define Ro 4 // RIGHT to digital output 4 (X2)<br />
#define To 5 // TOP to Digital output 5 (Y1)<br />
<br />
// Connect to Arduino these wires (used to read the touch position)<br />
#define Ti 3 // TOP also to analog input 3 (Y1)<br />
#define Ri 4 // RIGHT also to analog input 4 (X2)<br />
<br />
Lancer l’ampli + charger l’appli DSTouch<br />
=> On récupère les coordonnées via la liaison serie<br />
* soit depuis une application [http://processing.org/ Processing]<br />
* soit depuis une application (comme [http://websvn.ow2.org/filedetails.php?repname=aspire&path=%2Ftrunk%2Fbundles%2Fcommon%2Frxtx.cmd%2Fsrc%2Fmain%2Fjava%2Forg%2Fow2%2Faspirerfid%2Frxtx%2Fcmd%2Fconsole%2FSerialConsole.java SerialConsole] que vous pourrez modifier) utilisant l'API [http://rxtx.qbang.org/wiki/index.php/Main_Page RXTX]</div>Fredhttps://air.imag.fr/index.php?title=Gachette_electrique&diff=1122Gachette electrique2011-02-21T13:19:41Z<p>Fred: Created page with "== Fonctionnalité de la gachette == *Réglage du seuil de tolérance de comparaison *Bouton de lancement de test *Acquisition / Execution des fichiers sonores : externe via un…"</p>
<hr />
<div>== Fonctionnalité de la gachette ==<br />
<br />
<br />
*Réglage du seuil de tolérance de comparaison<br />
*Bouton de lancement de test<br />
*Acquisition / Execution des fichiers sonores : externe via un logiciel dédiée dans un premier temps pour faciliter le développement<br />
<br />
<br />
==== Extensions ====<br />
*Enregistrement des fichiers sonores directement dans l'application<br />
*2 modes<br />
*Gestionnaire de modèles de voix (Ajout/Modification/Suppression de modèle) dans l'application<br />
<br />
<br />
==== Limitations ====</div>Fredhttps://air.imag.fr/index.php?title=Projet_%22Biom%C3%A9trie%22&diff=1121Projet "Biométrie"2011-02-21T13:10:32Z<p>Fred: /* Avancement du projet */</p>
<hr />
<div>* Enseignant: Laurent Besacier<br />
* UE/Module: Biométrie en RICM5 option CM<br />
<br />
'''<br />
Chaque groupe doit me rendre le compte rendu sous forme de pages Wiki !!!'''<br />
<br />
=Introduction=<br />
<br />
Ce mini-projet porte sur la biométrie. Il se fait en 2 demi-promos d’option Multimedia (à vous de vous répartir en 2 demi-promos-multimédia de taille équivalente). Ces deux projets consistent à faire l’acquisition de modalités biométriques (voix ou signatures), et à appliquer des algorithmes « état de l’art » du domaine (reconnaissance de signatures ou reconnaissance du locuteur) sur ces modalités acquises.<br />
<br />
---------------------<br />
=Mini-projet 1 : Serrure vocale (10 personnes)=<br />
<br />
[[PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE]] <br />
<br />
Décomposition de l’équipe :<br />
<br />
a-Chef de projet (1 ou 2 personnes)<br />
<br />
b-Analyses / Mise en place d’algorithmes de reconnaissance du locuteur (3 personnes, plutôt soft) : voir http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/ <br />
Ces algos tournerons sur un PC pour l’instant. Le PC renverra une réponse du type acceptation / rejet et il faudra réaliser l’interfaçage avec la [http://www.sparkfun.com/tutorial/AIK/ARDX-EG-SPAR-PRINT-85.pdf#page=30 gâche électrique WECA].<br />
<br />
c- Interfaçage avec la gâche électrique (3 personnes, un peu à l’aise en électronique) voir le montage [http://ardx.org/CIRC11/ CIRC11] [http://www.sparkfun.com/tutorial/AIK/ARDX-EG-SPAR-PRINT-85.pdf#page=30 plus...]<br />
<br />
d- Organisation de l’acquisition des échantillons de parole, interface (3 personnes, polyvalentes)<br />
<br />
==== Avancement du projet ====<br />
<br />
---------------------------<br />
<u>Problèmatique</u><br />
<br />
Dans le cadre de la gache électrique à commande vocale, dans un premier temps, le système ne sera pas autonome.<br />
De fait, c'est l'ordinateur qui s'interface avec la gache électrique afin de la controler.<br />
<br />
Dans cette optique, l'acquisition et la comparaison sonore se fait sur ordinateur. L'ordinateur se charge ensuite d'envoyer un signal binaire <br />
de type "ouverture"/"non ouverture". Afin de réaliser ces étapes, nous créons une interface graphique détaillée ci-après.<br />
<br />
<u>Liens de documentation</u><br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage <br />
<br />
[[Utilistation du SVN]]<br />
<br />
=Mini projet 2 : Acquisition et reconnaissance de signatures (10 personnes)=<br />
<br />
[[PAGE WIKI ETUDIANTS 2010-11 SIGNATURES]] <br />
<br />
a-Chef de projet (1 ou 2 personnes)<br />
<br />
b-Recherche technologique sur les algorithmes de reconnaissance de signatures (3 personnes, plutôt soft) : <br />
Ces algos tournerons sur un PC pour l’instant. Le PC renverra une réponse du type acceptation / rejet et il faudra réaliser l’acquisition de signatures sur les « touch screen » (écrans de Nintendo DS).<br />
<br />
c- Acquisition de signatures sur les « touch screen (3 personnes, un peu à l’aise en électronique)<br />
<br />
d- Organisation de l’acquisition des échantillons de signature, interface (3 personnes, polyvalentes)<br />
<br />
Aide : voir http://kalshagar.wikispaces.com/Arduino+and+a+Nintendo+DS+touch+screen <br />
http://www.sparkfun.com/commerce/tutorial_info.php?tutorials_id=139<br />
http://www.sparkfun.com/datasheets/LCD/HOW%20DOES%20IT%20WORK.pdf <br />
<br />
voir aussi<br />
http://www.youtube.com/watch?v=1cfQT7WioxI <br />
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1232390262 <br />
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1243499684<br />
<br />
Aide : telecharger et installer l’application « arduino » sur http://arduino.cc/en/Main/Software (version Windows ou Linux, au choix)<br />
Récuperez le fichier DSTouch.pde<br />
Pour le branchement suivre les indications dans le code ;<br />
<br />
// Touch panel wiring<br />
// Connect to Arduino these wires (used to drive power)<br />
#define Lo 2 // LEFT to digital output 2 (X1)<br />
#define Bo 3 // BOTTOM to digital output 3 (Y2)<br />
#define Ro 4 // RIGHT to digital output 4 (X2)<br />
#define To 5 // TOP to Digital output 5 (Y1)<br />
<br />
// Connect to Arduino these wires (used to read the touch position)<br />
#define Ti 3 // TOP also to analog input 3 (Y1)<br />
#define Ri 4 // RIGHT also to analog input 4 (X2)<br />
<br />
Lancer l’ampli + charger l’appli DSTouch<br />
=> On récupère les coordonnées via la liaison serie<br />
* soit depuis une application [http://processing.org/ Processing]<br />
* soit depuis une application (comme [http://websvn.ow2.org/filedetails.php?repname=aspire&path=%2Ftrunk%2Fbundles%2Fcommon%2Frxtx.cmd%2Fsrc%2Fmain%2Fjava%2Forg%2Fow2%2Faspirerfid%2Frxtx%2Fcmd%2Fconsole%2FSerialConsole.java SerialConsole] que vous pourrez modifier) utilisant l'API [http://rxtx.qbang.org/wiki/index.php/Main_Page RXTX]</div>Fred