Système de traduction langue des signes

Objectif du projet : ce projet propose la mise au point d'une solution technologique de traduction de la langue des signes. Une solution proposée est l'utilisation d'un Data Glove, une autre l'analyse d'images.

État de l'art

Les personnes sourdes et malentendantes font face à de nombreuses difficultés dans notre société; c’est donc pour cela que des systèmes de traduction de la langue des signes ont été en réflexion. Ces systèmes représentent une réponse incontournable pour garantir l'accessibilité universelle à l'information et à la communication. En effet, avec les progrès technologiques rapides de ces dernières décennies, il est devenu impératif de veiller à ce que personne ne soit exclu de la communication en raison de sa surdité ou de sa malentendance. Les langues des signes étant souvent méconnues et mal comprises, ces systèmes de traduction comblent un vide linguistique crucial, permettant ainsi de faciliter les échanges entre les personnes sourdes ou malentendantes et les personnes entendantes.

https://www.lemonde.fr/sciences/article/2024/03/21/un-gant-traducteur-qui-transforme-la-langue-des-signes-en-voix_6223197_1650684.html

Projets suggérés

Voici quelques technologies qui ont été développées :

• Un ensemble composé d'un bracelet et de plusieurs bagues qui peut traduire le langage des signes :

Ce système va analyser les mouvements des mains et des doigts, puis va retransmettre en voix ce que le porteur signe. Son interlocuteur pourra ainsi comprendre ce qu'il dit même s'il ne comprend pas le langage des signes. Le système pourra également détecter les phrases de l'interlocuteur et les traduire sous forme écrite sur le bracelet qui comporte un petit écran.

• My Voice, l’appareil qui traduit la langue des signes en sons:

un groupe d’étudiants de l’Université de Houston, a mis au point un appareil nommé My voice, qui peut traduire la langue des signes en sons et vice-versa. L’appareil tient dans une main. Il comprend un microphone, un haut-parleur, une caméra vidéo et un écran. A l’aide de la caméra vidéo, l’appareil détecte les mouvements de mains pour traduire la langue des signes en sons. Il peut également faire l’inverse en traduisant des paroles en langue des signes grâce à l’affichage sur l’écran.

D'autre part , il y a la technologie '"SignALL" qui est une technologie se reposant sur l’intelligence artificielle et est utilisée pour traduire les langues des signes (ASL, LSF.. multiplicité des langues) dans différentes langues. Cette technologie prend les mouvements de la main grâce à un gant électronique (Data Glove) conçu exprès et analyse ce qui est dit en langue des signes et la caméra pour regarder les expressions du visage. C'est vrai que l'idée du Data glove reste une des meilleurs jusqu'à maintenant , en effet , c'est déjà plus pratique et facile à porter pour la vie quotidienne ainsi que la plus abordable niveau coût 50 dollars Un projet dans lequel L’UE a contribué avec 50 000 euros et le projet a coûté environ 71 500 euros.

D’après CORDIS (le site de la recherche de l’UE), au moins 5% de la population mondiale (466 millions de personnes) souffrent d’une perte auditive incapacitante et 800 000 personnes utilisent la langue des signes pour communiquer dans l’UE.

-> Ces personnes ont donc du mal à s’intégrer pleinement dans la société et nécessitent une solution digne d'être utilisée dans la vie quotidienne .

Les défis à relever

Il est vrai que la réalisation d'un système de traduction de langues de signes fiable et de prix abordable reste un défi et présente des limitations qui soulèvent plusieurs questions et problématiques :

Précision et fiabilité : Les traductions doivent être précises et fiables pour assurer une communication fluide et efficace. Les systèmes actuels peuvent parfois présenter des erreurs de traduction ou des incompréhensions, ce qui peut entraîner des malentendus et des difficultés de communication.

Variabilité linguistique: La langue des signes est riche et diversifiée, avec des variantes régionales et culturelles. Les systèmes de traduction doivent être capables de prendre en compte cette variabilité linguistique pour garantir des traductions adaptées à différents contextes et utilisateurs.

Accessibilité et disponibilité: Les systèmes de traduction de langue des signes doivent être accessibles à tous, quel que soit leur niveau de maîtrise de la langue des signes ou leur accès aux technologies. Il est essentiel de développer des solutions qui soient facilement disponibles et utilisables par le plus grand nombre.

Intégration sociale: Les technologies de traduction de langue des signes ne doivent pas seulement se concentrer sur la traduction linguistique, mais aussi sur l'intégration sociale des personnes sourdes ou malentendantes dans différents contextes, tels que l'éducation, le travail et les interactions sociales.

Malgré les progrès réalisés dans le domaine des systèmes de traduction de langue des signes, il reste encore des défis à relever :

Complexité gestuelle: Les systèmes de traduction doivent être capables de reconnaître et d'interpréter cette complexité gestuelle de manière précise et efficace.

Biais technologique: Les systèmes de traduction de langue des signes sont souvent développés par des personnes entendantes, ce qui peut entraîner des biais culturels et linguistiques dans la conception et l'implémentation de ces systèmes. Il est important de veiller à ce que les perspectives des utilisateurs sourds ou malentendants soient prises en compte dans le processus de développement.

Dépendance technologique: Bien que les technologies de traduction de langue des signes puissent faciliter la communication, elles ne doivent pas remplacer les interactions humaines et l'apprentissage de la langue des signes. Il est essentiel de trouver un équilibre entre l'utilisation des technologies et le maintien des compétences linguistiques et culturelles.

les systèmes de traduction de langue des signes ont le potentiel de transformer la manière dont les personnes sourdes ou malentendantes communiquent avec le monde qui les entoure. Cependant, pour réaliser pleinement ce potentiel, il est nécessaire de relever les défis techniques, linguistiques, culturels et sociaux associés à ces systèmes.

Besoins en matériel

• Flexomètres : capteur électronique qui mesure le taux de flexion ; plus l'angle de flexion est élevé, plus la résistance est grande.
• La carte ESP32 Thing est une carte de développement complète, avec tous les éléments nécessaires pour programmer, exécuter et développer un projet connecté.
• Un câble USB - Micro-USB
• Une breadboard
• Des résistances afin de réaliser des ponts diviseurs de tension
• Des câbles

A la découverte du flexomètre !

Lorsque le capteur subit une flexion, il convertit cette flexion en un signal électrique mesurable, généralement une variation de résistance électrique. Cette variation peut être proportionnelle à la quantité de flexion, permettant ainsi de mesurer avec précision la déformation de l'objet.

On a commencé par mesurer la valeur de résistance aux bords du flexomètre dans les deux cas (on doit faire cela pour chaque flexomètre):

• à plat : R = 10,94 KΩ
• plié : R = 24,14 KΩ
  

Ce qui nous a donné une plage de ΔR = 13,18 KΩ nous permettant de calculer la valeur de résistance optimale pour notre pont diviseur de tension. Après un simple calcul ,la valeur obtenue : R= 16,26 KΩ C'est la résistance dont on aura besoin pour réaliser le protocole avec les flexomètres.

La carte Sparkfun ESP32 Thing

Nous avons choisi de travailler avec la carte ESP32 puisqu'elle fournit les interfaces entrée sortie dont on aura besoin pour notre projet. De plus, étant donnée sa petite taille, elle sera plus pratique pour faire un prototype pratique et elle est compatible avec l'IDE Arduino, un environnement de développement avec lequel il est aisé de développer.

La datasheet de la carte indique que le Convertisseur Analogique Numérique a une résolution de 8bits donc il peut nous afficher une plage de 256 valeurs ce qui est pas mal pour la précision de nos résultats (les valeurs de tension relevées aux bornes du flexomètre).

Après la théorie vient la pratique

On a commencé par réaliser un montage de ponts diviseurs de tension sur une breadboard avec les flexomètres et écrire un code permettant de lire la tension aux bornes des flexomètres sur l'IDE arduino.

Sur l'IDE d'Arduino , on a écrit un code qui affiche la tension aux bornes de chaque flexomètre correspondant à chaque doigt de la main.

Après s'être assurés du bon fonctionnement du montage et du code, on a utilisé des câbles et les avons sécurisé avec des gaines dans pour avoir un prototype le plus fiable possible.

Pour finaliser notre prototype , on a cousu les flexomètres sur un gant pour ensuite attaquer la partie de la traduction de signe.

Vers la traduction

Après avoir été capables de faire des relevés de tension selon la flexion des doigts, vient l'heure de traduire la langue des signes.

• Le premier problème que nous avons rencontré est le fait que pour traduire cette langue, la rotation des mains compte pour certains mots (on aurait pu utiliser un gyromètre).
• Le second problème est le fait que les flexomètres ne fonctionnaient pas tout le temps. En effet, ceux-ci étant très fragiles, malgré un renforcement avec des gaines et une précaution extrême, les valeurs minimales et maximales de certains d'entre eux ont variées.

Afin de traduire la langue des signes, il y a différentes solutions:

• Faire une interface graphique affichant une main et les mouvements réalisés par l'utilisateur afin que ceux-ci soient traduits par un traducteur.
• Prendre la combinaison des différentes positions des doigts afin de demander à une intelligence artificielle de réaliser la traduction.
• Mettre chaque lettre de l'alphabet dans un tableau en fonction des combinaisons nécessaires et faire des opérations de comparaison à chaque fois.

La deuxième solution était celle que l'on avait retenue, mais nous n'avons pas eu le temps d'étudier les requêtes HTTP avec le module associé à la carte Sparkfun ESP32 Thing, donc nous n'avons pas été capables d'aller très loin.

On aurait utilisé l'API d'OpenAI afin de faire des requêtes demandant à l'intelligence artificielle de traduire les combinaisons via une requête GET à l'endpoint "/v1/chat/completions*".

Entre temps, nous avons réalisé une modélisation 3D de la main à l'aide de l'IDE Processing.

• Voici le code processing utilisé:

import processing.serial.*;

//GLOBAL VARIABLES:

//Palm size int palmSizeX = 200; int palmSizeY = 250; int palmSizeZ = 50;

//Phalanges size int phalangeSizeX = 50; int phalangeSizeZ = 50;

int phalangeSizeYThumb = 60; int phalangeSizeYIndex = 50; int phalangeSizeYMiddle = 60; int phalangeSizeYRing = 50; int phalangeSizeYLittle = 40;

//Fingers values //Thumb float fingerThumb; //Index float fingerIndex; //Middle float fingerMiddle; //Ring float fingerRing; //Little float fingerLittle;

////Thumb //float fingerThumb = 2000; ////Index Finger //float fingerIndex = 2000; ////Middle Finger //float fingerMiddle = 1000; ////Ring Finger //float fingerRing = 2000; ////Little Finger //float fingerLittle = 2000;

//Fingers Max/Min/Mid float fingerThumbMin = 1.24; float fingerIndexMin = 1510; float fingerMiddleMin = 1.5; float fingerRingMin = 1.17; float fingerLittleMin = 2960;

float fingerThumbMax = 1.92; float fingerIndexMax = 2680; float fingerMiddleMax = 2.1; float fingerRingMax = 2.06; float fingerLittleMax = 3260;

float midThumb = (fingerThumbMax + fingerThumbMin) / 2; float midIndex = (fingerIndexMax + fingerIndexMin) / 2; float midMiddle = (fingerMiddleMax + fingerMiddleMin) / 2; float midRing = (fingerRingMax + fingerRingMin) / 2; float midLittle = (fingerLittleMax + fingerLittleMin) / 2;

//float fingerThumbMin = 1000; //float fingerIndexMin = 1000; //float fingerMiddleMin = 1000; //float fingerRingMin = 1000; //float fingerLittleMin = 1000;

//float fingerThumbMax = 2000; //float fingerIndexMax = 2000; //float fingerMiddleMax = 2000; //float fingerRingMax = 2000; //float fingerLittleMax = 2000;

//Fingers Angles float angleLittle; float angleRing; float angleMiddle; float angleIndex; float angleThumb;

//Screen Rotation float screenRotation=45;

//Serial Port Serial myPort;

//Transmitted data String transmittedData;

//Values stockage float values[];

void setup() {

 myPort  =  new Serial (this, "COM8",  115200);
 myPort.bufferUntil ('\n');
 
 size(600, 700, P3D);
 textAlign(CENTER, CENTER);
 rectMode(CENTER);

}

//Reading data from the serial port void serialEvent(Serial myPort) {

 transmittedData  = myPort.readStringUntil( '\n' )  ;

 if (transmittedData != null)
 {
   transmittedData = trim(transmittedData);
   values = float(split(transmittedData, ','));

   for (int i = 0; i < 5; i++)
   {
     print(values[i] + ",");
   }
   
   fingerThumb = values[0];
   fingerRing = values[1];
   fingerMiddle = values[2];
   //fingerRing = values[3];
   //fingerLittle = values[4];
   println();
   }

}

void draw() {

 background(0);
 stroke(100);
 strokeWeight(2);
 fill(245, 183, 177);
 
 //Calculation of angles between the phalanges
 angleThumb = map(fingerThumb, fingerThumbMax, fingerThumbMin, PI/4, 0);
 angleIndex = map(fingerIndex, fingerIndexMax, fingerIndexMin, PI/2, 0);
 angleMiddle = map(fingerMiddle, fingerMiddleMax, fingerMiddleMin, PI/2, 0);
 angleRing = map(fingerRing, fingerRingMax, fingerRingMin, PI/2, 0);
 angleLittle = map(fingerLittle, fingerLittleMax, fingerLittleMin, PI/2, 0);
 
 pushMatrix();

 //Screen management 
 screenRotation = map(mouseX,0,width,-180,180);

 translate(width/2, height * 7/12); 
 rotateY(radians(screenRotation));

 //Drawing of the hand
 //Palm
 box(palmSizeX,palmSizeY,palmSizeZ);
   
 float phalangeThumb1X = modelX(-palmSizeX/2 + phalangeSizeX * 9/2, -palmSizeY/2 - phalangeSizeYThumb + palmSizeY/2, -palmSizeZ/2);
 float phalangeThumb1Y = modelY(-palmSizeX/2 + phalangeSizeX * 9/2, -palmSizeY/2 - phalangeSizeYThumb + palmSizeY/2, -palmSizeZ/2);
 float phalangeThumb1Z = modelZ(-palmSizeX/2 + phalangeSizeX * 9/2, -palmSizeY/2 - phalangeSizeYThumb + palmSizeY/2, -palmSizeZ/2);
 
 float phalangeIndex1X = modelX(-palmSizeX/2 + phalangeSizeX * 7/2, -palmSizeY/2 - phalangeSizeYIndex/2, -palmSizeZ/2);
 float phalangeIndex1Y = modelY(-palmSizeX/2 + phalangeSizeX * 7/2, -palmSizeY/2 - phalangeSizeYIndex/2, -palmSizeZ/2);
 float phalangeIndex1Z = modelZ(-palmSizeX/2 + phalangeSizeX * 7/2, -palmSizeY/2 - phalangeSizeYIndex/2, -palmSizeZ/2);
 
 float phalangeMiddle1X = modelX(-palmSizeX/2 + phalangeSizeX * 5/2, -palmSizeY/2 - phalangeSizeYMiddle/2, -palmSizeZ/2);
 float phalangeMiddle1Y = modelY(-palmSizeX/2 + phalangeSizeX * 5/2, -palmSizeY/2 - phalangeSizeYMiddle/2, -palmSizeZ/2);
 float phalangeMiddle1Z = modelZ(-palmSizeX/2 + phalangeSizeX * 5/2, -palmSizeY/2 - phalangeSizeYMiddle/2, -palmSizeZ/2);
 
 float phalangeRing1X = modelX(-palmSizeX/2 + phalangeSizeX * 3/2, -palmSizeY/2 - phalangeSizeYRing/2, -palmSizeZ/2);
 float phalangeRing1Y = modelY(-palmSizeX/2 + phalangeSizeX * 3/2, -palmSizeY/2 - phalangeSizeYRing/2, -palmSizeZ/2);
 float phalangeRing1Z = modelZ(-palmSizeX/2 + phalangeSizeX * 3/2, -palmSizeY/2 - phalangeSizeYRing/2, -palmSizeZ/2);
 
 float phalangeLittle1X = modelX(-palmSizeX/2 + phalangeSizeX/2, -palmSizeY/2 - phalangeSizeYLittle/2, -palmSizeZ/2);
 float phalangeLittle1Y = modelY(-palmSizeX/2 + phalangeSizeX/2, -palmSizeY/2 - phalangeSizeYLittle/2, -palmSizeZ/2);
 float phalangeLittle1Z = modelZ(-palmSizeX/2 + phalangeSizeX/2, -palmSizeY/2 - phalangeSizeYLittle/2, -palmSizeZ/2);
 
 popMatrix();
 
 
 //Thumb1
 pushMatrix();
 translate(phalangeThumb1X, phalangeThumb1Y, phalangeThumb1Z);
 rotateY(radians(screenRotation));
 rotateY(angleThumb);
 rotateX(angleThumb);
 box(phalangeSizeX,phalangeSizeYThumb,phalangeSizeZ);
 
 float phalangeThumb2X = modelX(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYThumb/2 - phalangeSizeYThumb/2, -phalangeSizeZ/2);
 float phalangeThumb2Y = modelY(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYThumb/2 - phalangeSizeYThumb/2, -phalangeSizeZ/2);
 float phalangeThumb2Z = modelZ(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYThumb/2 - phalangeSizeYThumb/2, -phalangeSizeZ/2);
 popMatrix();
 
 //Index1
 pushMatrix();
 translate(phalangeIndex1X, phalangeIndex1Y, phalangeIndex1Z);
 rotateY(radians(screenRotation));
 rotateX(angleIndex);
 box(phalangeSizeX,phalangeSizeYIndex,phalangeSizeZ);
 
 float phalangeIndex2X = modelX(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYIndex/2 - phalangeSizeYIndex/2, -phalangeSizeZ/2);
 float phalangeIndex2Y = modelY(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYIndex/2 - phalangeSizeYIndex/2, -phalangeSizeZ/2);
 float phalangeIndex2Z = modelZ(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYIndex/2 - phalangeSizeYIndex/2, -phalangeSizeZ/2);
 popMatrix();
 
 //Middle1
 pushMatrix();
 translate(phalangeMiddle1X, phalangeMiddle1Y, phalangeMiddle1Z);
 rotateY(radians(screenRotation));
 rotateX(angleMiddle);
 box(phalangeSizeX,phalangeSizeYMiddle,phalangeSizeZ);
 
 float phalangeMiddle2X = modelX(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYMiddle/2 - phalangeSizeYMiddle/2, -phalangeSizeZ/2);
 float phalangeMiddle2Y = modelY(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYMiddle/2 - phalangeSizeYMiddle/2, -phalangeSizeZ/2);
 float phalangeMiddle2Z = modelZ(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYMiddle/2 - phalangeSizeYMiddle/2, -phalangeSizeZ/2);
 popMatrix();
 
 //Ring1
 pushMatrix();
 translate(phalangeRing1X, phalangeRing1Y, phalangeRing1Z);
 rotateY(radians(screenRotation));
 rotateX(angleRing);
 box(phalangeSizeX,phalangeSizeYRing,phalangeSizeZ);
 
 float phalangeRing2X = modelX(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYRing/2 - phalangeSizeYRing/2, -phalangeSizeZ/2);
 float phalangeRing2Y = modelY(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYRing/2 - phalangeSizeYRing/2, -phalangeSizeZ/2);
 float phalangeRing2Z = modelZ(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYRing/2 - phalangeSizeYRing/2, -phalangeSizeZ/2);
 popMatrix();
 
 //Little1
 pushMatrix();
 translate(phalangeLittle1X, phalangeLittle1Y, phalangeLittle1Z);
 rotateY(radians(screenRotation));
 rotateX(angleLittle);
 box(phalangeSizeX,phalangeSizeYLittle,phalangeSizeZ);
 
 float phalangeLittle2X = modelX(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYLittle/2 - phalangeSizeYLittle/2, -phalangeSizeZ/2);
 float phalangeLittle2Y = modelY(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYLittle/2 - phalangeSizeYLittle/2, -phalangeSizeZ/2);
 float phalangeLittle2Z = modelZ(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYLittle/2 - phalangeSizeYLittle/2, -phalangeSizeZ/2);
 popMatrix();
 
 
 //Thumb2
 pushMatrix();
 translate(phalangeThumb2X, phalangeThumb2Y, phalangeThumb2Z);
 rotateY(radians(screenRotation));
 rotateY(2 * angleThumb);
 rotateX(2 * angleThumb);
 box(phalangeSizeX,phalangeSizeYThumb,phalangeSizeZ);
 popMatrix();
 
 //Index2
 pushMatrix();
 translate(phalangeIndex2X, phalangeIndex2Y, phalangeIndex2Z);
 rotateY(radians(screenRotation));
 rotateX(2 * angleIndex);
 box(phalangeSizeX,phalangeSizeYIndex,phalangeSizeZ);
 
 float phalangeIndex3X = modelX(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYIndex/2 - phalangeSizeYIndex/2, -phalangeSizeZ/2);
 float phalangeIndex3Y = modelY(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYIndex/2 - phalangeSizeYIndex/2, -phalangeSizeZ/2);
 float phalangeIndex3Z = modelZ(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYIndex/2 - phalangeSizeYIndex/2, -phalangeSizeZ/2);
 popMatrix();
 
 //Middle2
 pushMatrix();
 translate(phalangeMiddle2X, phalangeMiddle2Y, phalangeMiddle2Z);
 rotateY(radians(screenRotation));
 rotateX(2 * angleMiddle);
 box(phalangeSizeX,phalangeSizeYMiddle,phalangeSizeZ);
 
 float phalangeMiddle3X = modelX(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYMiddle/2 - phalangeSizeYMiddle/2, -phalangeSizeZ/2);
 float phalangeMiddle3Y = modelY(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYMiddle/2 - phalangeSizeYMiddle/2, -phalangeSizeZ/2);
 float phalangeMiddle3Z = modelZ(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYMiddle/2 - phalangeSizeYMiddle/2, -phalangeSizeZ/2);
 popMatrix();
 
 //Ring2
 pushMatrix();
 translate(phalangeRing2X, phalangeRing2Y, phalangeRing2Z);
 rotateY(radians(screenRotation));
 rotateX(2 * angleRing);
 box(phalangeSizeX,phalangeSizeYRing,phalangeSizeZ);
 
 float phalangeRing3X = modelX(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYRing/2 - phalangeSizeYRing/2, -phalangeSizeZ/2);
 float phalangeRing3Y = modelY(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYRing/2 - phalangeSizeYRing/2, -phalangeSizeZ/2);
 float phalangeRing3Z = modelZ(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYRing/2 - phalangeSizeYRing/2, -phalangeSizeZ/2);
 popMatrix();
 
 //Little2
 pushMatrix();
 translate(phalangeLittle2X, phalangeLittle2Y, phalangeLittle2Z);
 rotateY(radians(screenRotation));
 rotateX(2 * angleLittle);
 box(phalangeSizeX,phalangeSizeYLittle,phalangeSizeZ);
 
 float phalangeLittle3X = modelX(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYLittle/2 - phalangeSizeYLittle/2, -phalangeSizeZ/2);
 float phalangeLittle3Y = modelY(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYLittle/2 - phalangeSizeYLittle/2, -phalangeSizeZ/2);
 float phalangeLittle3Z = modelZ(-phalangeSizeX/2 + phalangeSizeX/2, -phalangeSizeYLittle/2 - phalangeSizeYLittle/2, -phalangeSizeZ/2);
 popMatrix();
   
 //Index3
 pushMatrix();
 translate(phalangeIndex3X, phalangeIndex3Y, phalangeIndex3Z);
 rotateY(radians(screenRotation));
 rotateX(3 * angleIndex);
 box(phalangeSizeX,phalangeSizeYIndex,phalangeSizeZ);
 popMatrix();
 
 //Middle3
 pushMatrix();
 translate(phalangeMiddle3X, phalangeMiddle3Y, phalangeMiddle3Z);
 rotateY(radians(screenRotation));
 rotateX(3 * angleMiddle);
 box(phalangeSizeX,phalangeSizeYMiddle,phalangeSizeZ);
 popMatrix();
 
 //Ring3
 pushMatrix();
 translate(phalangeRing3X, phalangeRing3Y, phalangeRing3Z);
 rotateY(radians(screenRotation));
 rotateX(3 * angleRing);
 box(phalangeSizeX,phalangeSizeYRing,phalangeSizeZ);
 popMatrix();
 
 //Little3
 pushMatrix();
 translate(phalangeLittle3X, phalangeLittle3Y, phalangeLittle3Z);
 rotateY(radians(screenRotation));
 rotateX(3 * angleLittle);
 box(phalangeSizeX,phalangeSizeYLittle,phalangeSizeZ);
 popMatrix();
 
 //Special positions
 //Scissors
 textSize(30);
 if(fingerThumb <= fingerThumbMax - 0.3)
 {
   text("A", width/2, height - 50);
 }

}

Bibliographie

https://www.sparkfun.com/products/13907
https://learn.sparkfun.com/tutorials/esp32-thing-hookup-guide/all
https://processing.org/reference
https://www.cypris.fr/solidarite/LSF.pdf
https://en.wikipedia.org/wiki/French_Sign_Language
https://en.wikipedia.org/wiki/Sign_language

Faire une reconstruction (simpliste) de notre projet

• Tout d'abord, il va falloir mesurer la valeur minimale et la valeur maximale (flexomètre plié au maximum) de chaque flexomètre.
• Puis, il faut réaliser un pont diviseur de tension avec une résistance R et le flexomètre puis mettre en équation ce pont diviseur de tension.

• Ensuite, il faut mettre en équation ΔV qui est la différence entre la tension du pont diviseur de tension avec le flexomètre plié (R2) et la tension du pont diviseur de tension avec le flexomètre déplié (R1).
• Dériver cette équation par rapport à R afin de trouver la valeur optimale de R (on calcule R tel que dV/dR = 0). Dans notre projet, nous avons trouvé R = sqrt(R1*R2).
• Pour la mise en pratique: il faut mettre une carte Sparkfun ESP32 Thing sur une breadboard et réaliser les câblages que l'on voit sur le schéma et utiliser les codes qui sont ci-dessous.