Smart Jogging : capture de trajectoire des pieds pour les joggers

De fablab
Aller à : navigation, rechercher

Informations générales

Encadrants: Rémi Pincent, Vivien Quéma

Ce projet est pour des groupes de 2 à 4 étudiants.

Contexte

Ce projet vise à créer un dispositif intelligent pour les adeptes du jogging. L'un des paramètres importants pour les joggers est d'avoir une foulée efficace. En particulier, il est important que les joggers attaquent le sol par la partie avant du pied et non par le talon. Par ailleurs, la trajectoire que suit le pied quand il n'est pas au sol doit vérifier certaines propriétés (voir par exemple : lien).

Sujet

Les étudiants développeront un dispositif permettant de capter la trajectoire de la foulée d'un jogger. Pour ce faire, les étudiants s'appuieront sur un capteur existant (lien). Dans un premier temps, l'acquisition des données de la centrale inertielle sera faite sur une carte SD pour un post traitement utilisant sensbiotk. Les étudiants implémenteront un algorithme ainsi qu'une interface graphique permettant de reconnaître les défauts de la foulée du coureur et de donner des conseils pour l'améliorer. Durant une seconde phase, tout ou partie de l'algorithme de détection de défaut de la foulée du coureur sera porté sur un autre capteur communiquant en Bluetooth LE afin d'avoir un traitement des données en temps réel et ainsi permettre au coureur de découvrir ses défauts lors de l'exercice.

Compétences qui seront acquises / mises en oeuvre

  • programmation python
  • programmation sur Cortex M3
  • programmation android / python / Nodejs pour la communication Bluetooth LE
  • algorithmes de detection de mouvement utilisant les données d'une/plusieurs centrale inertielle

Travail réalisé

Etudiants : Cyril Bonaccini, Anir El Kabiri, Eloïse Julien

Encadrant : Jérôme Maisonnasse

Présentation

Nous avons réalisé une application pour la course à pied du même genre que l'application Runtastic. En comparaison avec ces applications nous avons rajouté l'utilisation des capteurs SensorTag de Texas Instruments. L'application donne à l'utilisateur la possibilité d'enregistrer des entrainements avec comme données, la vitesse, le parcours, la durée, la fréquence de pas...

Conception de l'application

En début de projet nous avons réaliser un prototype de notre application à l'aide du site marvalapp. Cela nous a permis de visualiser ce que nous voulions implémenter. Le rendu est proche du prototype de départ sauf pour ce qui concerne la charte graphique.

L'application est composé de plusieurs pages :

  • Authentification : Elle permet de se connecter à son compte personnel avec un email et un mot de passe. Les comptes sont sauvegardés dans la base de donnée interne du téléphone. On ne peut pas récupérer ses données sur un autre téléphone.
Connexion.png
  • Créer un nouveau profil : La création d'un nouveau profil demande de remplir des données (email, mot de passe, nom, prénom...)
  • Accueil : Sur cette page on retrouve un résumé du dernier entrainement ainsi qu'un bouton permettant de démarrer un nouveau entrainement.
  • Entraînement : Permet la connexion avec le capteur. On retrouve aussi une carte suivant le parcours lors de l'entraînement ainsi que la vitesse et la durée de l'entraînement. Il y a aussi des boutons permettant le démarrage, l'arrêt ou la mise en pause de l'entraînement. Lors de l'arrêt de l'entraînement, une page de dialogue apparait permettant de rentrer un nom, un commentaire et une note avant de sauvegarder l'entraînement.
Training.jpg
  • Historique : Correspond à une liste de tous les entraînements enregistrés. Pour chaque entraînement on a accès par exemple à une sauvegarde du parcours ainsi que des graphiques montrant l'évolution de la vitesse et de l'altitude.
  • Modifier Profil : Il est possible de modifier certaines informations du comptes comme par exemple le mot de passe, le poids ou la taille.

Capteur TI Sensortag CC2650

Le capteur utilisé est un capteur TI Sensortag CC2650
SensorTag-CC2650.jpg

Le Sensortag joue le rôle d’observateur surveillant la publications de données de plusieurs dispositifs de broadcast (les capteurs). C'est tout l'idée de la technologie BLE qui est principalement construite autour du profil d'attribut générique (GATT), ce profil définit une approche structurelle de la façon dont les périphériques exposent leurs données à d'autres périphériques.

Le GATT est basé sur le protocole d'attribut (ATT) qui utilise les données du GATT pour définir la manière dont deux appareils Bluetooth Low Energy envoient et reçoivent des messages standard.

Les informations sont organisées comme une collection de services décrivant les fonctions logiques de l'appareil comme l'accéléromètre dans notre cas.

Les services sont des ensembles de caractéristiques et de relations avec d'autres services qui encapsulent le comportement d'une partie d'un périphérique. Cela inclut également la hiérarchie des services, des caractéristiques et des attributs utilisés dans le serveur d'attributs.

Profile-gatt.jpg

Chaque service a ses propres caractéristiques pour transférer des valeurs de données discrètes entre les périphériques. Une caractéristique peut représenter une donnée de service ou des données de configuration

Les caractéristiques ont une valeur et des flags de propriétés et ils peuvent avoir en plus des descripteurs qui permettent la configurations de valeurs spécifiques ou bien une indications du type d’usage.

Framework Android pour le capteur

Il y a tout un framework disponible sur Android Studio pour se connecter au capteur via BLE et retirer les données des fonctions logiques comme l’accélération dans notre cas.

Il faudra implémenter l'interface "BluetoothAdapter.LeScanCallback". Et les classes qui forment ce framework sont : BluetoothManager, BluetoothAdapter, BluetoothDevice, BluetoothProfile, BluetoothGatt, BluetoothGattCallback, BluetoothGattCharacteristic, BluetoothGattDescriptor.

Lorsqu'on se connecte au capteur et plus précisément lorsqu'on active le service d'accélération, on utilise Handler qui va recevoir les requêtes de l'accéléromètre et par suite va mettre à jour la valeur que nous retourne le capteur.

Nous obtenons du service de mouvement une charactéristique qui sur laquelle on doit faire quelques opérations afin d'avoir la vraie accélération en fonction de la constante de gravitation.

Tout d'abord il faut activer le service contenant le gyroscope, le magnétomètre et l'accéléromètre, puis il faudra obtenir la caractéristique du mouvement et la régler à la valeur suivante par la ligne de code :

    characteristic.setValue(new byte[] {0x7F,0x00});

Et enfin il faut extraire les données de capteur et les mettre à jour:

    private void updateAccelerationValues(BluetoothGattCharacteristic characteristic){
       
       byte[] value = characteristic.getValue();
       // Range 8g
       final float SCALE = (float) 4096.0;
       // Pour avoir les accélérations suivant les 3 axes on fait les calculs suivants :
       int x = (value[7]<<8) + value[6];
       float acceleration_x =  (x / SCALE)*(-1);
       int y = (value[9]<<8) + value[8];
       float acceleration_y = y / SCALE;
       int z = (value[11]<<8) + value[10];
       float acceleration_z = (z / SCALE)*(-1);
    }

Les UUIDS du service de mouvement sont :

   public final static UUID
           MOVEMENT_SERVICE = fromString("f000aa80-0451-4000-b000-000000000000"),
           MOVEMENT_DATA_CHAR = fromString("f000aa81-0451-4000-b000-000000000000"),
           MOVEMENT_CONFIG_CHAR = fromString("f000aa82-0451-4000-b000-000000000000"), 
           MOVEMENT_PERIOD = fromString("f000aa83-0451-4000-b000-000000000000"); 

Utilisation du capteur

Nous utilisons le capteur pour calculer la vitesse et la fréquence de foulée.

  • Algorithme de calcule de vitesse :

Pour la vitesse nous avons utilisé un algorithme de calcul d'intégrale simple basé sur la relation suivante :

    vitesse(n+1) = acceleration(n+1)*(t(n+1)-t(n)) + v(n) 

Comme le capteur est attaché d'une manière qui fait que Z est constante, les vitesses qu'on calcul sont seulement sur les axes X et Y.

  • Algorithme fréquence de foulée :

Foulee.jpg

On a cherché a récupérer les moments où la personne fait son appui sur le pied ayant le capteur, c'est à dire les moments ou la vitesse théorique instantanée suivant l'axe Y est nulle. Mais comme le capteur ne donne pas des valeurs très précises nous avons donné une valeur tampon (alpha=0,4) en dessous de laquelle la vitesse suivant un axe est supposée presque nulle.

Ainsi un pseudo-algorithme qui exécuterait cela est :

    // tableau contenant les périodes de foulees
    double[] periodesFoulees;
    // le double de la periode d'une foulée
    double periode2;
    for v in vitessesY:
        if ( valeurAbs(v) < alpha && periode > 0 ):
            // on calcul 2 fois la periode d'une foulée du coup on ajoute la période calculée divisée par 2.
            periodesFoulees.append(periode/2); 
            // on remet la periode à 0
            periode = 0;
        else if ( valeurAbs(v) > alpha ):
            periode += periode_echantillonage_capteur;
    // après on peut calculer la foulée moyenne
    double fouleeMoyenne = moyenne(periodesFoulees)
    double frequenceFouleeMoyenne = 1/fouleeMoyenne