RASP-SENSE-HAT-ASTRO-PI-Mouvement

Senseur de mouvement

Le Sense HAT met en oeuvre de nombreux senseurs, l'un d'eux est un senseur de mouvement appelé IMU. L'IMU est capable de mesurer le type de mouvement qu'il subit.

La source anglaise de cette traduction se trouve ici https://www.raspberrypi.org/learning/astro-pi-guide/sensors/movement.md

Qu'est ce qu'un IMU?

Il est équipé d'une centrale de mesure inertielle (dite IMU pou Inertial Measurement Unit) sous forme d'une puce qui inclus:

• Un gyroscope (qui mesure le moment et la rotation)
• Un accéléromètre (qui mesure les forces d'accélération et peut être utilisé pour trouver la direction de la gravité)
• Un magnétomètre (qui mesure le champ magnétique de la terre, c'est un peu comme une boussole)

Pourquoi un senseur de mouvement est-il si important?

Quand vous êtes dans l'espace il y a une question d'importance absolue à laquelle vous devez toujours être capable de répondre: dans quelle direction suis entrain de pointer?

Si vous ne connaissez pas votre orientation alors vous avez un énorme problème. Par conséquent, une centrale inertielle (senseur IMU) est utilisée dans tous les engins spatiaux habités et non habités. Ce senseur permet savoir quelle est l'orientation et fait en sorte de maintenir cette information "correcte". Même un ancien engin spatial dispose d'un IMU. Demandez à vos grand-parents s'ils se souvennent des missions Apollo (wikipedia, anglais) qui ont emmené des humains sur la surface de la lune.

La photo ci-dessus présente le senseur IMU de module de commande Apollo. Notez comme ce module est imposant comparé au petit cube noir qui équipe votre Sense-Hat; c'est la différence entre la technologie de 1975 et celle de 2015. Par ailleurs, l'IMU du Hat Sense n'est pas aussi précis que celui d'Appolo, mais il coûte aussi un million de fois moins cher!

Comment l'orientation est elle représentée?

Nous savons que la terre tourne autour d'un axe qui va du pôle Nord vers le pôle Sud. Tous les objets (y compris dans l'espace) ont 3 axes autour desquels ils peuvent tourner. Si vous savez déterminer la quantité de "rotation" sur chacun de ces axes alors vous savez aussi vers où l'objet pointe.

Les 3 axes utilisés pour décrire le mouvement sont:

• Elévation, dit "Pitch" en anglais (comme quand l'avion décolle)
• Roulis/Roulement, dit "Roll" en anglais (comme un avion qui faire la rouleau de la victoire, ou une voiture qui fait un tonneau)
• Lacet/Embardée, dit "Yaw" en anglais (imaginez un avion qui dévie de sa route comme le ferait une voiture, où une voiture qui prend un virage "en lacet")

Etant donné que l'interface de programmation du Sense Hat utilise ces mêmes mots clés en anglais pour vous permettre d'accéder aux valeurs, nous allons préserver les termes "Pitch"n "Roll", "Yaw".

Les images ci-dessus montre les 3 axes en relation avec le Sense Hat ainsi que la correspondance dans le monde réel.

Nous allons maintenant démarrer le programme d'exemple en 3D.

Démonstration Appolo Soyuz

L'image ci-dessous présente le module Apollo Soyuz utilisé pour emporter des humain sur la surface de la lune durant les années 1970. La démontration 3D avec laquelle nous allons jouer montre le même vaisseau spatiale (mais avec moins de détails).

Vous aurez besoin de votre Raspberry Pi et d'un Hat Sense connecté sur Internet de façon à pouvoir télécharger les logiciels nécessaires.

Entrez la commande suivante dans une fenêtre terminal:

sudo apt-get install python3-pip
sudo pip-3.2 install pi3d
git clone git://github.com/astro-pi/apollo-soyuz
cd apollo-soyuz
sudo ./soyuz.py

Les utilisateurs de Pi ancienne génération devrons attendre 3 ou 4 minutes pour achever le chargement.

30 secondes de chargement seront nécessaires pour les utilisateurs de Pi 2.

Commencez à bouger votre Raspberry-Pi lorsque vous verrez le vaisseau spatiale apparaître à l'écran. Le bruleur principal se trouve du côté du lecteur de carte SD de votre Pi.

Voyez si vous pouvez identifier les différents mouvement d'élévation pitch, roulis/roulement roll et embardée yaw.

Le code derrière cette démo fait principalement appel à la fonction get_orientation du sense hat (fonction qui accède au senseur IMU). Cette fonction retourne trois angles entre 0 et 360 degrés, une valeur pour chaque axe(pitch, roll et yaw). Le modèle du vaisseau spatial subit alors une rotation de ces mêmes angles de façon à pointer dans la même direction. Cette opération est répétée encore et encore de façon à maintenir rapidement l'orientation du modèle avec celle rapportée par le senseur IMU.

Pour quitter la démo, pressé sur la touche Esc.

Essayons maintenant de réaliser une version simplifié de ce programme.

Quelle direction est-elle pointée?

1. Ouvrez Python 3 dans une fenêtre terminal en utilisant sudo avec la commande suivante:

sudo idle3 &

2. Selectionnez le menu File > New Window (Fichier > Nouvelle fenêtre) et entrez le code suivant:

from sense_hat import SenseHat
sense = SenseHat()
sense.clear()

o = sense.get_orientation()
pitch = o["pitch"]
roll = o["roll"]
yaw = o["yaw"]
print("pitch %s roll %s yaw %s" % (pitch, roll, yaw))

3. Sélectionnez le menu File > Save (Fichier > Sauver sous) et choisissez une nom pour votre programme.

4. Sélectionnez Run > Run module (Executer > Exécuter module).

5. Si vous voyez l'erreur IMU Init Failed, please run as root / use sudo sur la dernière ligne en rouge, cela signifie que vous n'avez pas suivit les instructions ci-dessus. Fermez tout et reprenez à l'étape 1.

Le message "IMU Init Failed" signifie "Echec d'initialisation de l'IMU".

6. Vous devirez maintenant un résultat semblable à celui-ci:

IMU Init Succeeded
pitch 356.35723002363454 roll 303.4986602798494 yaw 339.19880231669873

La première ligne "IMU Init Succeeded" signifie que l'IMU à été initialisé avec succès.

Vous noterez également les 3 valeurs "pitch", "roll" et "yaw" dont nous avons expliqué la signification plus haut dans l'article.

7. Nous n'avons pas besoin de toutes ces décimales derrière le point. Nous allons faire le nécessaire pour les arrondir juste avant l'instruction print("pitch %s roll %s yaw %s" % (pitch, roll, yaw)) avec les lignes suivantes:

pitch = round(pitch, 1) # ne garder qu'un seul chiffre après le point décimal.
roll = round(roll, 1)
yaw = round(yaw, 1)

Surveiller les mouvements

Ce serait bien de surveiller les valeurs sur les différents axes, plaçons notre code dans une boucle while et exécutons le une nouvelle fois:

while True:
   o = sense.get_orientation()
   pitch = o["pitch"]
   roll = o["roll"]
   yaw = o["yaw"]

   pitch = round(pitch, 1)
   roll = round(roll, 1)
   yaw = round(yaw, 1)

   print("pitch %s roll %s yaw %s" % (pitch, roll, yaw))

Déplacez votre Pi dans votre main et vous deviez voir les numbres changer. Voyez si vous pouvez modifier la valeur d'un axe en bougeant votre Pi dans la direction "pitch" (élévation) comme indiqué dans les diagrammes.

Répéter l'opération pour les 3 axes. Pressez Ctrl - C pour arrêter le programme.

Afficher l'orientation sur la matrice LED

1. Afficher quelque-chose provenant de l'univers 3D sur un afficheur 2D est toujours un challenge, plus spécialement si votre afficheur à une taille de 8 x 8 point. Une option qui fonctionnerait bien serait d'utiliser une LED pour chaque axe et de déplacer cette LED de différente façon. Par exemple:

• La LED pitch (élévation) pourrait monter et descendre
• La LED roll (roulis, roulement) pourrait aller d'un côté à l'autre
• La LED yaw (embardée) pourrait se déplacer le long des bordures

2. Voici une astuce intelligente que vous pouvez réaliser. La table ci-dessous affiche le numéro des LEDs (numérotation séquentielle) organisées en lignes horizontale.

Pour chacun de ces numéros, il est possible des les convertir en coordonnées X Y en utilisant le code ci-dessous.

y = number // 8
x = number % 8

Pour la valeur y vous pouvez utiliser une division entière // par le nombre 8. Dans division entière, la valeur décimale (et donc le "reste de la division") est simplement ignoré. Ensuite, la valeur de x est le module % par 8, ce qui donne uniquement le reste de la division par 8.

Voici un exemple basé sur le point/pixel 60 se trouvant sur la ligne du bas:

60 // 8 = 7
60 % 8 = 4

Notez de 7 * 8 + 4' donne bien 60 :-)

3. Essayez le code suivant:

number = 60

y = number // 8
x = number % 8

sense.set_pixel(x, y, 255, 255, 255)

4. La chose vraiment intelligente dans cet astuce est de réaliser une liste contenant les numéros de LEDs correspondantes à la directions souhaitée. Il suffira alors de se déplacer d'avant en arrière dans cette liste en fonction de la valeur de l'axe.

Disons maintenant que nous voulons créer une suite de LEDs à allumer le long des bords de la matrice. Nous allons construire notre liste sur la ligne du haut, puis descende le long du coté droit, aller de gauche à droite sur la ligne du bas et finalement remonter le coté gauche de la matrice.

Cela donnera la liste suivante:

edge = [0, 1, 2, 3, 4, 5, 6, 7, 15, 23, 31, 39, 47, 55, 63, 62, 61, 60, 59, 58, 57, 56, 48, 40, 32, 24, 16, 8]

En anglais, le mot edge signifie "bordure".

Nous pouvons alors trouver la longueur de cette liste en utilisant la fonction len:

length = len(edge)

Donc la taille est 28. Si nous divisons 28 par 360 nous avons un rapport entre , disons, la mesure de "yaw" (embardée) et la position de la LED dans notre liste (la distance a parcourir le long de la bordure). Nous pouvons maintenant obtenir le numéro séquentiel du point/pixel directement depuis la liste. De cette valeur "séquentielle" nous pouvons obtenir les coordonnées x et Y de la LED et allumer cette LED (comme expliqué au début de cette section)!

Comme ceci:

from sense_hat import SenseHat

sense = SenseHat()
sense.clear()

edge = [0, 1, 2, 3, 4, 5, 6, 7, 15, 23, 31, 39, 47, 55, 63, 62, 61, 60, 59, 58, 57, 56, 48, 40, 32, 24, 16, 8]
length = len(edge)
ratio = length / 360.0

while True:
    o = sense.get_orientation()
    pitch = o["pitch"]
    roll = o["roll"]
    yaw = o["yaw"]

    yaw_list_position = int(yaw * ratio) # Position dans la liste pour YAW

    yaw_pixel_number = edge[yaw_list_position] # Numéro du pixel pour YAW

    y = yaw_pixel_number // 8  # Calcul de la position Y du pixel
    x = yaw_pixel_number % 8   # Calcul de la position X du pixel

    sense.set_pixel(x, y, 255, 255, 255) # Allumer le pixel

5. Ce qui vous aurez certainement remarqué dans le code ci-dessus, c'est qu'il ne fait qu'allumer les LEDs. Nous vous laissons le soin de trouver, par vous même, le code à utiliser pour éteindre les LEDs.

Essayez d'avoir des variables pour la valeur de x et y lorsque la boucle à été exécutée la fois précédente. Si la nouvelle valeur de x et y (du pixel à allumer) est différente de l'ancienne valeur alors vous pouvez utiliser set_pixel pour éteindre la LED (la mettre en noir).

---

Source: Getting Started with Astro PI et Astro-Pi Guide proposé par Raspberry Pi Learning Resource (www.raspberrypi.org)

Licence Creative Commons - CC-BY-SA
The learning resource is provided for free by the Raspberry Pi Foundation under a Creative Commons licence.
Find more at raspberrypi.org/resources and github.com/raspberrypilearning.

Traduction réalisée par Meurisse. D pour shop.MCHobby.be - Licence CC-BY-SA.
Crédit de traduction: Toute référence, mention ou extrait de cette traduction doit également être explicitement accompagné du crédit de traduction suivant : «  Traduction par MCHobby (shop.MCHobby.be) » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.