Souris pour personne en situation d'handicap

De fablab
Aller à : navigation, rechercher

Informations générales

Encadrants: Jérôme Maisonnasse,

Ce projet est pour un groupe de 2 à 4 étudiants intéressés par l'informatique embarquée (C/C++) et l'intégration de capteurs.

Contexte

Dans le contexte économique actuel, les solutions technologiques pour permettre aux personnes en situation d'handicap de gagner en autonomie sont chères et "packagées" dans des formats propriétaires qui rend l'alignement avec les spécificités de l'handicap compliqué. Nous vous proposons de contribuer à une solution opensource et openhardware d'une souris gyroscopique integrée à un casque pour permettre à un étudiant tétraplégique de manipuler sa souris d'ordinateur avec des mouvements de la tête.

Sujet

Les étudiants auront à intégrer des capteurs du type : accéléromètre, un module Bluetooth 4.0 avec le bon profile (ex : HID) pour que le système détecte automatiquement le nouveau dispositif comme une souris. http://redbearlab.com/blendmicro/


Casque commercial


Informations générales sur le projet

Composition de l'équipe

  • Lucie OUVRIER-BUFFET
  • Mégane RUFFIOT

Nom du projet

Souris pour personne en situation de handicap

Vidéo de présentation

https://youtu.be/PyI7RoiyjOY

GitHub repository

Le code source final de notre projet se situe ici

https://github.com/MegR/Arduino-Head-Mouse-Project

Fonctionnalités du produit

L’interface JAVA permet de contrôler toutes les interactions de type clic du produit. Elle se présente sous la forme d’une fenêtre avec des boutons de contrôle. Pour en activer un, il est nécessaire de rester 2 secondes sur l’un deux, il se colore et on dispose ensuite de 3 ou 5 secondes pour se placer à l’endroit où l’on souhaite cliquer avant que le clic se déclenche.

L’interface JAVA implémente 6 fonctionnalités :

  • clic gauche
  • double clic gauche
  • clic molette
  • clic droit puis gauche (3 secondes de battement)
  • clic gauche puis gauche (3 secondes de battement)
  • déplacement : clic gauche appuyé pendant 5 secondes

On peut voir le temps qu’il reste pour se placer sur l’endroit à cliquer à l’aide d’un compteur.

La partie Arduino du code permet de détecter deux commandes particulières par des mouvements de tête spécifiques.

La première est la recalibration de la souris : la souris est placée au centre de l’écran puis une temporisation de 2 secondes permet à l’utilisateur de replacer sa tête comme il l’entend sans que la souris ne bouge. Cette commande est détectée par une vive rotation sur l’axe de roulis.

La deuxième commande est une commande qui recalibre et simule l’appui sur la touche ​Echap, elle peut être utile dans le cas où l’utilisateur ne choisit pas l’action appropriée et se retrouve alors bloqué dans un menu. Cette commande est détectée par une vive rotation selon l’axe de tangage.

Axes de détection
Axes de détection

Choix des technologies​

Carte

Depuis le début du projet, nous avons travaillé avec des cartes Arduino car celles-ci sont les moins coûteuses, et les plus faciles à utiliser. Au début du projet, le FabLab nous a fourni une carte Arduino Nano. Nous avons cependant dû changer de carte car celle-ci ne possédait pas la librairie Mouse d’Arduino, permettant de déplacer la souris directement grâce à la carte. Le FabLab nous a donc fourni une carte Arduino Micro, étant de la même taille que la Nano, et supportant les déplacements de curseur. Nous avons eu des soucis de connectivité avec cette carte à cause d’un mauvais choix de programmateur. La carte n’était plus reconnu par aucun ordinateur, il nous était donc impossible de téléverser des programmes. Nous avons finalement fini le projet avec une carte Arduino Leonardo, avec laquelle nous n’avons pas eu de problème.

Al.jpg

Carte Arduino Leonardo


Capteur

Le FabLab nous a fourni au début du projet un gyromètre 3 axes Arduino GY-521, aussi appelé MPU-6050.

Gy521.jpg

Gyromètre 3 axes Arduino GY-521


Liaison (filaire VS Bluetooth)

La finalité de ce projet était de faire une connexion Bluetooth entre la carte Arduino et l’ordinateur. Nous devions tout d’abord développer la connexion en Bluetooth 3.0, et si il nous restait du temps, nous devions le faire en Bluetooth 4.0. Pour la première connexion réalisée en Bluetooth 3.0, le FabLab nous a fourni une carte Arduino GW-040, aussi appelée HC-05.

Gw040.jpg

Carte Arduino GW-040


Partie matérielle

Schéma de cablage
Schéma de cablage


Bluetooth

Problématique

La problématique était de ne pas avoir à brancher la souris à l’ordinateur, afin de permettre un plus grand confort d’utilisation. Ceci aurait été possible grâce à un module Bluetooth faisant la liaison entre la carte Arduino et l’ordinateur.

Nos approches et problèmes rencontrés

Comme nous allons le voir plus bas, la carte Arduino calcule des écarts correspondant aux déplacements à effectuer, et les envoient au module Bluetooth grâce à une liaison série établie au démarrage entre la carte Arduino et le module Bluetooth. Il nous faut ensuite un programme sur l’ordinateur connecté en Bluetooth au module, qui aille lire sur le port série et qui récupère les déplacements à réaliser.

Problèmes rencontrés :

Le FabLab nous a parlé de l’environnement Processing, nous avons donc commencé par utiliser cet outil. Déplacer la souris ne posait aucune difficulté grâce à la classe Robot. Le problème s’est cependant posé pour récupérer les données sur le port série. Nous avons eu le problème que la liaison série s’ouvrait et se fermait constamment, le code n’était pas stable. Nous avions aussi un problème de formatage de données. Nous envoyions des entiers sur le port série mais nous n’avons pas trouvé comment recevoir les données au bon format. Nous avons donc opté pour la solution d’envoyer des chaînes de caractères, avec un indice à la fin qui nous indiquait l’axe à déplacer (0 pour X et 1 pour Y par exemple).

Nous avons ensuite opté pour l’écriture d’un programme Java, qui nous paraissait plus stable pour la gestion des liaisons séries. La connexion s’est effectivement mieux passée et nous n’avions pas de problèmes pour la lecture des données. Nous envoyions des chaines de caractères et les convertissions facilement en entier côté Java. Le seul problème que nous avons eu avec cette méthode, c’est la gestion d’un grand flux de données. Le programme Java n’arrivait pas à suivre la cadence de la carte Arduino, et le résultat visuel était donc beaucoup trop saccadé. Nous avons essayé d’envoyer moins de données et d’échantillonner, mais le résultat n’était toujours pas satisfaisant car on perdait en précision et il était donc impossible de pointer convenablement avec le curseur.

Le projet approchant à son échéance, nous avons pris la décision d’abandonner le développement du module Bluetooth. Nous avons préféré rendre un produit utilisable et fonctionnel, même si un câble est nécessaire. Nous avons donc terminé le développement en filaire, avec la carte Arduino réalisant directement les déplacements de la souris grâce à la librairie Mouse.

Liaison filaire

Finir le projet en connexion filaire nous a obligé à réaliser quelques ajustements. La carte Arduino ne connaissant pas la taille de l’écran, nous avons dû trouver une solution pour qu’elle puisse l’obtenir. Il nous était en effet indispensable de l’avoir pour pouvoir affecter un facteur de sensibilité à la souris. Le déplacement doit être proportionnel à la taille de l’écran, afin que l’utilisation soit la plus confortable et la plus pratique possible.

Nous avons ensuite dû gérer le problème de recalibration autrement. La carte Arduino ne connait pas la position du pointeur sur l’écran car les déplacements sont réalisés de manière relative par rapport à la position précédente. En Java, la taille de l’écran est connue et les déplacement sont absolus. Nous avons donc compris que la recalibration serait plus simple depuis Java, car il suffit de ramener la souris au centre de l’écran.

Nous avons donc écrit un programme Java établissant une liaison série avec le port série de la carte Arduino. Ce programme envoie tout d’abord la taille de l’écran à la carte Arduino. La souris ne fonctionne donc pas tant que l’application Java n’est pas lancée. Pour la recalibration, le code Java gère le déplacement de la souris. La carte Arduino détecte quand elle doit recalibrer et envoie une donnée au port série pour demander la recalibration (code 2 ou 3).

Capteur

Problématique

La problématique principale est d’exploiter au mieux les données du capteur afin d’obtenir une utilisation intuitive de la souris et fidèle à la précision des mouvements de tête.

Nos approches et problèmes rencontrés

Nous avons dans un premier temps réalisé des tests afin d’analyser les données acquises par le capteur.

Problèmes rencontrés :

La première question à laquelle nous avons dû réfléchir concernait l’endroit où l’on plaçait le capteur sur la tête. Nous l’avons tout d’abord fixé sur la tempe puis, considérant que cela ne nous procurait pas une précision suffisamment grande, nous l’avons fixé à l’arrière de la tête.

Module placé à l'arrière de la tête
Module placé à l'arrière de la tête


Un point important dont il a fallu tenir compte est que les mouvements de rotation de la tête entraînent une rotation du capteur sur deux axes en même temps (puisque le capteur est éloigné à une dizaine de centimètres du centre de rotation de la tête). Nous avons réglé cette problématique en n’exploitant que deux axes de rotation.


Enfin, un dernier point auquel nous nous sommes heurtées était le fait que lorsque le gyromètre atteint une certaine inclinaison, la valeur brute d’accélération angulaire relevée passe d’une valeur positive à une valeur négative. Le traitement des données grâce aux fonctions de la bibliothèque mpu6050 nous conduisait ensuite à un changement de sens de la souris sur l’écran. On constate sur les graphiques suivants que lorsque la tête d'un individu fait un aller-retour avec sa tête (1 période), cela correspond à deux aller-retours (2 périodes) en ce qui concerne la valeur d'angle calculée par le code Arduino.

Phénomène de "mur"

Nous n’avons pas réussi à traiter ce problème de manière logiciel puisqu’il s’agissait d’un problème qui impactait directement les données brutes. Nous l’avons finalement réglé en inclinant le capteur de 90°.

Capteur incliné à 90°
Capteur incliné à 90°

Partie logicielle

Arduino

Le code Arduino s’articule en plusieurs parties :

  • Initialisation :

Au branchement de la carte Arduino, le programme chargé dans la carte s’exécute et le code de l’initialisation attend que le code Java lui envoie la taille de l’écran pour démarrer et simuler les mouvements de la souris.

  • Acquisition des données :

Afin de réaliser l’intégration des données d’accélération, on utilise les fonctions de la librairie ​ mpu6050 ​ .

  • Calcul des écarts :

On calcule ensuite des écarts d’angles entre la valeur d’angle courante et la valeur précédente. Afin de rendre la gestion du pointeur précise, nous avons choisi de ne bouger la souris que lorsque le mouvement dépasse un certain seuil de quelques degrés.

  • Mouvement de la souris :

Afin de déplacer la souris, on utilise la bibliothèque ​ mouse ​ et l’on déplace la souris de l’écart d’angle observé multiplié par des coefficients de dilatation relatifs à la taille de l’écran (fourni au démarrage par le code Java).

  • Détection de recalibration :

Pour la détection de recalibration et de simulation de la touche echap, on utilise des mouvement de tête rapide selon l’axe de roulis respectivement tangage. On exploite donc directement les données brutes des accélérations angulaires en testant que leur valeur dépasse un certain seuil. Une fois la commande détectée, on envoie sur la liaison série un code signifiant le type d’action que l’on souhaite réaliser. L’action est ensuite réalisée par le code Java.

  • Loi de Fitts :

Pour améliorer la précision du pointeur, nous nous sommes renseignées sur la loi de Fitts : elle stipule, dans le cas des petites cibles, que plus le chemin qui reste à parcourir est proche, plus il faut de temps pour le parcourir et arriver à la cible. Nous avons donc développé un modèle de code Arduino dans lequel la souris se déplace moins vite (diminution du coefficient de dilatation) lorsque le mouvement angulaire décélère. Nous l’avons testé en comparaison du modèle original. Nous avons finalement opté pour l’original car le modèle implémenté du ralentissement conduisait à réduire le champ dans lequel on peut bouger la tête sans recalibrer.

Java

  • Liaison série

La première partie de notre programme, le programme établit la liaison série avec la carte Arduino. Il envoie tout d’abord la taille de l’écran à la carte. Ensuite, il se met en mode écoute, et réalise la recalibration s’il reçoit 2, et la simulation de la touche échap s’il reçoit 3, en cas de problème de blocage.

  • Génération des clics

La deuxième partie de notre programme Java est la console permettant à l’utilisateur de faire les clics. Cette fenêtre bénéficie de l’autofocus, permettant de ne jamais la perdre. Nous avons dû réfléchir aux scénarios de base, afin de savoir précisément quels clics étaient nécessaires. Nous avons fait beaucoup d’essais afin d’être certaines d’avoir pensé à tout et de ne pas avoir de blocage. Il faut tout d’abord savoir que nos boutons s’activent si on reste deux secondes dessus. Quand le bouton s’active, celui-ci passe au vert, et un décompte se déclenche, donnant le nombre de secondes avant la génération du clic. Une fois le clic généré, le décompte reste à 0, et le bouton reprend sa couleur initiale.

Console de sélection de clic
Console de sélection de clic


  • Nous avons, pour commencer, mis un bouton permettant la recalibration de la souris.
  • Nous avons ensuite mis un bouton permettant le clic gauche, généré après trois secondes.
  • Le double clic gauche est aussi possible, avec un délai de trois secondes.
  • Le clic molette est aussi réalisable après trois secondes.
  • Nous avons bien constaté que le clic droit ouvrait toujours un menu déroulant, et qu’il fallait donc toujours générer un clic gauche après pour la sélection. Nous avons donc créé un bouton qui génère un clic droit après trois secondes, et un clic gauche trois secondes après.
  • Certains menus s’ouvrant avec le clic gauche, nous avons généré un bouton faisant un clic gauche au bout de trois secondes, et un deuxième clic gauche trois secondes plus tard.
  • Nous avons enfin trouvé qu’il serait bien de pouvoir sélectionner du texte. Pour cela, nous avons fait un bouton qui simule un appui prolongé sur le clic gauche. Ceci a été réalisable grâce à un délai entre l’appui du bouton, et son relâchement. Nous avons laissé à l’utilisateur trois secondes pour se placer, et cinq secondes pour la sélection.

Tous les délais sont facilement modifiables dans le programme Java si nécessaire.

Tests réalisés

Afin de réaliser les tests, nous avons écrit une liste de scénarios basiques de cas d’utilisation d’un ordinateur afin de couvrir une utilisation classique d’ordinateur. Nous les avons ensuite exécuté un à un afin de vérifier qu’il soient tous faisables.

Nous avons également procédé à des tests de pointage avec des cibles plus ou moins petites afin d’avoir une idée de la précision de la souris et des choix à faire entre la configuration avec ou sans ralentissement de la vitesse du pointeur en fonction de la vitesse de rotation de la tête.

Nous aurions aussi beaucoup apprécié faire un test dans des conditions réelles, avec une personne tétraplégique.

Perspectives d'approfondissement

Nous aurions souhaité aller plus loin dans le projet et développer plus de fonctionnalités. Les fonctions que nous aurions voulu développer étaient la gestion du scroll (pour lire des documents par exemple) ou encore le fait de cliquer en restant appuyé durant un temps que l’on contrôle. Enfin, une autre amélioration notable aurait été de réussir à exploiter le Bluetooth afin de rendre le produit moins contraignant.

Codes sources utilisés

Pour la manipulation des valeurs du gyromètre, nous avons utilisé la librairie MPU6050 ​ de Jeff Rowberg, disponible sur Github ici

https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

et pour l'intégration des données du gyromètre, nous avons utilisé le code donné sur le forum du site officiel Arduino (Auteur : 3Sigma) disponible à cette adresse :

http://forum.arduino.cc/index.php?topic=224897.0

Pour la liaison série entre Java et la carte Arduino, nous avons utilisé un code de base ​ SerialTest ​ disponible ici, établissant la connexion et écrivant les données reçues dans la console.

http://playground.arduino.cc/Interfacing/Java