Robots pompiers

2022-04-05T15:15:14Z

Alexandre Oriol :

Fichier:StreamCam.png

2022-04-05T15:13:27Z

Alexandre Oriol :

2021-06-05T13:47:01Z

Alexandre Oriol :

Fichier:DGPierre.png

2021-06-05T13:46:35Z

Alexandre Oriol :

2021-05-31T10:18:38Z

Alexandre Oriol :

PAE 2021 Datagloves

2021-05-31T10:18:19Z

Alexandre Oriol :

DUMAS Clément, ORIOL Alexandre

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

Séance 1 : Découverte du sujet

flexomètre : résistance variable qui augmente avec l'angle de flexion.
Schéma de câblage pour l'acquisition des données du capteur :

[[image:DUMAS_ORIOL_flexomètre.png|alt]]

Le data glove que nous allons utiliser :

[[image:photo-gant-redim.png|alt]]

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)

On a testé l'ESP32 avec un programme de clignotement de la LED embarquée avec un PC Windows et Arduino IDE. Le programme fonctionne et la LED clignotte.
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 faut qu'on remette en état le gant et qu'on essaye de lire les données des capteurs.

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 :

[[image:photo-platine.png|alt]]

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

[[image:schéma-platine.png|alt]]

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 flexomètres. Nous câblerons les broches sur les pins 26, 27, 14, 12 et 13 de l'ESP32.

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 :

[[image:courbe_delta.png|alt]]

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 :

[[image:DUMAS_ORIOL_code_22_mars.JPG|400px]]

Il permet de récupérer les données analogiques des flexomètres et de rafraichir les 5 valeurs toutes les 1/2 secondes. Cela nous a permis de valider les doigts auxquels sont reliés les différents ports.

Pour la séance suivante, on pense commencer à découvrir Processing, à établir une communication entre Processing et l'ESP32 et commencer à les traiter. 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 :

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 programme d'essai avec 3 données, séparées par des virgules pour les distinguer sur le port COM :

[[image:Capture transmission serie 3 doigts.JPG]]

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 :

[[image:code-AP-wifi.png|500px]]

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 :

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 :

[[image:code_vue_camera.png|500px]]

Grâce à une souris ou un trackpad, nous pouvons orienter le cube selon les axes des abscisses et des ordonnées :

[[image:vue_processing_cube.png|500px]]

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 :
[[image:Code processing 8 avril.jpg|500px]]
[[image:5 Cubes Processing.JPG|600px]]

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 :

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) :

[[image:doigt_processing.png|500px]]

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 :

[[image:main_processing.png|500px]]

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 :

[[image:nouveau_dataglove.JPG|500px]]

Séance 6 :

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 :

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) :

[[image:bluetooth_processing.png|alt]]

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 :

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. 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 flexo et de la plaquer sur la piste conductrice à l'aide d'un morceau de scotch. Cette solution semble fonctionner malgré tout. Nous aurions pu utiliser de l'encre conductrice, mais il n'y en avait pas.

Bonus : implémentation du jeu papier, caillou, ciseaux

Ayant respecté tous les besoins minimum du cahier des charges, nous avons décidé d'aller plus loin et d'implémenter le jeu papier, caillou, 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.

Liens :
- explications flexomètres + exemple application : https://learn.sparkfun.com/tutorials/flex-sensor-hookup-guide
- codes exemples processing : http://learningprocessing.com/examples/chp14/example-14-14-rotate-rect1-rect2

PAE 2021 Datagloves

2021-05-31T10:15:37Z

Alexandre Oriol :

DUMAS Clément, ORIOL Alexandre

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

Séance 1 : Découverte du sujet

flexomètre : résistance variable qui augmente avec l'angle de flexion.
Schéma de câblage pour l'acquisition des données du capteur :

[[image:DUMAS_ORIOL_flexomètre.png|alt]]

Le data glove que nous allons utiliser :

[[image:photo-gant-redim.png|alt]]

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)

On a testé l'ESP32 avec un programme de clignotement de la LED embarquée avec un PC Windows et Arduino IDE. Le programme fonctionne et la LED clignotte.
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 faut qu'on remette en état le gant et qu'on essaye de lire les données des capteurs.

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 :

[[image:photo-platine.png|alt]]

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

[[image:schéma-platine.png|alt]]

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 flexomètres. Nous câblerons les broches sur les pins 26, 27, 14, 12 et 13 de l'ESP32.

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 :

[[image:courbe_delta.png|alt]]

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 :

[[image:DUMAS_ORIOL_code_22_mars.JPG|400px]]

Il permet de récupérer les données analogiques des flexomètres et de rafraichir les 5 valeurs toutes les 1/2 secondes. Cela nous a permis de valider les doigts auxquels sont reliés les différents ports.

Pour la séance suivante, on pense commencer à découvrir Processing, à établir une communication entre Processing et l'ESP32 et commencer à les traiter. 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 :

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 programme d'essai avec 3 données, séparées par des virgules pour les distinguer sur le port COM :

[[image:Capture transmission serie 3 doigts.JPG]]

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 :

[[image:code-AP-wifi.png|500px]]

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 :

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 :

[[image:code_vue_camera.png|500px]]

Grâce à une souris ou un trackpad, nous pouvons orienter le cube selon les axes des abscisses et des ordonnées :

[[image:vue_processing_cube.png|500px]]

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 :
[[image:Code processing 8 avril.jpg|500px]]
[[image:5 Cubes Processing.JPG|600px]]

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 :

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) :

[[image:doigt_processing.png|500px]]

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 :

[[image:main_processing.png|500px]]

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 :

[[image:nouveau_dataglove.JPG|500px]]

Séance 6 :

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 :

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 mon ordinateur portable, au lieu de passer à chaque fois par le PC fixe.

Séance 8 :

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. 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 flexo et de la plaquer sur la piste conductrice à l'aide d'un morceau de scotch. Cette solution semble fonctionner malgré tout. Nous aurions pu utiliser de l'encre conductrice, mais il n'y en avait pas.

Bonus : implémentation du jeu papier, caillou, ciseaux

Ayant respecté tous les besoins minimum du cahier des charges, nous avons décidé d'aller plus loin et d'implémenter le jeu papier, caillou, 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.

Liens :
- explications flexomètres + exemple application : https://learn.sparkfun.com/tutorials/flex-sensor-hookup-guide
- codes exemples processing : http://learningprocessing.com/examples/chp14/example-14-14-rotate-rect1-rect2

PAE 2021 Datagloves

2021-05-31T10:11:09Z

Alexandre Oriol :

DUMAS Clément, ORIOL Alexandre

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

Séance 1 : Découverte du sujet

flexomètre : résistance variable qui augmente avec l'angle de flexion.
Schéma de câblage pour l'acquisition des données du capteur :

[[image:DUMAS_ORIOL_flexomètre.png|alt]]

Le data glove que nous allons utiliser :

[[image:photo-gant-redim.png|alt]]

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)

On a testé l'ESP32 avec un programme de clignotement de la LED embarquée avec un PC Windows et Arduino IDE. Le programme fonctionne et la LED clignotte.
Sur Mac, on n'arrive pas à compiler le programme, aucun compilateur n'est détecté pour ce type de carte.

Pour la prochaine séance, il faut qu'on remette en état le gant et qu'on essaye de lire les données des capteurs.

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 :

[[image:photo-platine.png|alt]]

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

[[image:schéma-platine.png|alt]]

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 flexomètres. Nous câblerons les broches sur les pins 26, 27, 14, 12 et 13 de l'ESP32.

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 :

[[image:courbe_delta.png|alt]]

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 :

[[image:DUMAS_ORIOL_code_22_mars.JPG|400px]]

Il permet de récupérer les données analogiques des flexomètres et de rafraichir les 5 valeurs toutes les 1/2 secondes. Cela nous a permis de valider les doigts auxquels sont reliés les différents ports.

Pour la séance suivante, on pense commencer à découvrir Processing, à établir une communication entre Processing et l'ESP32 et commencer à les traiter. 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 :

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 programme d'essai avec 3 données, séparées par des virgules pour les distinguer sur le port COM :

[[image:Capture transmission serie 3 doigts.JPG]]

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 :

[[image:code-AP-wifi.png|500px]]

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 :

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 :

[[image:code_vue_camera.png|500px]]

Grâce à une souris ou un trackpad, nous pouvons orienter le cube selon les axes des abscisses et des ordonnées :

[[image:vue_processing_cube.png|500px]]

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 :
[[image:Code processing 8 avril.jpg|500px]]
[[image:5 Cubes Processing.JPG|600px]]

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 :

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) :

[[image:doigt_processing.png|500px]]

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 :

[[image:main_processing.png|500px]]

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 :

[[image:nouveau_dataglove.JPG|500px]]

Séance 6 :

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 :

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 mon ordinateur portable, au lieu de passer à chaque fois par le PC fixe.

Séance 8 :

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. 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 flexo et de la plaquer sur la piste conductrice à l'aide d'un morceau de scotch. Cette solution semble fonctionner malgré tout. Nous aurions pu utiliser de l'encre conductrice, mais il n'y en avait pas.

Bonus : implémentation du jeu papier, caillou, ciseaux

Ayant respecté tous les besoins minimum du cahier des charges, nous avons décidé d'aller plus loin et d'implémenter le jeu papier, caillou, 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.

Liens :
- explications flexomètres + exemple application : https://learn.sparkfun.com/tutorials/flex-sensor-hookup-guide
- codes exemples processing : http://learningprocessing.com/examples/chp14/example-14-14-rotate-rect1-rect2

Fichier:Courbe delta.png

2021-05-31T10:10:31Z

Alexandre Oriol :

PAE 2021 Datagloves

2021-05-31T10:10:12Z

Alexandre Oriol :

DUMAS Clément, ORIOL Alexandre

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

Séance 1 : Découverte du sujet

flexomètre : résistance variable qui augmente avec l'angle de flexion.
Schéma de câblage pour l'acquisition des données du capteur :

[[image:DUMAS_ORIOL_flexomètre.png|alt]]

Le data glove que nous allons utiliser :

[[image:photo-gant-redim.png|alt]]

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)

On a testé l'ESP32 avec un programme de clignotement de la LED embarquée avec un PC Windows et Arduino IDE. Le programme fonctionne et la LED clignotte.
Sur Mac, on n'arrive pas à compiler le programme, aucun compilateur n'est détecté pour ce type de carte.

Pour la prochaine séance, il faut qu'on remette en état le gant et qu'on essaye de lire les données des capteurs.

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 :

[[image:photo-platine.png|alt]]

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

[[image:schéma-platine.png|alt]]

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 flexomètres. Nous câblerons les broches sur les pins 26, 27, 14, 12 et 13 de l'ESP32.

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 :

[[image:courbe_delta.png]]

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 :

[[image:DUMAS_ORIOL_code_22_mars.JPG|400px]]

Il permet de récupérer les données analogiques des flexomètres et de rafraichir les 5 valeurs toutes les 1/2 secondes. Cela nous a permis de valider les doigts auxquels sont reliés les différents ports.

Pour la séance suivante, on pense commencer à découvrir Processing, à établir une communication entre Processing et l'ESP32 et commencer à les traiter. 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 :

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 programme d'essai avec 3 données, séparées par des virgules pour les distinguer sur le port COM :

[[image:Capture transmission serie 3 doigts.JPG]]

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 :

[[image:code-AP-wifi.png|500px]]

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 :

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 :

[[image:code_vue_camera.png|500px]]

Grâce à une souris ou un trackpad, nous pouvons orienter le cube selon les axes des abscisses et des ordonnées :

[[image:vue_processing_cube.png|500px]]

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 :
[[image:Code processing 8 avril.jpg|500px]]
[[image:5 Cubes Processing.JPG|600px]]

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 :

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) :

[[image:doigt_processing.png|500px]]

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 :

[[image:main_processing.png|500px]]

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 :

[[image:nouveau_dataglove.JPG|500px]]

Séance 6 :

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 :

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 mon ordinateur portable, au lieu de passer à chaque fois par le PC fixe.

Séance 8 :

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. 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 flexo et de la plaquer sur la piste conductrice à l'aide d'un morceau de scotch. Cette solution semble fonctionner malgré tout. Nous aurions pu utiliser de l'encre conductrice, mais il n'y en avait pas.

Bonus : implémentation du jeu papier, caillou, ciseaux

Ayant respecté tous les besoins minimum du cahier des charges, nous avons décidé d'aller plus loin et d'implémenter le jeu papier, caillou, 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.

Liens :
- explications flexomètres + exemple application : https://learn.sparkfun.com/tutorials/flex-sensor-hookup-guide
- codes exemples processing : http://learningprocessing.com/examples/chp14/example-14-14-rotate-rect1-rect2

2021-05-31T06:31:28Z

Alexandre Oriol :

PAE 2021 Datagloves

2021-05-31T06:31:16Z

Alexandre Oriol :

Fichier:Doigt processing.png

2021-05-31T06:21:24Z

Alexandre Oriol :

PAE 2021 Datagloves

2021-05-31T06:20:25Z

Alexandre Oriol :