1.2 Conversions bas niveau

Les impulsions qui sont comptées par le LM ne correspondent à aucune réalité physique. Or, pour faciliter la mise en oeuvre et la compréhension du système, il est pratique d'utiliser en haut niveau des unités courantes (m, cm, mmm...). De plus, on a constaté une dissymétrie entre les deux roues codeuses et on a dû introduire un facteur correctif. Là aussi, il est plus convivial de ne pas avoir à se soucier de ce facteur en haut niveau.

D'autre part, le câblage et le montage des moteurs et des roues codeuses peuvent faire que les signes soient plus ou moins n'importe quoi. Or, on aimerait bien lorsqu'on dit aux deux roues d'avancer de 10 cm, qu'elles avancent (Je dis bien avancent et non reculent) de 10 cm. Ce qui est loin d'être gagné au départ.

C'est pourquoi, on a implémenté dans le DSP une sorte de couche bas niveau qui permet de convertir les données brutes en informations classiques et vice-versa. Les fonctions ou macros ainsi écrites permettent d'accéder à l'asservissement sans trop se soucier des conversions d'unités une fois que tout les paramètres de la couche basse sont bien réglés.

1.2.1 Conversion des distances

La seule unité de distance que le LM connaisse est ce que nous allons appeler le count. Ainsi avec une roue codeuse de 500 points, le LM s'incrémente de 2000 counts en un tour de roue. En haut niveau, on souhaite n'utiliser que des unités classiques ; le millimètre a été retenu bien qu'après coup le mètre eu été préférable.

Notons $N$, le nombre de points que possèdent une roue codeuse. Le LM est alors capable de décoder $4 \times N$ counts sur cette roue codeuse. Donc un déplacement de $4N$ counts correspond à un déplacement effectif de la roue d'une distance équivalente à sa circonférence qui vaut $\pi D$ où $D$ représente le diamètre de la roue codeuse.

La constante qui est utilisée dans le DSP pour les conversions de distances est COUNT_PER_MM qui représente le nombre de counts produits par le LM lorsqu'une roue codeuse avance d'un millimètre. Son unité est donc le count/mm. Pour déterminer cette constante, il suffit de faire avancer le robot de 2 m par exemple, de regarder le nombre de counts produits et d'en déduire la valeur du COUNT_PER_MM. Cette valeur est commune aux deux roues codeuses et correspond à la moyenne des valeurs de cette constante pour chaque roue.

Comme on l'a déjà dit et répété, il y a une dissymétrie entre les circonférences des deux roues codeuses et c'est pour cette raison que l'on a introduit le facteur de correction SYM_LM ^1.4. Une valeur positive de cette constante permet de corriger une dérive du robot vers la droite. Pour être ajustée, cette valeur nécessite beaucoup de tests. L'une des techniques les plus fiables consiste à faire effectuer au robot une trajectoire rectangulaire qui suit des lignes ^1.5. Si au bout d'un certain nombre de tours le robot coupe les lignes de la gauche vers la droite, alors il faut augmenter la valeur du SYM_LM.

Avant de modifier la valeur de la constante, il faut s'assurer de la répétabilité de l'opération. Il est bon de refaire au moins 2 fois la même expérience pour d'affranchir des erreurs de calage au départ ...et pour dégager une tendance moyenne. Une fois que le SYM_LM est correctement réglé, on peut avoir une dérive qui reste limitée sur la durée souhaitée et qui surtout est alors aléatoire. On peut estimer que le robot est bien calibré quand :

• L'erreur reste minime sur 1'30 (< quelques cm). Si ça n'est pas le cas, il est bon d'examiner pourquoi. Les roues codeuses sont les premiers éléments à tester (Suspension, Écrasement, Libre rotation, Jeu latéral ...)
• Sur plusieurs expériences, on va un coup à droite, un coup à gauche, etc. Dans ce cas l'erreur n'est pas répétable, et il ne reste plus qu'à faire des offrandes à Murphy^1.6 pour essayer d'améliorer les choses.

Ces deux conversions ont été regroupées en deux constantes :

COUNT_PER_MM_D = COUNT_PER_MM*(1-SYM_LM)
COUNT_PER_MM_G = COUNT_PER_MM*(1+SYM_LM)

Ainsi, dès que l'on veut envoyer une distance au LM il suffit de la multiplier par l'une de ces valeurs. Et inversement, quand on récupère une donnée du LM, il faut la diviser par l'une de ces constantes pour retrouver une valeur en mm.

ATTENTION : Toutes les valeurs qui sont transmises au LM sont des entiers alors que les calculs sont fait en virgule flottante sur le DSP et ceci pour des raisons de précision. Il ne faut donc pas oublier de les convertir avant de les envoyer.

1.2.2 Conversion des vitesses

La seule unité de vitesse que le LM connaisse est le count/sample. Curieuse unité me direz-vous alors essayons d'éclaircir la chose. Le count, on a déjà vu avec les distances. Maintenant qu'est que le sample. Le sample est l'unité de temps du LM, elle correspond à la période de la boucle d'asservissement qui est de $2048/f_{CLK}$ où $f_{CLK}$ est la fréquence de l'oscillateur qui pilote le LM. Donc, pour un oscillateur à 8 MHz, un sample correspond à 256 $\mu$s. Dans le code DSP, cette constante a été appelée SAMPLING_PERIOD et son unité est la seconde/sample.

Mais la ruse du LM ne s'arrête pas là. En fait, lorsque l'on charge une vitesse dans le LM, on l'envoie sur 32 bits. Or, seuls les 16 bits de poids forts correspondent à des counts/sample alors que les 16 bits de poids faible correspondent à la partie décimale.

Si on dispose d'une vitesse v_DSP en cm/s que l'on souhaite l'envoyer au LM droit sur 32 bits dans v_LM, il faut appliquer la formule suivante pour la convertir :

v_LM = v_DSP * 10 * COUNT_PER_MM_D * SAMPLING_PERIOD * 65536

Si on récupère une vitesse du LM sur 32 bits et que l'on veut la convertir en cm/s, on appliquera :

v_DSP = v_LM / (10 * COUNT_PER_MM_D * SAMPLING_PERIOD * 65536)

ATTENTION : Les vitesses envoyées au LM sont sur 32 bits et certaines de celles que l'on peut récupérer sont sur 16 bits seulement. Dans ce cas, il ne faut pas oublier de décaler de 16 bits vers la droite la valeur récupérée. Lorsque l'on, ne récupère que 16 bits, il s'agit des 16 bits de poids forts dont l'unité est le count/sample.

1.2.3 Conversion des accélérations

Comme pour la vitesse, le LM ne connaît que des accélérations en counts/sample/sample. Et là aussi les 16 bits de poids forts correspondent à la partie entière et les 16 bits de poids faible à la partie décimale.

Si on dispose d'une accélération a_DSP en cm/s$^2$ que l'on souhaite l'envoyer au LM droit sur 32 bits dans a_LM, il faut appliquer la formule suivante pour la convertir :

a_LM = a_DSP * 10 * COUNT_PER_MM_D * SAMPLING_PERIOD * SAMPLING_PERIOD * 65536

Si on récupère une vitesse du LM sur 32 bits et que l'on veut la convertir en cm/s, on appliquera :

v_DSP = v_LM / (10 * COUNT_PER_MM_D * SAMPLING_PERIOD * SAMPLING_PERIOD * 65536)

ATTENTION : Là aussi le LM renvoie dans certains cas les accélérations sur 16 bits.

Ces routines de conversion bas niveau permettent de s'abstraire légèrement du matériel dans le code de traitement. Cependant, nous avons commencé un peu tard à vouloir faire une couche de conversion bas niveau si bien qu'elle n'est pas vraiment opérationnelle et que l'on retrouve souvent les formules de conversion au milieu du code. Ces conversions gagneraient sans doute à être intégrées dans des routines bas niveau d'accès au LM.