!!!!1. Introduction Parmi les sports qui deviennent de plus en plus populaire de nos jours, la course prend de l’avance devant la natation et le ski. En effet, il y a progressivement plus en plus de jeunes adolescents et d’adultes qui pratiquent ce sport si proche d’atteinte. Mes parents courent tous les deux à trois jours et ma meilleure amie vise le triathlon avec des entraînements tous les jours, atteignant presque 15 heures de sport intensif par semaine. En débutant la course, mon père s’était souvent blessé, principalement aux genoux, à cause d’une posture inadéquate pour alléger la pression sur les genoux lors de la pratique du sport.

Mon projet serait donc de produire une genouillère qui permettrait de mesurer l'angle entre le genou et la jambe lors de la course et serait capable d'alerter le coureur lorsque celui-ci est hors de la "zone de sécurité". Il sera cependant difficile de produire ce projet qui ne doit pas gêner le coureur, ni s’endommager sous les nombreux choc et vibrations de la course. Il faudra aussi trouver un moyen efficace d’alerter le coureur de sa mauvaise posture. Ce projet permettrait une baisse de blessure causée par la course, ainsi qu’une amélioration de la posture des coureurs, leur permettant d’accomplir de meilleures performances. La course étant un sport hautement populaire, ce gadget pourrait servir à n’importe quel coureur, aussi bien le débutant que le professionnel.

2. Matériel et méthodes

2.1 Matériel

  • Raspberry Pi

Figure 2.1.1 : Raspberry Pi 3 Model B

  • Pi Wedge et board

  • 2 accéléromètres sur 3 axes

  • Genouillère

2.2 Méthode

sensors_raspi_lis3dh_i2c_bb.png, janv. 2020 J'ai tout d'abord suivit les instructions sur le site adafruit.com pour savoir comment connecter un des deux accéléromètres au Raspberry Pi. La figure ci-dessus montre un schéma de l'interface I2C utilisé pour mon projet pour sa simplicité. J'ai ensuite tenté de connecter mon ordinateur au Raspberry Pi, sans succès. La librairie RPi.GPIO nécessaire pour le Raspberry Pi avait besoin de l'application Visual Studio, que je n'avais pas sur mon ordinateur. J'ai dû ainsi l'installer et réessayer d'installer la libraire RPi.GPIO.Or, une nouvelle erreur apparu et j'ai dû abandonner l'idée plus simple de coder sur mon ordinateur. Après avoir branché un écran, un clavier et une souris sur le Raspberry Pi directement, j'ai pu écrire le code basique pour lire les valeurs (x,y,z) d'un des deux accéléromètres. Il fallait tout d'abord s'assurer que le CircuitPython du microcontrolleur était à jour :

sudo apt-get update
sudo apt-get upgrade
sudo pip3 install --upgrade setuptools

Il fallait aussi utiliser I2C pour l'interface en l'activant dans les configurations du Raspberry Pi. J'ai ensuite vérifié que le premier accéléromètre était bien connecté au Raspberry avec la commande ci-dessous :

sudo i2cdetect -y 1

Qui fait alors apparaître une grille ou figure toutes les adresses possible sur le I2C (donc 127 en tout). Ici, seulement le 0x18, l'adresse par défaut de l'accéléromètre utilisé, est signalé.

Puis, j'ai téléchargé les librairies du CricuitPython lis3dh, incluant Adafruit-Blinka qui permet la liaison CircuitPython et Python.

sudo pip3 install adafruit-circuitpython-lis3dh

J'ai ensuite rentré le code de base pour lire les valeurs de l'accéléromètre dans une page vierge de Thonny sur le Raspberry Pi en ajoutant RPi.GPIO dans le code pour qu'il puisse traduire le hardware CircuitPython API aux librairies du Raspberry Pi.

import adafruit_lis3dh
import RPi.GPIO as GPIO
import busio
import time
import digitalio
import board

GPIO.setmode(GPIO.BCM)
i2c = busio.I2C(board.SCL, board.SDA)
int1=digitalio.DigitalInOut(board.D18)
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c)

x,y,z=lis3dh.acceleration
print (x,y,z)

Ceci m'a donné des valeurs de x et y environnant le 0 et une valeur z avoisinant 9 et 10, qui est valeur approximative de l'attraction terrestre.

J'ai ensuite branché le deuxième accéléromètre en liant SDO avec 3,3V pour activer la deuxième adresse réservée pour cet accéléromètre. J'ai retapé la commande de détection.

sudo i2cdetect -y 1

Qui me donna une grille contenant maintenant les deux accéléromètres 0x18 et 0x19. Figure 6 : Grille de connexion I2C, fév. 2020

J'ai alors essayé de trouver un moyen de pouvoir alterner les mesures de valeurs de chaque accéléromètre car il était impossible d'avoir les valeurs simultanément d'un coup car le programme lis3dh de l'accéléromètre permettait seulement de lire la valeur d'une seule adresse I2C. J'ai ainsi écrit ce code qui m'a permit d'avoir les mesures de chaque accéléromètres l'un apres l'autre. Grâce à un calcul simple, j'ai déduis une approximation de la période entre le moment le genou se plie jusqu'au moment ce même genou se plie de-nouveau en me basant sur des informations fournies par mon père (10km en 1 heure et 80 cm par pas).

GPIO.setmode(GPIO.BCM)
i2c = busio.I2C(board.SCL, board.SDA)
int=digitalio.DigitalInOut(board.D18)
number=1

while True:
    number>=0
    lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c,address= 0x18)
    x,y,z=lis3dh.acceleration
    print (x,y,z)
    time.sleep(0.1)
    number=(-1)*number
    if number<=0:
        lis3dh=adafruit_lis3dh.LIS3DH_I2C(i2c,address= 0x19)
        x,y,z=lis3dh.acceleration
        print (x,y,z)
        time.sleep(0.3)
        number=(-1)*number

Il fallait maintenant pouvoir garder les valeurs du premier accéléromètre après avoir mesuré les valeurs du deuxième car les deux avaient, pour leur accélération, une variable appelée lis3dh.acceleration qui ne pouvait être changée dû au fait qu'elle est ainsi nommée dans le code de l'accéléromètre lui-même. Voici le code qui m'a permis de contourner cette restriction et d'avoir l'angle entre les deux vecteurs accéléromètres.

while True:
    number>=0
    lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c,address= 0x18)
    a,b,e=lis3dh.acceleration
    vector1=a,b,e
    print (a,b,e)
    #time.sleep(.001)
    number=(-1)*number
    if number<=0:
        lis3dh=adafruit_lis3dh.LIS3DH_I2C(i2c,address= 0x19)
        c,d,f=lis3dh.acceleration
        vector2=c,d,f
        print (c,d,f)
    def angle_of_vectors(vector1,vector2):
        dotProduct=a*c+b*d+e*f
        modOfVector=math.sqrt(a*a+b*b+e*e)*math.sqrt(c*c+d*d+f*f)
        angle=dotProduct/modOfVector
        angleInDegree=math.degrees(math.acos(angle))
        print("Angle is",angleInDegree,"°")
    angle_of_vectors(vector1,vector2)

Enfin, il fallait pouvoir allumer une led lorsque l'angle était plus grand que 90° ou plus petit que 30°,ces valeurs étant la fourchette de sécurité pour le genou.

if angleInDegree>=90:
            GPIO.output(4,True)
            print ("LED on")
        if angleInDegree<=30:
            GPIO.output(4,True)
            print ("LED on")
        else:
            GPIO.output(4,GPIO.LOW)
            print ("LED off")

3. Résultats

Le prototype fonctionnait du moment les connexions étaient maintenue. Figure 8 : le prototype méchanique, fév. 2020

4. Discussion

La première difficulté rencontrée était que le RPi.GPIO n'était pas compatible à mon ordinateur. J'ai dû donc directement coder depuis le Raspberry Pi. La seconde difficulté rencontrée était que je ne savais pas comment afficher les valeurs (x,y,z) des deux accéléromètres en même temps. J'ai du faire une fonction qui alternait entre positif et négatif pour pouvoir avoir les valeurs des deux accéléromètres presque en même temps. Il y a beaucoup de défauts sur ce prototype. Notamment le fait que les accéléromètres mesurent l'angle à une fréquence d'un peu plus que 2 HZ. Je n'ai pas pu implémenter un bout de code permettant la mesure seulement entre deux pas, ce que je regrette immensément. Ainsi, le code écrit mesure constamment l'angle 2 fois par seconde, ce qui ne peut être une mesure exacte du genou car elle ne prend pas en compte la valeur maximale pendant une certaine période de temps. Un autre défaut, celui-ci plus technique, est la mauvaise connexion des accéléromètres qui se "déconnecte" lors des manipulations. Ceci est lié à la fragilité du système qui n'est pas fixée et peut très facilement être déconnecté. Il y a aussi le problème de la taille. Le prototype n'offre aucun confort au coureur à cause de sa taille, surtout le breadboard. Il faudrait trouver un moyen de le rendre plus compact pour ne pas gêner le coureur lors de sa course. Je n'ai pas réussi a programmer le Raspberry Pi à exécuter le code le moment il est branché à un courant. Beaucoup d'amélioration peuvent encore être faite pour rendre ce projet plus intéressant. Les angles prenant compte d'un vecteur vitesse par exemple, ou un compteur à pas.

5. Conclusion

En conclusion, j'ai fait ce projet avec beaucoup d'intérêts, malgré le fait que c'était la première fois je codais. J'ai dû faire un travail immense de recherche et d'essais, mais le projet final me satisfait assez. Je me suis étonnée d'avoir réussi à terminer ce projet presque individuellement et j'espère il surmontera les épreuves de test pour rendre honneur aux 30 fenêtres web ouvertes sur mon portable.

Références

https://learn.sparkfun.com/tutorials/i2c https://learn.adafruit.com/adafruit-lis3dh-triple-axis-accelerometer-breakout?view=all https://learn.adafruit.com/circuitpython-hardware-lis3dh-accelerometer/software https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/circuitpython-raspi