1

I) Le principe de la reconnaissance vocale :

1) Présentation générale : La reconnaissance vocale (aussi appelée reconnaissance automatique de la parole) consiste à enregistrer un signal vocal pour le transcrire sous une forme que la machine pourra exploiter. On retrouve plusieurs techniques de traitement de la parole telles que la synthèse de la parole, l’identification du locuteur ou la vérification du locuteur. A l’aide de ces techniques, on peut réaliser des interfaces homme-machine (IHM), une partie de l’interaction se fait donc à l’aide de la voix. De nombreuses applications existent déjà telles que la dictée vocale sur PC ou encore les serveurs vocaux.

2) Les dates clefs : 1952 : reconnaissance des 10 chiffres par un dispositif électronique câblé. 1960 : utilisation des méthodes numériques. 1965 : reconnaissance de phonèmes en parole continue. 1968 : reconnaissance de mots isolés par des systèmes implantés sur gros ordinateurs (jusqu’à 500 mots). 1971 : lancement du projet ARPA aux USA (15 millions de dollars = 11 237 999 euros) pour tester la faisabilité de la compréhension automatique de la parole continue avec des contraintes raisonnables. 1972 : premier appareil commercialisé de reconnaissance de mots. 1978 : commercialisation d'un système de reconnaissance à microprocesseurs sur une carte de circuits imprimés. 1983 : première mondiale de commande vocale à bord d'un avion de chasse en France. 1985 : commercialisation des premiers systèmes de reconnaissance de plusieurs milliers de mots. 1986 : lancement du projet japonais ATR de téléphone avec traduction automatique en temps réel.

2

3) Principe de fonctionnement : Un micro va transformer le son de la parole en signal électrique. Ce signal sera ensuite transmis à un analyseur qui va le convertir en signal numérique. Une fois le signal numérisé, celui-ci sera traité afin d’extraire certaines caractéristiques nécessaires pour que le mot soit reconnu. Ces caractéristiques sont ensuite comparées à celles contenu dans un dictionnaire qui contient des mots préalablement enregistrés.

4) Les détails de fonctionnement : Une phrase est enregistrée puis numérisée, elle sera envoyée au RAP (reconnaissance automatique de la parole). Voici le découpage des différentes fonctions du RAP : Le traitement acoustique va extraire une image acoustique compacte du signal vocal, celle-ci sera sous forme de vecteurs acoustiques. Ceux-ci correspondent à des tranches de 20 à 30ms de signal avec un pas de 10ms. Le signal sera ensuite numérisé et paramétré à l’aide d’une technique d’analyse fréquentielle qui utilise la transformée de Fourier. L’apprentissage automatique va associer les segments élémentaires de la parole avec les éléments lexicaux. Cette association fera appel à une modélisation statistique. Le décodage va reconstituer le discours le plus probable grâce à une concaténation des modèles élémentaires vu précédemment, on appelle cela : une correspondance de motif temporelle.

Une étape de mémorisation de mots peut être ajoutée. Le mot sera donc ajouté au dictionnaire.

3

II) Les systèmes déjà existant dans le domaine « handicap-mobilité » :

1) Le fauteuil roulant wi-fi :

Voici un prototype de fauteuil roulant élaboré par les chercheurs du MIT. Celui-ci se déplace jusqu’à l’endroit que l’on lui indique et ce, sans intervention extérieure. Il fonctionne grâce à un système de bornes de communication sans-fil. L’utilisateur indique une destination au fauteuil qui va alors l’y conduire. Le système fonctionne grâce à des signaux wi-fi, des caméras à angle large et des télémètres laser. Ce matériel est relié à un système informatique qui va retranscrire les éléments qui entourent le fauteuil afin qu’il puisse se repérer. Les chercheurs du MIT n’ont pas utilisé les signaux GPS pour leur fauteuil car ceux-ci fonctionnement difficilement en intérieur ce qui était problématique. Afin de mémoriser un endroit, il faut que l’utilisateur indique au système où il se trouve. Par exemple, si un utilisateur dit « ceci est ma chambre », la position sera alors mémorisée et le fauteuil sera capable d’y retourner grâce à la commande vocale. On peut noter que le logiciel de reconnaissance vocale s’adapte aux expressions et aux intonations de la personne qui l’utilise car les gens utilisent parfois des expressions spécifiques pour désigner un lieu ou un objet. Il est prévu que le fauteuil intègre un système qui détectera les obstacles afin d’éviter des collisions avec des personnes, des animaux etc.. Une autre avancée prévue est l’implémentation d’un bras mécanique qui aidera les personnes à manipuler des objets comme un verre ou encore à réaliser des actions comme éteindre la lumière.

Ce fauteuil est un prototype, il n’est pas encore finalisé, cependant certains tests ont été réalisé comme à l’hôpital de Boston. Ceux-ci se révélèrent assez concluant même si certaines choses sont encore à perfectionner comme la mise en place de la détection d’obstacle.

4

III) Etude du matériel à disposition:

Les déplacements du fauteuil se font grâce à des moteurs, pour commander le fauteuil, nous nous sommes penchés sur la motorisation de celui-ci. Nous avons donc remarqué qu’il y avait deux moteurs, situés aux niveaux des roues arrière du fauteuil. On trouve des moteurs différents selon les modèles de fauteuil, voici quelques références de moteur :

1) Etude du module SmartVR : Le module smart VR est constitué de deux cartes, une partie gère la reconnaissance vocale et l'autre est une carte de développement contenant de nombreux composants, Voici la partie reconnaissance vocale :

Voici la partie carte de développement :

Sur cette partie carte de développement nous retrouvons des boutons poussoirs qui peuvent être utilisés en entrée, en fonction de l'appuie ou non sur l'un des boutons, on peut faire basculer des sorties par exemple. Un bouton poussoir est aussi utilisé pour le reset de la carte. On peut aussi observer la présence d'un micro externe servant pour la reconnaissance vocale, d'une prise jack afin de brancher des écouteurs pour avoir un retour audio lorsque l'on émet un son avec la carte. Différents cavaliers servent à sélectionner le mode d'alimentation de cette carte, on peut avoir une alimentation via des piles, par USB ou par une alimentation externe. Enfin c'est sur l'emplacement entouré en rouge que l'on vient insérer le module de reconnaissance vocale.

5

Nous allons voir plus en détail le module de reconnaissance vocale, voici un schéma représentant ce module :

Récapitulatif des entrées/sorties: Pin No. Pin name Type Description 1L VDD P DC input voltage 2L GND P Ground 3L /RST - Asynchronous reset 4L PLED O Power LED indicator 5L VLED O Voice LED indicator 6L GPIO16 I/O General purpose input/output pin 16 7L GPIO15 I/O General purpose input/output pin 15 8L GPIO14 I/O General purpose input/output pin 14 9L GPIO13 I/O General purpose input/output pin 13 10L GPIO12 I/O General purpose input/output pin 12 11L GPIO11 I/O General purpose input/output pin 11 12L GPIO10 I/O General purpose input/output pin 10 13L GPIO09 I/O General purpose input/output pin 09 14L GPIO08 I/O General purpose input/output pin 08 15L GPIO07 I/O General purpose input/output pin 07 16L GPIO06 I/O General purpose input/output pin 06 17L GPIO05 I/O General purpose input/output pin 05 18L GPIO04 I/O General purpose input/output pin 04 19L GPIO03 I/O General purpose input/output pin 03 20L GPIO02 I/O General purpose input/output pin 02 21L GPIO01 I/O General purpose input/output pin 01

6

22L DBG I/O Debug/diagnostic output 23L TX O Serial port transmit 24L RX I Serial port receive 25L PDN O Power down indicator 26L /XM I Boot mode selector 27L PWM0 O Speaker output 28L PWM1 O Speaker output 1R MICRET P Microphone signal reference 2R MICIN I Microphone input signal 3R MICPWR P Microphone power (for on-board gain resistor) 4R MICVDD P Microphone power (for custom gain resistor) 5R DACOUT O DAC audio output (line level) 6R FCK O External SPI fast clock 7R /RDF O Memory bus read strobe 8R /WRD O Memory bus write strobe 9R /EN1 O Memory device enable 1 10R EN2 O Memory device enable 2 11R SPISW O External SPI clock switch 12R /CS1 O SPI bus chip select 1 13R /CS2 O SPI bus chip select 2 14R /CS3 O SPI bus chip select 3 15R /CS4 O SPI bus chip select 4 16R /CS5 O SPI bus chip select 5 17R DQ0 I/O Memory bus data line 18R DQ1 I/O Memory bus data line 19R DQ2 I/O Memory bus data line 20R DQ3 I/O Memory bus data line 21R DQ4 I/O Memory bus data line 22R DQ5 I/O Memory bus data line 23R DQ6 I/O Memory bus data line 24R DQ7 I/O Memory bus data line 25R SDA I/O I2C bus data line 26R MISO I SPI bus data line 27R MOSI O SPI bus data line 28R SCK/SCL O SPI bus clock / I2C bus clock

Pour la partie programmation du module de reconnaissance vocale, nous n’avons utilisé que les GPIO que nous avons configurés en sortie.

7

2) Le driver de moteur :

Afin de contrôler les moteurs de notre fauteuil roulant, nous avons dû utiliser un driver de moteur. Ce composant sert à faire tourner les moteurs, dans un sens ou dans un autre en fonction de l'information qu'il reçoit en entrée. Voici une photo du driver utilisé, c'est un Sabertooth2x25 :

Voici deux photos afin de pouvoir mieux observer les entrées et les sorties du driver :

On remarque la présence des sorties M1A et M1B ainsi que M2A et M2A, c'est là que seront connectés les moteurs du fauteuil. Les batteries du fauteuil seront reliées aux entrées B+ et B-.

Sur cette photo, nous pouvons observer la présence d'une sortie 5V ainsi que des entrées S1 et S2. C'est grâce à ces entrées que nous contrôleront les moteurs. La sortie 5V sert pour le mode potentiomètre, mais elle peut être bien pratique si l'on souhaite alimenter une autre carte par exemple.

8

Le driver de moteur possède différents modes, on peut choisir le mode désiré grâce à des switchs présent sur celui-ci :

Nous avons utilisé ces deux modes : -"Signal Input Terminals S1 and S2" : Ce mode nous a permis de vérifier le bon fonctionnement des moteurs, nous avons donc relié deux potentiomètres aux entrées S1 et S2, en fonction de la valeur de ceux-ci, la valeur de tension variait, les moteurs tournaient donc dans un sens, dans l'autre ou s'arrêtaient. Voici une image du montage :

Nous pouvons remarquer qu'il y a seulement un potentiomètre, celui-ci commandera donc les deux moteurs de ma même manière. -Mode "Simplified serial" : C'est ce mode qui est utilisé pour commander notre fauteuil. L'entrée S1 du driver de moteur est reliée au TX du PIC. La communication se fait donc par liaison série. En fonction de la valeur envoyée, l'un ou l'autre des moteurs sera commandé à une certaine vitesse et dans un certain sens. Voici un tableau avec les valeurs « max » et les valeurs qui permettent de stopper les moteurs :

Moteur 1 Moteur 2

A fond en marche avant 127 255

A fond en marche arrière 1 128

Stop 64 192

La vitesse de transmission de ce mode est de 38400.

9

Explication générale du projet :

Comme vous pouvez le voir sur le schéma ci-dessus, les sorties de la carte de reconnaissance vocale sont reliées aux entrées d'un PIC, en fonction du mot prononcé, certaines sorties vont basculer et l'état de certaines entrées du PIC va donc changer. Le PIC va ensuite commander l'envoi d'une information(sous forme d'une valeur binaire) qui va être reçue par le driver de moteur (Sabertooth), celui-ci va ensuite commander l'un ou l'autre des moteurs en fonction de la valeur envoyée par liaison série. Les moteurs quant à eux sont alimentés par deux batteries 12V couplées en parallèle.

10

IV) Travail réalisé :

1) Reconnaissance vocale : Tout d'abord, nous avons réalisé des tests afin d'allumer des LEDs ce qui nous a permis de nous familiariser avec différentes fonctions de la programmation vocale. Pour ce faire, nous avions à notre disposition des exemples de programmes, cependant beaucoup de fonctions ne nous intéressaient pas et nous avons donc dû analyser la structure du programme. Après ce travail de recherche, nous avons pu réaliser ce programme: void main(void) { int a=1; uchar error; uchar class; _SetOutput(COMMAND_PIN_ALL,1); _SysBeep (250); _GreenOn(); _RedOff(); error = _T2SI((long)&nn_sample, (long)&gsearch_trig_sample, T2SI_DEFAULT_KNOB , T2SI_DEFAULT_TIMEOUT, T2SI_DEFAULT_TRAILING, &results); _GreenOff();// definition « signal d’erreur » if(error == ERR_OK) // test des erreurs de reconnaissance { _SysBeep (20); _RedOn(); error = _T2SI((long)&nn_sample, (long)&gsearch_comm_sample, T2SI_DEFAULT_KNOB

, T2SI_DEFAULT_TIMEOUT, T2SI_DEFAULT_TRAILING, &results);

class = results.pp_b; _RedOff();

if ((class == G_comm_sample_nota) || (error == ERR_RECOG_LOW_CONF)) //Si reconnaissance mal effectuée

{ _RedOn(); _DelayMilliSecs(500); _RedOff(); } else

11

if ((error == ERR_OK) || (error == ERR_RECOG_MID_CONF))//Si reconnaissance sans erreurs { while(1) { error = _T2SI((long)&nn_sample, (long)&gsearch_comm_sample, T2SI_DEFAULT_KNOB , T2SI_DEFAULT_TIMEOUT, T2SI_DEFAULT_TRAILING, &results); class = results.pp_b; if ((class == G_comm_sample_nota) || (error == ERR_RECOG_LOW_CONF))// Si reconnaissance mal effectuée { _RedOn(); _HighPin(0xFF00); _DelayMilliSecs(500); _LowPin(0xFF00); _RedOff(); } Else // sinon on test le mot et on met une sortie à 1 { if(class==G_comm_sample_ERASE) {_HighPin(0x1000);} } } Explication du programme : Lorsque l'on prononce un mot, celui-ci est donc analysé par la carte, si cette donnée ne comporte pas d'erreur et que le mot et reconnu alors, on réalise la fonction qui est à l'intérieur du "if", dans notre cas c'est activer une sortie de la carte. Le programme précédent a ensuite été modifié afin de correspondre à l'application du fauteuil roulant: #include <techlib.h> #include "demo_io.h" #include "recog\comm_rscApp_sample.h" #include "recog\trig_rscApp_sample.h" #include "audio\TEST.H" #define COMMAND_PIN(x) #define COMMAND_PIN_ALL GPIO_SPAN(1,16) PARAMETERPASS results;

12

void main(void) { int a=1; uchar error; uchar class; _SetOutput(COMMAND_PIN_ALL,1); _SysBeep (250); _GreenOn(); _RedOff(); error = _T2SI((long)&nn_sample, (long)&gsearch_trig_sample, T2SI_DEFAULT_KNOB , T2SI_DEFAULT_TIMEOUT, T2SI_DEFAULT_TRAILING, &results); _GreenOff(); if(error == ERR_OK) { _SysBeep (20); _RedOn(); error = _T2SI((long)&nn_sample, (long)&gsearch_comm_sample, T2SI_DEFAULT_KNOB , T2SI_DEFAULT_TIMEOUT, T2SI_DEFAULT_TRAILING, &results); class = results.pp_b; _RedOff(); if ((class == G_comm_sample_nota) || (error == ERR_RECOG_LOW_CONF)) { _RedOn(); _DelayMilliSecs(500); _RedOff(); } else if ((error == ERR_OK) || (error == ERR_RECOG_MID_CONF)) { while(1) { error = _T2SI((long)&nn_sample, (long)&gsearch_comm_sample, T2SI_DEFAULT_KNOB , T2SI_DEFAULT_TIMEOUT, T2SI_DEFAULT_TRAILING, &results); class = results.pp_b; if ((class == G_comm_sample_nota) || (error == ERR_RECOG_LOW_CONF)) { _RedOn(); _HighPin(0xFF00); _DelayMilliSecs(500); _LowPin(0xFF00); _RedOff();

13

} else { if(class==G_comm_sample_ERASE) {_LowPin(0xFFFF); _HighPin(0x0001);} if(class==G_comm_sample_RECORD) {//_PlaySnd(SND_gauche, (long)&SNDTB_TEST, 256); _LowPin(0xFFFF); _HighPin(0x0002);} if(class==G_comm_sample_PASSWORD) {_LowPin(0xFFFF); _HighPin(0x0004);} if(class==G_comm_sample_CALL) {_LowPin(0xFFFF); _HighPin(0x0008);} if(class==G_comm_sample_PLAY) { _LowPin(0xFFFF); _HighPin(0x0010); _LowPin(0xFFFF);} if(class==G_comm_sample_MODIFY) { _LowPin(0xFFFF); _HighPin(0x0020); _LowPin(0xFFFF);} } } }}} Explication du programme : Ce programme reprend le même principe que ce que l'on a pu voir un peu plus haut, sauf que les lignes de codes présentes dans les "if" ont pour rôle de désactiver toutes les sorties de la carte, puis d'activer celle que l'on désire. Les sorties de la carte sont reliées aux entrées d'un PIC. Lorsque l'on prononce un mot correspondant au déplacement à gauche, une sortie de la carte va basculer, celle-ci va faire basculer une entrée du PIC et en fonction de ce basculement, nous commandons l'envoie d'une information au driver de moteur qui va ensuite commander l’activation d'un moteur, de l'autre ou encore des deux. La mise à l'état bas de toutes les sorties était donc obligatoire car sinon on envoyait deux informations différentes au driver de moteur qui ne savait pas ce qu'il devait faire. On peut noter que les quatre premières lignes de code (les #include) servent à inclure les fichiers vocaux nécessaires à la reconnaissance vocale. #define COMMAND_PIN(x)

14

#define COMMAND_PIN_ALL GPIO_SPAN(1,16) Ces deux lignes servent à définir les pins que l’on utilise dans le programme ainsi que leurs fonctions (ici les pins 1 à 16 sont utilisées en entrée-sortie). Test du Sabertooth2x25 : Après ce travail de programmation, nous nous sommes attelés à l'utilisation du driver de moteur, tout d'abord, nous l'avons utilisé en mode potentiomètre afin de prendre en main ce composant, les tests se sont avérés concluant. Nous avions donc dans l'optique de remplacer les potentiomètres et de contrôler le fauteuil directement à l'aide d'une tension externe. Cependant nous nous sommes rendu compte que c'était impossible. En effet, lorsque nous sélectionnons le mode potentiomètre, nous avons remarqué que l'entrée S1 est reliée en interne au +5V du Sabertooth, il est donc impossible d'appliquer une tension. Nous nous sommes donc dirigés vers le mode liaison série. Tout d'abord, nous avons envoyé des valeurs via l'hyperterminal de l'ordinateur afin d'activer l'un ou l'autre des moteurs. Nous avons donc utilisé Tiny Bootloader pour envoyer nos valeurs :

Quelques problèmes sont apparu lors de ces tests, en effet, les moteurs ne répondaient pas comme ils devaient le faire, ils avançaient dans un sens puis dans l'autre alors qu'on leur demandait d'avancer à fond en avant. Nous nous sommes donc rendu compte que les valeurs du TX étaient en Char alors qu'il fallait qu'elles soient en Mix2 (ce type de langage permet d'envoyer des entiers).

2) Programmation du PIC 16F877 : Après avoir validé le fonctionnement des deux parties précédentes, nous nous sommes demandés comment faire le lien entre le basculement des sorties de la carte de reconnaissance vocale et le driver de moteur, nous avons donc décidé d'utiliser un PIC 16F877. Nous avons donc crée un programme qui commande l'envoi d'une valeur par liaison série en fonction du basculement des entrées de PIC. Tout d'abord, nous avons mesuré au voltmètre la tension de sortie de la carte de reconnaissance vocale puis, nous avons appliqué une tension de même valeur aux entrées du PIC afin de savoir si une adaptation de puissance était nécessaire. Nous avons donc mesuré une tension de 3,2V en sortie de la carte de reconnaissance, en appliquant cette tension aux entrées du PIC , nous avons observé qu'elle était suffisante pour les faire changer d'état.

15

Voici le programme réalisé afin de réaliser la « connexion » entre le sabertooth et le module de reconnaissance vocale : (Afin de faciliter la lecture du programme, nous le découperons en plusieurs parties pour expliquer le fonctionnement) #include <C:\Logiciels\PICC\Devices\16F877A.h> #fuses HS, NOWDT,NOPROTECT,NOLVP #use delay(clock=20000000) #use rs232(baud=38400,xmit=PIN_C6, rcv=PIN_C7) int a=64; int b=191; void main() { while(TRUE) { if(input(PIN_B0)==1)// arret { while(a!=64||b!=191) {a--; b--; if(a<=64) a=64 ; if(b<=191) b=191; putc(a); putc(b); delay_ms(100);} } } Voici le mode « arrêt », celui-ci gère les arrêts du fauteuil. On décrémente 2 variables que l'on envoie au driver de moteur par liaison série. Nous avons choisi de décrémenter deux variables et d'insérer un delay afin que le fauteuil ne s'arrête pas trop brusquement. Lorsque les variables descendent en dessous des valeurs d'arrêt de chaque moteur (64 pour le moteur 1 et 191 pour le moteur 2), nous les fixons à 64 et à 191 afin que les moteurs restent à l'arrêt et ne tournent pas dans l'autre sens.

16

if(input(PIN_B1)==1)//avant { if(a==64&&b==191) { while(a!=75&&b!=201) {a++; b++; putc(a); putc(b); delay_ms(100);} } if(a==75&&b==225) { while(a!=97) {a++; putc(a); delay_ms(100);} } if(a==97&&b==201) {while(b!=225) {b++; putc(b); delay_ms(100); } } } Cette partie du programme gère la marche avant du fauteuil, on distingue 2 cas différents : Lorsque les deux moteurs sont arrêtés, nous incrémentons deux variables afin de créer une rampe d'accélération (plus ou moins brusque grâce au delay), lorsque celles-ci atteignent 75 et 201 (valeurs déterminées par tests afin d'avoir une vitesse pas trop rapide), nous arrêtons l'incrémentation. Lorsque le fauteuil est en mode virage (on sait qu'il est en mode virage en testant les valeurs de a et b, si a=75 et b=225 ou a=97 et b=201) nous incrémentons la variable qui gère la vitesse du moteur qui tourne le moins vite afin qu'elle soit égale à la vitesse du moteur tournant le plus vite. En faisant ça, le fauteuil va donc arrêter de tourner et avancer en ligne droite. Il y a 3 cas en tout car on gère le cas du virage à droite et du virage à gauche.

17

if(input(PIN_B2)==1)// touner à gauche { a=75; putc(a); b=225; putc(b); } Dans ce mode, nous fixons la variable a à 75 et b à 225, la vitesse du moteur 1 sera donc inférieur à celle du moteur 2, cela aura pour conséquence de faire tourner le fauteuil (valeurs déterminées par tests afin que le virage soit léger). if(input(PIN_B3)==1)// touner à droite { a=97; putc(a); b=201; putc(b); } Dans ce mode, nous fixons la variable a à 97 et b à 201 (valeurs déterminées par tests afin que le virage soit léger). if(input(PIN_B4)==1)//accélération { if(a>117) { a=127;} else {a=a+10;} if(b>245) {b=255;} else {b=b+10;} putc(b); delay_ms(5); putc(a); } Ce mode permet à l'utilisateur de choisir la vitesse qu'il désire pour le fauteuil. En effet, lorsque celui-ci prononce le mot correspondant à l'accélération, une entrée du PIC va basculer. Les variables correspondant aux vitesses des moteurs seront alors incrémentées de 10 (valeurs déterminées afin que l'utilisateur puisse avoir 3 accélérations possibles depuis le mode marche avant). Lorsque les valeurs dépassent 245 et 117, on fixe cette valeur à 127 et 255 car ce sont les vitesses maximales des moteurs, au-delà, les moteurs tourneraient dans l'autre sens, cela rendrait le fauteuil dangereux.

18

if(input(PIN_B5)==1)//décélération { if(a<74) { a=64;} else {a=a-10;} if(b<201) {b=191;} else {b=b-10;} putc(b); delay_ms(5); putc(a); } Ce mode gère la décélération du fauteuil. Lorsque l'utilisateur prononce le mot correspondant à la décélération, une entrée du PIC va basculer. Les variables correspondant aux vitesses des moteurs seront alors décrémentées de 10 (valeurs déterminées afin que l'utilisateur puisse demander 3 décélérations depuis le mode marche avant). Lorsque les valeurs descendent en dessous de 201 et de 74, nous les fixons à 64 et 191 afin que les moteurs restent arrêtés et ne tournent pas dans l'autre sens. if(input(PIN_B6)==1)//demi-tour sur place { putc(255); putc(1); delay_ms(1000); putc(64); putc(191); } } } Ce dernier mode gère le demi-tour sur place. On commande un moteur à fond dans un sens et l'autre à fond dans l'autre sens pendant une durée d'une seconde (valeur déterminée par test afin que le fauteuil puisse faire un demi-tour complet).

Nous testons toujours l'état de l'entrée correspondant aux différents modes afin d'entrer dans chacun de ces modes. Ces entrées basculent en fonction du mot prononcé (principe vu précédemment).

19

3) Réalisation de la carte électronique :

A la base pour réaliser les tests de notre programme, nous avions utilisé une carte de développement qui nous a été fourni. Cependant, cette carte était alimentée par du 12V, cela posait donc un sérieux problème d’alimentation. En effet, pour réaliser les tests, nous mettions le fauteuil sur cales et nous utilisions une alimentation externe afin de pouvoir l’alimenter en 12V. Mais dans le cas d’un fonctionnement sans cales, avec de vrais déplacements, il fallait alimenter la carte d’une autre manière. C’est pour cela qu’une fois le fonctionnement validé, nous avons réalisé une carte afin de pouvoir enlever certains composants inutiles et avoir une carte qui est alimentée par du 5V, nous avons donc résolu le problème de l’alimentation car le driver de moteur fourni une tension de 5V, nous avons donc relié la sortie 5V du driver à l’alimentation de la carte afin de pouvoir embarquer le tout sur le fauteuil. Voici le typon de la carte que nous avons réalisé :

Sur cette carte, nous pouvons observer la présence de borniers servant à mieux pouvoir relier les sorties de la carte vocale aux entrées du PIC. On peut observer que seules les entrées du port B sont reliées au bornier. En effet, pour notre projet, nous avions seulement besoin de quelques entrées donc nous avons décidé d’utiliser exclusivement le port B. On retrouve également la présence de condensateurs de découplage mais aussi les condensateurs au niveau du bouton de reset servant à éviter les rebonds.

20

3) Maquette de test :

Afin de réaliser les tests plus facilement, sans utiliser le fauteuil, nous avons décidé de mettre en place une maquette qui symbolise les roues arrière du fauteuil électrique. Cette maquette est constituée de deux moteurs 12V, chaque moteur fait tourner une roue, c’est le même principe que le fauteuil. Les deux moteurs sont alimentés par le driver de moteur. Le reste du montage est le même que celui présenté dans la partie « explication générale du projet » sauf que les batteries qui alimentent le driver sont remplacées par une alimentation externe. Voici une photo de la maquette que nous avons réalisé :

21

V) Finalisation du projet : Une fois le fonctionnement du fauteuil validé, nous avons décidé de mettre en place un arrêt d’urgence afin que l’utilisateur puisse arrêter le fauteuil en cas de danger ou en cas de non reconnaissance de l’ordre émis par l’utilisateur. Nous avons aussi décidé de mettre en place un coffret au niveau des batteries afin de faciliter le rangement des différentes cartes. Nous avons aussi décidé de fixer notre micro sur une oreillette afin de ne pas être obligé de tenir le micro avec la main. Finalement, nous avons adapté la vitesse des moteurs afin de pouvoir se déplacer facilement dans une pièce, ceci nous a demandé de nombreux tests car il fallait modifier les valeurs envoyées par liaison série et sachant que les moteurs n’ont pas connu la même usure, il fallait mettre une vitesse plus importante sur le moteur le plus faible afin que le fauteuil puisse aller tout droit.

22

VI) Problèmes rencontrés : Nous avons rencontrés quelques problèmes durant ce projet, le plus important fût la mise en place de la liaison série, en effet nous avons mis quelques semaines à comprendre pourquoi cela ne fonctionnait pas. En fin de compte il s'est avéré que cela venait du fait que l'instruction “printf” envoyait les caractères en ASCII, les moteurs répondaient alors de manière aléatoire. Nous avons pu résoudre ce problème en regardant ce que nous obtenions au niveau du TX du PIC, nous avons alors compris que les caractères étaient en ASCII. Le deuxième gros problème fût au niveau de la programmation avec le langage servant à gérer la partie reconnaissance vocale. En effet, nous avions à notre disposition une multitude de programmes d'exemple mais ceux-ci étaient assez abouti, cela à donc été compliqué de faire le tri afin de comprendre les fonctions simples du logiciel. Ce travail d'analyse et de compréhension des fonctions a été une des parties les plus dures du projet. La prise en main du driver de moteur a été compliqué car nous voulions commander le fauteuil à l'aide d'une tension externe mais nous nous sommes rendu compte que cela était impossible car l'entrée du Sabertooth servant à la commande des moteurs est reliée en interne à la sortie 5V de celui-ci, ce qui rend la commande par une alimentation externe simplement impossible. Ce problème a été résolu par un gros travail de recherche sur internet, sur les documentations techniques et les témoignages d'autres personnes utilisant des composants similaires.

23

VII) Amélioration du projet :

L’amélioration majeure de notre projet consiste à pouvoir contrôler le fauteuil avec des mots français, pour ce faire, nous avons décidé d’utiliser ce module arduino :

Comme vous pouvez le voir sur l’image ci-dessus, cette carte vient se clipser sur une autre carte appelée afin de pouvoir alimenter la première et pouvoir la programmer via un cable USB. Voici un exemple de montage de deux cartes arduino :

24

Cette platine est équipée du module « EasyVR » et est dotée d’une liaison série. Elle est capable de reconnaître jusqu’à 32 mots qu’il faudra lui apprendre. La mémorisation se fait via un logiciel sur PC, le module est donc relié au port série de l’ordinateur. On peut noter que la reconnaissance des mots enregistrés est de type « mono locuteur ». Cependant, le module possède également une reconnaissance "multi-locuteur". Celle-ci regroupe environ vingt expressions : Action, bouge, tourne, cours, regarde, attaque, arrête, salut, à gauche, à droite, vers le haut, vers le bas, en avant, en arrière, 0, 1, 2 ,3 ,4, 5, 6, 7, 8, 9, 10. Ces différentes expressions peuvent être prononcées par n’importe quelle personne, l’apprentissage du mot n’est pas nécessaire. On peut noter que ces expressions peuvent être dites en plusieurs langues dont le français, l’allemand ou l’espagnole. Le module communiquera via liaison série afin d’indiquer au microcontrôleur quels mots ont été reconnus.

25

Conclusion : Ce projet a été très enrichissant car il nous a permis d'acquérir des connaissances dans le domaine de la reconnaissance vocale, ce domaine était totalement inconnu pour nous. La prise en main du module Smart VR était plutôt ludique, par exemple allumer des LED à la voix. Toutes les petites applications que nous avons dû réaliser étaient très intéressantes car cela changeait de la partie théorique que l'on peut avoir dans certains cours. Nous avons aussi eu la possibilité d'appliquer les connaissances acquises au cours de notre cursus scolaire comme en électronique avec la réalisation d'une carte ou encore en informatique avec la programmation en langage C. Grâce à tous ces travaux, nous avons pu nous apercevoir que nous sommes capables de mener un projet à bien avec une grande autonomie. Nous avons appris à nous organiser, à répartir le travail ainsi qu'à respecter un planning. Dorénavant, nos futurs travaux seront beaucoup plus organisés et structurés que par le passé ce qui sera bénéfique dans nos futurs métiers. Durant ce projet nous avons connu pas mal de pannes et de disfonctionnements, cela nous a permis d'apprendre à analyser la situation et à trouver des solutions afin de pouvoir terminer dans les temps. Nous sortons donc de ce projet avec une confiance plus grande en nos capacités ainsi qu'une rigueur de travail plus importante.

26

Annexes :