DUMAS Clément, ORIOL Alexandre

Sommaire

1 Projet : Datagloves à flexomètres et transmission sans fil (Sparkfun ESP32 Thing)

Projet : Datagloves à flexomètres et transmission sans fil (Sparkfun ESP32 Thing)

Séance 1 : Découverte du sujet

Description de l'existant :

- flexomètre : capteur électronique qui mesure le taux de flexion ; plus l'angle de flexion est élevé, plus la résistance est grande. Le capteur est constitué d'une encre polymère composée de particules conductrices imprimée sur un substrat en plastique. Lors de la flexion, Les particules conductrices de l'encre s'écartent les unes des autres, ce qui fait varier la résistance du capteur.

Schéma de câblage pour l'acquisition des données du capteur :

- Le data glove que nous allons utiliser :

Sur ce gant, il y a deux types de capteurs de flexion :

- celui du pouce (plus court) : R = 80kΩ à plat, 180kΩ fléchi (environ)

- tous les autres (plus long) : R = 25kΩ à plat, 100kΩ fléchi (environ)

Nous avons tout d'abord commencé par tester le module ESP32. Il faut tout d'abord installer la librairie (avec le Gestionnaire de cartes) afin de pouvoir compiler et téléverser le programme pour l'ESP32. On a essayé un programme de permettant de faire clignoter de la LED embarquée avec un PC Windows et le logiciel Arduino IDE. Le programme fonctionne et la LED clignote.

Sur Mac, on n'arrive pas à compiler le programme, aucun compilateur n'est détecté pour ce type de carte. Il semble s'agir d'un problème de bibliothèque.

Pour la prochaine séance, il faudrait qu'on arrive à récupérer les informations des capteurs et les interpréter.

Séance 2 : Acquisition des données brutes sur l'IDE Arduino

Lors de cette séance, nous avons identifié le câblage de la platine, fournie avec le gant et l'ESP32 lors de la séance précédente :

On en a déduit le câblage suivant :

Il s'agit de ponts diviseurs de tension avec 3V3 en entrée, une résistance fixe (soudée à la platine), une résistance de pull-down (flexomètre). La valeur de la tension de sortie est redirigée vers un connecteur qui sera connecté à l'ESP32.

Par conséquent, nous avons besoin d'une broche de Masse (GND), d'une alimentation 3V3 et de 5 broches GPIO pour l'acquisition des données des 5 flexomètres. Nous câblerons les broches sur les pins 26, 27, 14, 12 et 13 de l'ESP32. Ces broches sont reliées à des ADCs, permettant de faire la conversion analogique vers numérique des valeurs afin de pouvoir les interpréter ensuite.

Concernant les plages de valeurs des capteurs, l'ESP32 convertit les signaux analogiques en signaux numériques sur 12 bits (4096 valeurs). Avec les résistances présentes sur la platine, les tensions présentes sur les ports de l'ESP32 se situent entre 1,69 et 2,67V, soit un ∆≈1V.

Après étude, afin d'optimiser la plage de valeurs en fonction des flexomètres, il faudrait que les résistances de la platine aient une valeur d'environ 50kΩ, on obtiendrait un ∆≈1,1V :

Nous avons décidé de conserver les résistances déjà présentes sur la platine ; si on augmente la valeur des résistances, pour des valeurs de tension aussi faibles, le bruit thermique et les perturbations externes deviennent de moins en moins négligeables. Résultat : les valeurs oscillent plus.

Nous avons réalisé une première acquisition des données à l'aide de ce code :

Il permet de récupérer les données analogiques des flexomètres et de rafraichir les 5 valeurs toutes les 1/2 secondes.

Pour la séance suivante, on pense commencer à découvrir le logiciel Processing, à établir une communication entre Processing et l'ESP32 et commencer à traiter les données. Si possible, il serait intéressant d'essayer de communiquer avec l'ESP32 en Wi-Fi (présence d'un code d'essai dans la librairie de l'ESP32).

Séance 3 : Découverte de Processing

Lors de cette séance, nous avons fait des essais de communication entre Processing et l'ESP32, d'abord via port COM en USB. Nous avons tout d'abord essayé de récupérer la valeur de résistance d'un flexomètre qui permet de modifier la couleur d'une fenêtre sur Processing. Nous nous sommes rendu compte que nous allions devoir sérialiser les données afin de transmettre les données des 5 doigts sur une seule trame. Nous avons réalisé un second programme avec 3 données, séparées par des virgules pour les distinguer sur le port COM :

En fin de séance, nous avons essayé des codes d'exemples permettant une communication sans fil. Nous avons modifié ce fichier avec un nouveau nom de réseau et un mot de passe :

Après avoir téléversé le code sur l'ESP32, le réseau Wi-Fi est bien détecté par un téléphone ou un PC et nous pouvons bien nous connecter.

Séance 4 : Processing, la suite

Lors de cette séance, nous avons débuté la programmation sous Processing. Nous avons débuté nos essais par créer un rectangle dans une fenêtre et de le faire tourner sur lui-même avec la souris :

Grâce à une souris ou un trackpad, nous pouvons orienter le cube selon les axes des abscisses et des ordonnées, ce qui nous permettra par la suite d'orienter la main comme on le souhaite :

Ensuite, nous avons fait l'acquisition des données des 5 doigts sous Processing et visualiser les valeurs avec des rotations qui s'opèrent sur 5 cubes :

Pour la prochaine séance, nous pensons commencer à modéliser une main sur Processing et essayer de la contrôler avec le dataglove.

Séance 5 : Débuts de la modélisation de la main

Lors de cette séance, nous avons débuté la modélisation de la main à partir d'une solution trouvée sur internet. Elle modélise les doigts de la main à l'aide d'une succession de sphères (on ne peut pas modéliser ce genre de formes nativement) :

Pour essayer de régler les problèmes de valeurs instables, nous avons implémenté une moyenne glissante sur les 5 valeurs des flexomètres. Nous utilison la bibliothèque Runningaverage.h dans le code arduino qui intègre toutes les fonctionnalités nécessaires. Cette moyenne fonctionne bien, sauf pour celle du pouce, qui reste malgré tout très instable.

Travail à la maison n°1 :

Pour être plus efficace, nous avons emporté le dataglove pour poursuivre le projet chez nous. Nous avons pu effectuer le traitement des valeurs par processing, ce qui permet aux doigts modélisés de bien suivre les mouvements réels de la main :

Sur notre fenêtre, nous affichons également la valeur des flexomètres, ce qui permet de mieux déboguer. Aussi, nous nous sommes accordés avec l'autre binôme du groupe A pour refaire le gant (petites pochettes pour mieux contenir les flexomètres). On remercie tout particulièrement Gaël Riou et sa soeur pour le nouveau gant, bien plus robuste et fonctionnel qu'auparavant :

Séance 6 : Optimisation

Lors de cette séance, nous avons décidé de changer l'une des résistances sur notre platine, celle du pouce. Celle-ci avait une valeur de 71.5kΩ, valeur trop élevée pour avoir une précision correcte (la valeur n'était pas stable et présence de bruit). Nous l'avons remplacée par une résistance de 24 kΩ, proche de la valeur des 4 autres présentes sur notre platine. Suite à ce changement, nous avons dû recalibrer nos valeurs, mais cette opération a réglé nos problèmes.

Séance 7 : Communication sans-fil

Nous avons modifié le protocole de communication de l'ESP32. Nous utilisions auparavant une liaison série USB filaire, nous sommes passés par une liaison série Bluetooth (sans-fil). Pour cela, nous avons dû modifier le code Arduino en ajoutant la bibliothèque Bluetoothserial.h et en utilisant les méthodes adaptées. En ce qui concerne l'implémentation Processing, nous avons simplement dû changer le nom du port série et la vitesse de communication (pasage de 9600 à 115200 bauds) :

Aussi, suite à une mise à jour des librairies Arduino sur Mac, il m'a été possible de complier et de téléverser le code depuis un ordinateur portable, au lieu de passer à chaque fois par le PC fixe.

Séance 8 : Problèmes matériels

Au cours de cette séance, nous avons été confrontés à plusieurs problèmes matériels; le flexomètre de l'auriculaire ne fonctionnait plus, en raison de son design peu robuste. En effet, la pate de fixation, posée sur la piste résistive et sertie au substrat en plastique frotte contre la piste conductrice. Au fil de l'utilisation, cette pate use la piste et le contact ne se fait plus. N'ayant pas de flexomètre de rechange, nous n'avons pas eu d'autre moyen que de tenter une réparation en soudant un fil sur la pate du capteur et de la plaquer sur la piste conductrice à l'aide d'un morceau de scotch. Cette solution semble fonctionner malgré tout. Une autre solution de réparation était d'utiliser de l'encre conductrice pour rétablir la connexion.

Bonus : implémentation du jeu Pierre, Feuille, Ciseaux

Ayant respecté tous les exigences minimales du cahier des charges, nous avons décidé d'aller plus loin et d'implémenter le jeu Pierre, Feuille, Ciseaux à notre code Processing. Le programme détecte si on fait une des figures, l'affiche et si on appuie sur la fenêtre, le programme génère automatiquement une figure et affiche si nous avons gagné, perdu ou égalité. Le score est également géré. Nous avons par contre eu un problème concernant la gestion du temps. En effet, il n'est pas possible de mettre un délai dans la boucle permettant d'afficher le résultat quelques instants. La fonction délai semble inutilisable dans une boucle draw(). Nous n'avons pas eu le temps de régler ce problème; notre code et jeu reste fonctionnel tout de même.

Pierre :