Site ELEC344/ELEC381

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

Catégories

J-8 Heliokter l'indomptable

Mardi

Comme on a travaillé ensemble avec FX je ne détailles pas les parties déjà explicitées, mais mardi, après avoir réglé des problèmes d’orientation et de précédence dans les angles, nous avons commencé à asservir l’Heliokter en angle, ce n’est pas une partie de gâteau, pour avoir un protocole de test cohérent, nous avons avec FX tracé les courbes correspondant aux erreurs du PID, les commandes des moteurs et l’évolution des différents angles. Nous avions trouvé une façon de limiter les mouvements à un seul degré de liberté, mais la technique consistant à attacher une des pattes de l’engin s’est révélée inadaptée dans la mesure où cela introduit une dissymétrie dans les bras de levier des moteurs que l’on voulait asservir.

Mercredi

Idem on a travaillé ensemble avec FX, grâce à la modification du code nous permettant de régler les coefficients à la volée et la mise en place d’un nouveau protocole pour avoir un degré de liberté mais sans les problèmes de mardi, ( Heliokter scotché à une plaque de polystyrène posée sur un cylindre de bois sous le centre de gravité ), nous avons constaté que le réglage du double asservissement restait très délicat, de plus les mesures des gyros étaient inexploitable car variant trop vite. Donc sur les conseils d’Alexis nous avons fait deux choses :

  • Filtrer les gyros sur un centième de seconde, ( Un+1 = alpha * Un + (1-alpha)*gyro où alpha = tau/(dt+tau) avec dt temps entre deux échantillons de gyros ( 5 ms chez nous ) et tau 1/fréquence de coupure donc tau = 10 ms chez nous ) .
  • Schinter le deuxième asservissement pour les régler l’un après l’autre.

Dans la soirée nous ne réussissions plus à démarrer les moteurs, nous avons perdu un bout de temps pour nous rendre compte que lors d’un merge malheureux, une version vieille de l’i2c avait écrasé la version fonctionnelle ( et que la numérotation du versionnage par hg peut être trompeuse ). Après ça, peu de temps avant les derniers métro, nous avons eu un asservissement décent en roulis et tangage à la fois, prochaine étape : régler le lacet et l’altitude.

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.

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 …

Encore une victoire de canard !

Suite à mon dernier article j’ai tenté toutes sortes de manières de debug pour trouver d’où le petit problème venait. Je suis passé par l’implémentation d’un programme en C sur mon ordinateur pour tester le filtre sur un échelon pour comparer à ce que donnait MATLAB (pareil), tester l’échelon sur la carte logique, j’en passe et des meilleures.

Après de longues heures à m’arracher les cheveux, j’ai enfin réussi à corriger le code. Le problème venait de l’accéléromètre. La récupération des valeurs via SPI posait des soucis et désynchronisait le filtre. J’ai donc créé une tâche  spécifique qui se charge d’updater une variable locale au programme avec ce qu’elle récupère via SPI. Ca permet d’éviter de perturber le bon déroulement du filtrage.

Voici le résultat obtenu lors du benchmark. Cela correspond pile poil aux mouvements donné à la carte par le servomoteur. Et l’axe des ordonnées indique pile poil l’angle d’inclinaison de la carte en centièmes de degrés. C’est trop cool, et surtout, ça va permettre de bosser sur la suite en ayant une totale confiance dans les angles que l’on va manipuler.

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.

Filtres complémentaires : mission accomplie

Bon, suite aux travaux d’aujourd’hui, j’ai réussi à obtenir de très bonnes courbes. Notre problème d’offset sur les valeurs et de temps de réponse du filtre a été résolu en choisissant une valeur beaucoup plus grande pour la fréquence de coupure.

J’ai ensuite mis en place un benchmark assez complet : oscillation rapide, oscillation lente avec plateau ou non, oscillations rapides de demi amplitudes.

J’ai ensuite calibré le coefficient relatif entre l’accéléromètre et le gyroscope en utilisant des oscillations de différentes fréquence, l’un et l’autre se manifestant ainsi différemment. Le bon coefficient relatif est celui qui permet d’avoir une même mesure de l’angle pour des oscillations de fréquence différente.

Voici le graphique obtenu, avec en haut la commande d’angle donnée aux servomoteurs, et en dessous, l’inclinaison, calculée en degré, en fonction des données recueillie par les capteurs lors du mouvement. Le seul défaut que l’on peut constater est un angle calculé un chouilla en dessous de 0 lorsque l’on vient de remonter la carte (aucun soucis lorsqu’elle vient de descendre). Cela est probablement du à un petit défaut des servo vis à vis de la gravité, et n’est donc a priori pas lié à notre travail.

J’ai ensuite implémenté le nouveau filtre en C, modifié le code du gyroscope pour intégrer après filtrage (et non avant comme c’était fait), et créé deux fonctions get_angle_degree et get_angle_radian qui intègrent les bons coefficients.

Enfin, j’ai testé l’execution sur la carte de tout ça, envoyant via bluetooth le résultat de la commande get_angle_degree*100 (pour avoir de la précision malgré le cast en entier pour l’itoa).

J’obtiens des résultats à l’image de la simulation MATLAB, plutôt satisfaisants. Hormis pour le troisième type d’impulsion, ou ça ne colle pas. Ca n’atteint pas les 10°, et surtout, ça fait deux oscillations au lieu d’une.

Compte tenu que j’ai bien vérifié que le filtre et les données traitées (vitesse donnée par le gyroscope et accélération donnée par l’accéléromètre) sont exactement les mêmes je ne comprends pas trop. Si quelqu’un à une piste je suis preneur, en attendant, je continue à chercher…

Wheely – filtre complémentaire

Depuis quelques jours, nous travaillons sur les données du gyroscope et de l’accéléromètre que l’on filtre (respectivement en passe haut et passe bas) afin d’utiliser la technique du filtre complémentaire. Pour l’instant, (après pas mal de tests) le temps de stabilisation du filtre se situe aux alentours de 20 secondes (ce qui est un peu long quand même !). De plus, la moyenne des signaux filtrés n’est pas centrée en 0 (ce qui est embêtant pour l’utilisation du LQR par la suite…).

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à.