2021-L3-Galilee- Semelle - Intelligente

Dans le cadre du projet de IOT 2020, nous avons décidé de concevoir un prototype qui permet de constater la présence d’une asymétrie au niveau du corps humain, en particulier au niveau de la longueur des jambes.
Le projet intitulé "Semelle Intelligente" est un système évolué de la balance baropodométrique. En se servant de la carte Arduino et de deux capteurs FSR402, le prototype "Semelle Intelligente" permet d’enregistrer les pressions exercées par les deux jambes.
L'analyse de ces données démontre la présence ou l'absence d'une éventuelle asymétrie.

Slides & Videos

Members

NameContribution
Ayoub Hayari- Code
- Soutenance
- Montage Hardware
- Calibration
- Commande Matériaux
- Branchement
- Montage Vidéo
- Rapport
- Soutenance
Sambou Keita- Code
- Soutenance
- Montage Hardware
- Calibration
- Commande Matériaux
- Branchement
- Montage Vidéo
- Rapport
- Soutenance

State of the Art

Business Aspect

RUNVI

 

A l’intérieur des semelles, il y a 30 capteurs de pression, deux accéléromètres et une batterie bonne pour 8 à 10 heures de course. Ce produit sert à donner à l’utilisateur des conseils et des programmes adaptés en analysant sa course et sa posture.

On voit sur La deuxième montre en partant du gauche les plantes des pieds avec différentes couleurs,  cette montre est connecté aux semelles. Grâce aux capteurs de pression on découvre la présence d’irrégularité au niveau des jambes. En effet si une jambe est plus longue que l’autre, elle sera distinguée par une couleur  rouge plus foncée.

Prix : 199 €

W-INSHOE EASY

 

Ce produit est adapté à l’étude des pressions du pied. Il est le partenaire idéal pour faciliter les diagnostics, corriger et améliorer la marche de nombreux patients, optimiser les performances chez le sportif ou mesurer l’incidence des semelles en conditions réelles.

Prix :  une centaine d’euros (indisponible sur le site).

 

WIN-POD WIFI

 

Ce produit est un produit pour les podologues et sa disponibilité n’est réservée que pour eux. Mais c’est l’outil parfait pour les examens des pieds.

Prix : indisponible sur le site, mais il a un prix assez élevé.

Technical Aspect

RUNVI

   

  • 30 capteurs de pression
  • 2 accéléromètres
  • Batterie  pour  une durée  de 8 à 10 heures de course
  • Analyse détaillée de vos performances de course
  • Contenu et procédures individuels basés sur les performances
  • Accès à notre Running Academy rédigée par des experts
  • Paramètres d’objectifs personnels pour les plans d’entraînement individuels
  • Live-View pour un contrôle total et une optimisation en temps réel
  • Intégration avec Apple Healthkit, Strava, Garmin
  • Importez et exportez vos données de performances historiques
  • Disponible sur iPhone SE, 6 – iPhone X, iOS 11+, Apple Watch Series 2-3

W-INSHOE EASY

 

Caractéristiques mécaniques
Taille (longueur / largeur / hauteur) 65* 46,5 * 18,3 mm
Poids 50 g
Caractéristiques électroniques
Surface active 35 mm x 20 mm
Capteurs Résistifs HD calibrés
Épaisseur du capteur 0,5 mm
Nombre de capteurs 8 capteurs / boîtier
Pression mini/maxi par capteur de 0,1 KgF à 8 kgF
Fréquence d’acquisition 100 images / seconde
Type d’interface PC / Plateforme Bluetooth
Alimentation Secteur / USB
Système d’exploitation requis Seven, 8, 10 / Android 5 mini pour smarphone

WIN-POD WIFI

Caractéristiques mécaniques
Taille (longueur / largeur / hauteur) 530* 610 * 25 mm
Poids 6,8 kg
Caractéristiques électroniques
Surface active 400 x 400 mm
Capteurs Résistifs calibrés
Épaisseur du capteur 8 x 8 mm
Nombre de capteurs 2304 soit 48 x 48
Pression mini/maxi par capteur de 0,4 N à 100 N
Fréquence d’acquisition 200/300 images / seconde
Type d’interface PC / Plateforme USB et WIFI
Alimentation USB ou btterie
Système d’exploitation requis Seven, 8, 10

Project Description

Problem Definition
Selon l'écrivain Jacques Bénigne Bossuet "la santé dépend plus des précautions que des médecins". Grace aux objets connectés "IOT" cette citation peut facilement être mise en pratique.
En effet les gens peuvent s’auto-consulter à l’aide de ces objets.

Challenges & Motivation
Dans le cadre du projet de IOT 2020, nous avons décidé de concevoir un prototype qui permet de constater la présence d’une
asymétrie au niveau du corps humain, en particulier au niveau de la longueur des jambes.

Après avoir discuté avec nos professeurs à propos des projets à réaliser, ils nous ont orientés vers le domaine de la santé.
ayant tous les deux (moi et mon binome ) eu une expérience avec des douleurs dorsales, Nous avons opté pour ce projet.
En plus on voulait changer des projets qui se répétent.
Real and Complete Usecases

Diagramme de cas d’utilisation

Cas posture correcte

Vu l’impossibilité de trouver des capteurs qui ont une capacité de 100 kg, nous avons acheté des capteurs à 30kg, nous avons simulé le corps humain ne dépassant pas 30kg par un haltère. Sur la figure ci-dessous, en partant de gauche à droite , la jambe gauche est représenté par le disque gauche et la jambe droite par le disque droit et le bassin par la barre entre les 2 poids. On peut générer le déséquilibre en inclinant l’un des deux disques.

Dans ce cas nous gardons les disques parfaitement parallèles sans aucune inclinaison.

Sur l’interface graphique Processing on obtient l’image des deux pieds avec la même distribution de la couleur rouge, nous indiquant ainsi qu’il n’y a aucun problème de posture, car la pression est uniforme.

 

 

 

Cas posture incorrecte

 

Dans ce cas on a incliné le disque droit pour simuler le déséquilibre. Comme l’illustre la figure obtenue sur l’interface graphique Processing, l’ellipse du pied droit est plus allongé que celle représentant le pied gauche. Ceci confirme que la position est incorrecte car le poids est mal distribué, et les capteurs ont pu le constater.

 

 

Technical Description

 

Tout d’abord, l’acteur lance le programme Arduino avec la vérification et le téléversement du code sur Arduino IDE, ensuite nous initialisons une communication série entre Arduino et Processing nécessitant la bibliothèque “processing.serial.*” ou la Transmission des données sur le port Serial se fait à une vitesse de 9600 bits par seconde.

De plus, l’accès au port Serial (COM3) est réservé à Processing lui permettant de lire les valeurs analogiques.

La carte Arduino effectue une connexion matérielle avec les 2 capteurs de pression avec un pin connecté au 5V et l’autre au GND relier par une résistance de 10k permettant une meilleure précision lors de l’appui plantaire.

Ensuite depuis les capteurs de pression les variations de tension sont lues par l’Arduino, puis le Tarage s’effectue par la mise à zéro de la valeur de pression prenant en compte le poids des semelles.

Suite à l’appui plantaire sur les capteurs de pression l’Arduino va de nouveau lire en boucle les variations de tension qui vont être analysées et converties.

Le calcul s’effectue d’abord par l’affectation de la valeur analogique (0 – 1023) dans une variable puis le calcul de la variable résistance par rapport au voltage de 5V la valeur analogique et la valeur des 10k de la résistance.

Ensuite on calcule la conductance qui est donnée par le rapport de 1’000’000 et la valeur de résistance. Puis on calcule la force qui est donnée par la variable de conductance divisée par une constante (80 dans notre cas) et multipliée par une constante (19,5 dans notre cas) nous permettant d’obtenir la force en Newton.

Enfin pour obtenir la valeur en kilogramme il suffit de diviser la force par la valeur de pesanteur (9.81) , tout cela en vérifiant la valeur d’un poids de 1 kilo.

Ces données sont ensuite envoyées vers Processing pour un affichage graphique des résultats en temps réel via une interface graphique codée en Java.

     

Hardware

Materials
ImageNamePart NumberPriceCountLink
Capteur FSR 402MD30-6010,39 €2🛒
Arduino Uno84057724,20 €1🛒
Semelles/7,99 €1🛒
Schematic

Software

Arduino Code

const int sensorPin = A0;    // pin A0 associer au senseur fsr 1
const int sensorPin2 = A1;    // pin A1 associer au senseur fsr 2

// variables:
float sensorValue = 0;         // valeur du senseur fsr 1
float sensorValue2 = 0;         // vameur du senseur fsr 2

int sensorMin = 1023;        // valeur minimal des senseurs
int sensorMax = 0;           // valeur maximal des senseurs 
int sensorMax2 = 0;
  
int voltage; // valeur analogique converti en voltage
float resistance; // voltage converti en resistance
float  conductance; 
float force; // resistance converti en force (Newton)
float poids; // force converti en poids (kg)

int voltage2; // valeur analogique converti en voltage
float resistance2;  // voltage converti en resistance
float  conductance2; 
float force2; // resistance converti en force (Newton)
float poids2; // force converti en poids (kg)

void setup()
{
  Serial.begin(9600);
  pinMode(sensorPin, INPUT);  
  pinMode(sensorPin2, INPUT);


  // calibrate during the first five seconds
  while (millis() < 5000) {
    sensorValue = analogRead(sensorPin);
    sensorValue2 = analogRead(sensorPin2);
   
  }

}

void loop() {


  
  // lecture analogique des senseurs
  sensorValue = analogRead(sensorPin);
  sensorValue2 = analogRead(sensorPin2);

// Callibration du senseur
  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 1023);
  sensorValue2 = map(sensorValue2, sensorMin, sensorMax, 0, 1023);
  
  // Range de la valeur sensorValue lors de la callibration
  sensorValue = constrain(sensorValue, 0, 1023);
  sensorValue2 = constrain(sensorValue2, 0, 1023);

    //Serial.println("---------------------------------  CAPTEUR1  -----------------------------");


    voltage = map(sensorValue, 0, 1023, 0, 5000);
    //Serial.println("voltage");
    //Serial.println(voltage);
    //Serial.println();
      
    // voltage = Vcc * R / (R + FSR) ou R = 10K et Vcc = 5V
    // FSR = ( (Vcc - V) * R) / V
    // Voltage est en millivolts 5V = 5000mV
    resistance = 5000 - voltage;     
    resistance *= 10000; // 10K resistance
    resistance /= voltage; // FSR resistance en ohms.
    //Serial.println("resistance");
    //Serial.println(resistance);
    //Serial.println();
  
    conductance = 1000000; //mesure en (ohms).
    conductance /= resistance;
    //Serial.println("conductance");
    //Serial.println(conductance);
    //Serial.println();
   
    force = conductance / 80;
    force *= 19.5;
    //Serial.println("newton");
    //Serial.println(force);
    //Serial.println();
    
    poids = force / 9,81;
    //Serial.println("kg");
    Serial.println(poids);
    //Serial.println();

/****************/
  //  Serial.println("---------------------------------  CAPTEUR2  -----------------------------");
    //Serial.println("Analog2");
    //Serial.println(sensorValue2);
    //Serial.println();
  // calibration du capteur senseur
  
    voltage2 = map(sensorValue2, 0, 1023, 0, 5000);
    //Serial.println("voltage2");
    //Serial.println(voltage2);
    //Serial.println();
    
    resistance2 = 5000 - voltage2;     
    resistance2 *= 10000; // 10K resistance 
    resistance2 /= voltage2; // FSR resistance en ohms.
    //Serial.println("resistance2");
    //Serial.println(resistance2);
    //Serial.println();
    
    conductance2 = 1000000; //Mesure en (ohms).
    conductance2 /= resistance2;
    //Serial.println("conductance2");
    //Serial.println(conductance2);
   // Serial.println();

    force2 = conductance2 / 80;
    force2 *= 19.5;
    //Serial.println("newton2");
    //Serial.println(force2);
   // Serial.println();

    poids2 = force2 / 9,81;
    //Serial.println("kg");
    Serial.println(poids2);
   // Serial.println();
    
  delay(500);
}
Import processing.serial.*;

Serial port; // le port serial
String serial;
float val;
int bval;
float val2;
int bval2;
PImage F;
int end = 10;
int count=0;
String sb ;

int[] sensorValues;
float tps;
void setup(){
  size(900,900);
  frameRate(30);
  
  
  port = new Serial(this, "COM3", 9600);

  F = loadImage("Pied2.jpg");
  
  
}

void draw(){
  noCursor();
  tps = millis();
   if ( tps < 4000) {
    background(100);
    textSize(24);
    fill(255);
    textAlign(CENTER);
    text("ADOPTER UNE POSE LA PLUS NATUREL POSSIBLE", 900/2, 700/2);
  }
  else{
     background(F); 
  
  while(port.available() > 0){
    
      
    sb = port.readStringUntil(end);
    
    
      if(sb != null){
    if(count%2 == 1){
      println("pied droit");
      print(sb);
      println("kg");
  
        val = float(sb);
        bval = int(val);
      }
    
     else{
          println("pied gauche");
          print(sb);
          println("kg");
          val2 = float(sb);
          bval2 = int(val2);
        }
    
     count ++; 
  }
 }
  
 
  fill(bval2*200, 0, 0);
   
  ellipse(170*2, 750, 120+bval2*10, 120+bval2*50);
  fill(bval*200, 0, 0);

  ellipse(280*2, 750, 120+bval*10, 120+bval*50);
  }
}

External Services