Site ELEC344/ELEC381

Partie interactive du site pédagogique ELEC344/ELEC381 de Télécom ParisTech (occurrence 2010).

Catégories

A toute vitesse

Ces derniers jours, tout le groupe s’est acharné à faire rouler le robot à nouveau, puisqu’après les exploits de dimanche nous sommes allés de déboire et déboire. D’abord, un bug d’initialisation du gyro nous a empéché d’avancer une journée entière, avec un robot qui ne tenait plus du tout. Ensuite, grâce à des conseils avisés d’Alexis qui a beaucoup travaillé sur nos filtres, nous avons grandement amélioré le filtre, en introduisant un filtre de Kalman en plus de notre filtre complémentaire, pour annuler le drift du gyroscope de façon satisfaisante. Le filtre de Kalman étant moins performant en translation, nous avons néanmoins conservé nos calculs.

Nous avosn pu commencer un début d’asservissement en x, encore beaucoup de tests en perspective…

En paralléle, Fabien a fait un script pour afficher les courbes en temps réel, ce qui nous a permis de faire des acquisitions et de nous rendre compte plus facilement de nos réussites et de nos problèmes. Ainsi, la vitesse en x est toujours nulle (on s’y attèle très vite).

Par contre, les résultats pour la vitesse angulaire sont assez bon, au vu de nos premier tests :

La courbe bleue représente la vitesse angulaire calculée par le robot (décalée pour les besoins de l’observation), alors que la verte donne la dérivée de l’angle.

Heliokter bourdonne

J’ai passé la fin des vacances sur le filtre de Kalman, pour l’affiner/le corriger. Je me suis rendu compte avec la carte IMU que je ne prenais en fait pas en compte les gyroscopes et que je me basais seulement sur l’accéléromètre/magnétomètre (l’accéléromètre étant excentré par rapport au centre de rotation de la carte IMU, on s’en aperçoit mieux). Le modèle cinématique de mise à jour de létat en fonction des gyros était en fait légèrement erroné (une petite matrice par-ci …).

Bon bref j’ai réussi à regler tout ça et avoir des resultats corrects et sans lag.

Hier, on a commencé à intégrer tout le code et à contrôler les moteurs correctement avec l’I2C, mais je laisse les autres détailler, je n’etais pas là l’après-midi …

Et aujourd’hui, c’etait au tour de l’asservissement d’être integré dans le code et testé. Il a fallu évidemment faire face aux éternels problème d’orientation  (argh, la carte est à 45° par rapport à l’avant de l’Helico !) et d’angles, en passe d’être résolu ce soir.

Fernando et Miguel s’occupent d’un protocole de communcation par ZigBee ou Bluetooth (compatible avec celui de Mikrkopter) qui nous permettra de régler les coefficients du PID de manière dynamique (sans avoir à reflasher à chaque fois). Je leur laisse le soin de détailler.

Voilà une petite vidéo du rodéo actuel, avec un asservissement inexact et trop fort.

Améliorations pour le code de Wheely

Cette nuit, Alexis nous a communiqué le fruit de ses recherches sur le filtrage. Sa conclusion : Le filtre complémentaire que nous utilisions est très bon une fois qu’on lui soustrait le drift, mesuré à l’aide d’un filtre de Kalman tournant en parallèle.

Avec l’aide du code fourni par Alexis, j’ai intégré le Kalman et la soustraction du drift. Le code d’Alexis m’a par ailleurs inspiré sur pas mal de points, en terme de propreté, donc j’en ai profité pour faire une bonne petite refonte du code de Wheely, avec des variables plus claires, et une API pratique et compréhensible.

Cet après midi nous avons testé le code. Après que nous ayons corrigé quelques coquilles, nous obtenons sans l’asservissement sur X des résultats plutôt satisfaisant. Le robot tient assez bien sur place, à condition que le léger offset sur l’angle soit bien réglé à la main. Mais il est assez stable, autour de 0.6°, désormais codé en dur.

Difficile pour l’instant de bien contrôler les effets d’un asservissement sur X lorsque nous l’introduisons.

J-22

Alors comme ça fait plusieurs jours que je n’ai pas mis à jour voici ce que j’ai fait durant les derniers jours :

Jeudi 15

J’ai amélioré mon code de benchmark, voici des résultats plus extensifs sur les opérations :

.

.

Math timings double Timing ( µs ) Cycles

.

offset add mul div cos sin abs sqrt abs

.

offset 14492 14.492 1043.424

.

add 28827 28.827 2075.544

.

mul 28823 28.823 2075.256

.

div 28826 28.826 2075.472

.

cos 14464 14.464 1041.408

.

sin 14487 14.487 1043.064

.

offset abs 14463 14.463 1041.336

.

sqrt(abs()) 41676 41.676 3000.672

.

Math timings floats

.

offset add mul div cos sin abs sqrt abs

.

offset 14501 14.501 1044.072

.

add 28826 28.826 2075.472

.

mul 28855 28.855 2077.56

.

div 28855 28.855 2077.56

.

cos 14473 14.473 1042.056

.

sin 14492 14.492 1043.424

.

offset abs 14501 14.501 1044.072

.

sqrt(abs()) 42032 42.032 3026.304

Je ne suis pas vraiment satisfait car les résultats ne me semblent pas vraiment cohérents, mais peut être est-ce à cause de l’influence de divers paramètres pas controlés : cache, optimisation, autre.

Explication de la méthode : le temps à gauche représente le temps d’exécution pour 1000 opérations en µs.
offset : temps d’exécution d’une fonction pour avoir une nombre alétatoire double ou float( mul, add, modulo, sauvegarde dans une variable double ou float static ), fonction appelée myrandd() ou myrandf()
add/mul/div : 2 appels à myrand, 2 cast int->float ou double, addition/mulitplication/division des deux nombres et sauvegarde dans une variable float/double.
cos/sin : 1 appel à myrand(), 1 cast, 1 sauvegarde
offset abs : 1 appel à abs( myrand( ) ) 1 cast et 1 sauvegarde
sqrt : 1 appel à sqrt(abs(myrand( ))) 1 cast et 1 sauvegarde

Le problème est que l’on ne peut pas vraiment soustraire l’offset des opérations … car le temps d’exécution n’est pas vraiment linéaire. Un autre point qui m’étonne est le nombre de cycles qu’il faut pour faire une simple addition …

Bref je vous donne les résultats as is, car j’ai du mal à les interpréter. On retiendra qu’une opération arithmétique sur un double ou un float est du même ordre de grandeur : quelques dizaines de µs.

Vendredi 16

J’ai écrit le code pour les télémètres, ce qui était assez rapide puisque j’ai juste eu à m’intégrer dans le code de FX pour les gyros. Mais comme les télémètres étaient bloqués au Royaume Uni à cause de l’arrêt du traffic aérien, une fois mon code fini, j’en ai profité pour me mettre à jour sur le code qu’avaient écrit les autres.

J’ai aussi commencé à nettoyer mon code et à agencé un peu l’architecture globale du code.

Samedi , Dimanche, Lundi 19

Vacances

Mardi 20

Retour en A405 par une magnifique journée de printemps. Aujourd’hui j’ai écrit le squelette de notre version propre alpha pour l’heliokter avec des prises de sémaphore bien claires, des delays là où il faut et une beau découpage en fichier pour la compilation séparée. Ca m’a pris un peu de temps dans le sens où j’ai du lire le code un peu de tout le monde et réfléchir à comment wrapper les fonctions de chacun pour ne pas avoir à réécrire trop de choses.

Ensuite comme les télémètres étaient arrivés, j’ai pu vérifier mon code, qui marchait du premier coup ! ( merci FX ) ensuite j’ai pu étalonner le télémètre et maintenant je récupère une distance en cm. Celle-ci est bonne pour une distance entre 8cm et 70 cm environ ( comme nous n’avions qu’une règle de 30 cm ( merci Flavia ) , les mesures au delà de 30 cm n’étaient pas très précises).

La méthode pour étalonner : regarder la valeur en « int12″ renvoyée par l’ADC à 8 cm, celle renvoyée à 30 cm, regarder la courbe sur la datasheet qui ressemble fortement à a/x+b, ensuite trouver a et b à partir de ces deux points. Ci dessous le résultat sous forme de courbe ( axes : distance en cm )

  • En rouge : y=x
  • En vert : y= f(x) où f est la fonction d’interpolation. Dans l’idéal elle devrait donner l’identité.

C’est assez satisfaisant !

Mercredi 21

Aujourd’hui on a réussi à avoir une version « sale » mais complète du code qui compile ( c’est à dire senseurs, filtrage, asservissement et moteurs ).

On a ensuite fait un vol d’essai pour faire une acquisition et un test du filtre de Kalman depuis notre propre carte. Ce qu’on a constaté dans ce premier vol et qui m’inquiète un peu c’est que les angles mis en jeu pour le roll et le pitch sont très faibles, je me demande aussi l’amplitude des valeurs utilisées par les moteurs ( +- 3 sur un unsigned char ou bien +- 100 ? ).

Quand l'incroyable se produit

Après quelques essais infractueux, je m’étais un peu résigné sur cette histoire de filtre de Kalman.

Mais là ce soir, dans un éclair d’espérance, j’ai relu mon code. Après la correction d’une erreur de signe, d’une erreur de calcul (je faisais la somme d’une matrice et de sa transposée « en place », très mauvaise idée …) et avec un pas de discrétisation plus petit, mon filtre s’est soudainement mis à marcher.

Yeeepeee !

Si, si !  et même que le changement des paramètres de covariance influe de manière à peu près logique sur le système. Si je fais trop confiance aux gyros, j’ai un petit effet « flamby inertiel » (lhélico tourne un peu plus loin qu’il aurait dû et revient un peu après le mouvement pour se trouver au bon endroit) mais si je fais trop confiance aux accelerometre/magnétomètre, il reprend un peu la tremblotte (comme sans filtre en fait).

Il faut encore que je comprenne comment régler la puissance de la correction sur l’offset des gyros, même si ça marche vraiment pas trop mal pour le moment.

Normalement, on va essayer de voir ce que ça donne demain mercredi sur un vrai vol : L’helicoptère devrait être attaché par des cordes de sorte qu’il ne puisse pas trop se déplacer mais en laissant de la marge sur son assiette pour voir si notre asservissement fonctionne.

Je vous aurais bien montré des vidéos de la visualisation de l’orientation de la carte mais je n’ai pas d’iPhone 3GS :’( (ou d’autres outils de prises de vue animées non propriétaires)

Résumé des épisodes précédents

Après avoir perdu sur la représentation des rotations de la carte en OpenGL, je me suis finalement mis à lire directement la DCM (matrice qui détermine l’attitude de la carte) pour savoir si l’algo FQA était bon. Ca permet surtout de vérifier pas mal de cas et de se convaincre que ça marche (quand la matrice n’a que des 0 et des +/- 1). Et le FQA a bien l’air de marcher !!

Sur la carte Heliokter, j’ai repris la méthode de Samuel pour déterminer comment les composants détectaient les axes et ça a presque tout de suite marché avec l’algorithme FQA. Vendredi soir j’ai juste eu le temps d’implémenter le FQA sur la carte et le filtre de Kalman sans pouvoir tout tester.

Aujourd’hui lundi, j’ai d’une part repris le code de visualisation OpenGL pour recevoir par Bluetooth directement les coefficients de la DCM calculés sur la carte et les représenter (sans se tromper ce coup-ci). C’est OK de ce point de vue là et ça marche bien. Il n’y a pas trop de singularité mais les changements d’attitude manquent de fluidité. C’etait prévu, mais ça permet aussi de voir que c’est effectivement très sensible aux vibrations. Après, peut-être que les vibrations faites avec la main sont différentes (notamment en terme de fréquence) de celles ressenties sur l’Heliokter.

D’autre part, j’ai regardé le comportement de mon filtre de Kalman  en fonction de différentes valeurs sur les incertitudes de mesures et de prédiction. J’ai surtout fait du cas extrême pour voir s’il n’y avait pas de grosses erreurs. C’est un peu le flou puisque je ne sais pas non plus si le modèle cinématique que j’ai implémenté dans le filtre est juste  mais j’ai observé des choses qui me semblaient cohérentes.

  1. Quand l’incertitude de prédiction est beaucoup plus faible (donc plus fiable !) que celle de mesure, j’ai mon état qui se décale lentement mais surement de l’état réel. C’est visiblement du au biais des gyroscopes, qui n’est pas corrigé dans l’état. C’est cohérent avec les incertitudes qu’on fixe.
  2. Quand l’incertitude de mesure est beaucoup plus faible que celle de prédiction, j’ai un filtre qui diverge très rapidement (en quelques itérations) sans que je puisse vraiment l’expliquer.
  3. Dans les autres cas (c’est à dire quand les incertitudes sont du même ordre de grandeur), mon état commence par se décaler de l’état réel puis le biais calculé dans l’état du filtre commence à se rapprocher du biais réél, ramenant l’état vers sa valeur réelle. Jusque là tout va bien. Mais le problème c’est que cela va de plus en plus vite et le biais calculé finit par dépasser rapidement la valeur du biais réel et s’écrase dans les choux (genre dépasement de capacité) quelques itérations plus tard.

Le jeu sur les valeurs de l’incertitude influe sur le temps que met le filtre à diverger. Ca va de jamais (cas extreme 1) à tout de suite (cas extreme 2). Je n’ai pas encore trouvé de valeurs qui marchent.

Voilà, après j’imagine qu’il faudra régler les incertitudes plus finement (c’est à dire avoir des coefficients différents pour chaque mesure et chaque prédiction, pour le moment) mais je ne sais pas si le comportement que j’observe présentement est typique d’un filtre de Kalman correct mal calibré ou d’un filtre complètement foireux …

Wahba pour Kalman

Lundi

Après les larges lectures des articles sur Kalman, MAV, IMU que Alexis nos a donné maintenant je peut dire que je  comprendre mieux les choses. A début des lectures j’ai eu des problèmes pour comprendre mais après un coup d’œil aux cours de physique, probabilités, et autres aspectes commet les angles d’Euler et les quaternions les choses ont commencé à être plus claires.

Mardi

Les neuf variables d’état du filtre Kalman  sont les trois vitesses de rotation angulaire mesures pour les gyroscopes plus les deux colonnes de la matrice de rotation de la base du mobile à la base de référence. Ces colonnes de matrice de rotation son trouvés à partir du algorithme FQA. FQA prend les valeurs mesures par l’accéléromètre et magnétomètre et donné la matrice rotation. Après lecture de Wahba, FQA, et le code de Fernando on a vu il y a encore le problème de singularité quand le tangage c’est près de quatre-vingt dix degrés.

Mercredi

En cherchant résoudre le problème de singularité j’ai vu que on peut trouver les colonnes de la matrice de rotation sans passer pour les quaternions. Celui-ci utilise plusieurs opérations comme sinus et cosinus qui sont très couteuses. Ainsi, j’ai fait une fonction qui donne les colonnes de la matrice en utilisant le minimum des opérations. Avec F-X on testé sur l’IMU et on a un problème sur le tangage, quand on fait la rotation l’axe n’est pas constante. Il reste de résoudre ce problème et celui de singularité, on a besoin que le problème de Wahba soit bien résolu pour tester le filtre Kalman sur l’IMU.

Matrix reloaded ...

Hier, fort de la lecture de différents articles et codes source, je me suis lancé dans le code du filtre de Kalman, sans pouvoir toutefois réellement le tester (mais il compile !). J’ai fait attention d’optimiser un peu les opérations sur les flottants même si on peut sûrement faire quelque chose de mieux ‘hardcore style’. J’espère aussi qu’une opération flottante avec 0 prend moins de temps qu’une autre !

Au total, une passe de mon filtre de Kalman prend environ 870 multiplciations, 950 additions et 9 divisions. Je n’ai pas encore relié ça rigoureusement aux temps d’execution qu’on a mesuré avec Etienne mais il semble me souvenir que ça devrait faire aux alentours de 5ms. Vu le temps de réaction et l’inertie de l’hélicoptère, je pense qu’on est bon de ce point de vue là.

L’objectif de la journée d’aujourd’hui était d’intégrer l’algo FQA (pour la résolution du problème de Wahba) et le filtre de Kalman pour pouvoir le tester. Seulement, pour faire ça, il fallait d’abord vérifier que l’algo FQA marchait bien, à l’aide du visualisateur 3D. Le protocole est simple: Le visualisateur récupère les valeurs du capteur sur la carte (envoyées par Bluetooth), execute l’algo en local  (pour eviter des problèmes supplémentaires …) et met à jour l’affichage.

Et là, ça a été trèèèèèèèèèèèèèèèès long (oui, une journée complète de 10h, je ne comprends toujours pas comment le temps a pu filer ainsi !) pour avoir le lien entre l’affichage et la matrice renvoyée par l’algo avec tous les problèmes de changements de base (carte->monde physique réél->monde openGL->représentation de la carte dans le monde OpenGL), de matrices transposées ou pas, bref !

Voyant que je pataugeais, Etienne D. m’a bien aidé pour essayer de voir les choses clairement et systématiquement et on est (visiblement !) arrivé à quelque chose de cohérent là-dessus.

Ce qui nous a permis de voir que l’algo FQA (ainsi qu’une version allégée que Miguel a codé en parallèle) ne marche pas très bien, vraisemblablement à cause d’un problème d’ordre de rotation. J’ai essayé aussi de reprendre l’algo TRIAD (qui n’utilise que des opérations vectorielles donc normalement exempt de ces problèmes d’angle) sans grand succès non plus…

Bref, c’est un peu une journée désespérante de ce côté là, heureusement qu’Etienne avait à côté des résultats positifs (et que Pulse aussi, derrière nous, on pouvait s’amuser à les pinger ou à les synflooder pour se détendre :P ).

J-23 La note du banc

Aujourd’hui j’ai compilé réussi à bien compiler mon code et à l’exécuter sur la carte de l’Heliokter en RAM et en Flash ( XIP ). J’ai pu débugger ma plateforme de bench ( quelques problèmes avec le timer m’ont ralenti, en effet il faut  déclencher un event quelconque pour que le Prescaler soit bien pris en compte ce qui m’avait échappé, et qui passe inaperçu avec de l’autoreload ).

Après quoi on a benchmarké rapidement avec FX quelques fonctions de math.h : float cos(float) versus double cos ( double ) , sqrt , addition , mulitplication de double. Ce qui lui permettra d’évaluer la vitesse de son filtre de Kalman et de décider entre float et double. Il a noté les résultats je lui laisse le soin de les donner, et on fera peut être un rapport plus poussé plus tard pour mémoire.

Pour l’exécution in place (XIP) j’ai pu faire des tests extensifs avec des traces issues des capteurs dans le simulateur ( 180 mesures environ ).  J’ai obtenu un temps d’exécution de 755 µs en moyenne environ. Ci-dessous un schéma résumant les résultats ( avec en axe des ordonnées les µs et en abscisse le numéro de la mesure ). Il y a quelques petites choses bizarres sur la fin, je pense que je dois changer ma méthode de mesure pour prendre en charge le changement de contexte avec une macro de FreeRTOS exprès , à vérfier, ce que je ne fais absolument pas pour l’instant et donc les mesures ne sont pas pures …

Nous avons aussi regardé avec FX quelques bugs qu’il y avait sur les changements de bases entre les données des capteurs, la sortie de wahba / Kalman et le monde réel.

Il faut toujours que je définisse des symboles dans mon code pour réussir à mettre en ram la partie du code à benchmarker et laisser en flash les jeux de test.

Kalman farçi, Kalman à l'américaine ...

Aujourd’hui, j’ai fait beaucoup de recherches sur le filtrage de Kalman, afin que ce soit bien clair dans ma tête et pour enfin voir concrètement ce qu’on va faire.

C’est un peu frustrant (surtout à ce stade du projet) de passer une journée où on ne produit rien de concret mais je pense que ça aidera quand même .

J’ai eu de gros moment de doutes dans la journée (notamment sur le calcul d’erreur et la manière dont on l’utilisait pour mettre à jour la variable d’état) qui se sont dissipés au fur et à mesure des lectures. Ca ne fera surement pas de mal non plus de confronter ce que j’en ai compris avec Miguel demain et d’en parler aussi avec Alexis.

Tout d’abord, le mot clé  AHRS (pour Attitude and Heading Reference Systems) m’a ouvert pas mal de portes pour trouver d’autres articles que ceux d’Alexis, certains plus théoriques et aussi des exemples de code. J’ai aussi découvert le projet OpenPilot (dont les sources sont normalement libres, mais je n’ai pu trouver les sources de leur AHRS (!) dans leur dépôt SVN ) et Rotomotion, asez présent sur le net.

Deux liens ici vers des exemples de code que je ne trouve pas parfait non plus (notations peu claires, syntaxe hésitante, utilisation de flottants) mais qui permettent de se donner une idée de ce qu’on devra faire.

Et un article, qui reprend l’idée de considérer le gyroscope comme commande et les accéléromètre comme mesure. Ils utilisent également les quaternions  et donnent les matrices utilisées dans le filtre de Kalman à part les matrices de covariance.

Voilà, j’espère qu’on pourra demain décider finalement ce qu’on met dans notre filtre, éclaircir les dernières zones d’ombre avec Alexis et commencer à le coder !

Quant au code de Mikrokopter, il m’a l’air très artisanal, avec des tests sur les écarts entre gyros et accélérometres et autres. Bref, pas de filtre de Kalman de ce côté là.