L’informatique

Architecture générale :

On a vu dans la partie électronique que le robot ne possède aucune intelligence ni aucun capteur. Ses déplacements sont complètement pré-programmés par l’intermédiaire d’un fichier binaire qui contient les positions des servos. Choisir la position des servos est donc relativement simple. Ce qui est plus délicat, c’est d’enchaîné ces positions afin d’obtenir des mouvements fluides. Le besoin au niveau informatique est donc : une interface permettant de dessiné à la souris le mouvement des pattes calculer le fichier binaire puis le télécharger dans la carte mémoire du robot.

Ce programme ce décompose en fait en trois interfaces principale :

- la première qui permet de dessiné à la souris un mouvement pour une patte (j’appelle ça une frame, fichiers .fra) Je me constitue ainsi une bibliothèque de mouvements élémentaires.

- la deuxième qui permet de programmer un déplacement complet en attribuant des frames aux six pattes (j’appelle ça un script, fichiers .scp).

- La troisième à pour rôle de calculer le fichier binaire à partir du fichier script. Elle permet également de télécharger ce fichier (nommé mouvement, fichiers .mvt) dans l’un des 16 segments de la carte mémoire.

Une condition impérative pour que cette interface fonctionne : avoir la loi de commande d’une patte. C’est à dire avoir les équations qui donnent la positions à appliqué aux deux servos en fonctions de la positions du bout de la patte dans un repère cartésien.

Loi de commande

Etant personnellement un peu faiblard en math (surtout en trigo à la X-Files) j’ai demandé à un copain de me calculer la loi de commande (grand merci à BB, homme de génie). Tous ce que je sait, c’est que c’est basé sur les Matrices Jacobienne. Pour donner une idées de l’aspect des équations, voici celles de Moumoute :

Equations.doc

On se retrouve donc avec deux équations, une pour chaque servo qui donnent l’angle des têtes de servos en fonctions de X et Y.

Les angles sont exprimés en Radian, il faut donc les traduire en « octet position ». Pour cela, il faut d’abord caractériser individuellement chaques servos car évidemment aucun ne donne la même position pour la même commande. Pour caractériser un servos, il suffit de demander à la patte deux positions « connues » et de mesuré la largeur de l’impulsion de commande. Ces positions connues sont des positions pour lesquelles on connaît l’angle de la tête de servo. J’ai choisi les positions extrêmes du diagramme de mouvement (cf partie mécanique) pour lesquelles j’ai mesuré les angles sur le plan CAO. Connaissant angle1 = octet1 et angle2 = octet2, j’en déduit la relation octet = offset + facteur x angle.

Pour que cette caractérisation soit rapide, j’ai fait une interface qui permet de piloter la position de chaque servo avec un curseur :

Il y a un curseur par servo, la valeur prise par le curseur est directement la largeur de l’impulsion (comme ça, pas besoin d’oscilloscope !) Pour que la position soit actualisée en temps réel en fonction du curseur, il faut bien sur charger un programme spécifique dans le µcontrôleur. Pour matérialisé les positions caractéristique à atteindre, j’ai fabriqué un outil spéciale : le caractériseur ! ! ! ! J’ai imprimer sur une feuille autocollante les diagrammes de mouvement dessiné en CAO. J’ai coller cette feuille sur une plaque (isorel®) sur laquelle j’ai également fixé deux axes verticaux qui viennent remplacer les axes des hanches. Je caractérise donc deux pattes à la fois, je sauve le résultat dans un fichier de calibration qui sera utilisé ensuite pour le calcul des octets positions. Le servo de translation est également caractérisé mais c’est beaucoup plus facile, une règle graduée suffi…

Etape 1 : faire bouger une patte

Comme expliqué plus haut, la première étape dans la fabrication d’un programme pour Moumoute est de décrire chaque mouvement élémentaire pour chaque patte. La première interface est donc un outil de dessin de déplacement de patte :

Première chose qui saute aux yeux : y en a deux ! C’est très pratique car bien souvent pendant un pas, le déplacement d’une patte et le même que celui de ça voisine mais inversé ou décalé d’un segment.

Ceux qui ont lu la page mécanique ont reconnu le diagramme de mouvement de la patte. L’origine étant en haut à gauche, il suffit de cliquer dans le diagramme pour obtenir les coordonnées cartésiennes du pied dans le repère utilisé par les équations de la loi de commande (relire cette phrase plusieurs fois avant de continuer ;o) On pose ainsi un point de passage du pied. Lorsqu’on clique une deuxième fois, le programme relit le premier et le deuxième point par une droite, on a ainsi défini un segment du mouvement de la patte. On peut définir jusqu'à 30 segments par frame. Facile non ?

Au fur et a mesure, le programme écrit les coordonnées des extrémité de chaque segment. Les points intermédiaires (les segment eux mêmes) ne sont pas encore calculé. Cette étape ne sera réalisée qu’a la fin, au moment de convertir le script en fichier mouvement. Pour définir le nombre de point intermédiaire d’un segment, on dispose d’un curseur « vitesse » (en bas à droite). l’ordinateur calcul la longueur du segment puis la divise par la vitesse. Le nombre de pas ainsi calculé et écrit à côté des coordonnées cartésienne du point à atteindre. Une ligne d’un fichier frame se lis donc « atteins le point X,Y en faisant N pas ». La vitesse de base (10) correspond à 1 point tous les millimètres. Sachant que je peut donner 50 points par seconde aux servos, cela fait 5cm/s (ce qui est lent !). La vitesse maxi est d’environ 40 = 4mm entre deux points = 20cm/s.

Dans beaucoup de cas, il est nécessaire de synchroniser le début et la fin des segments fait par les 6 pattes alors que ces segments ne sont pas de même longueur. Il y a par exemple des phases d’attente où 3 pattes ne bouge pas pendant que les 3 autres changent de position. Il est donc nécessaire de pouvoir imposer de nombres d’étape pour réaliser un segment. C’est à ça que sert le bouton « imposer nb step = ». Lorsqu’on clique dessus, le facteur vitesse est inactif, la valeur du champ à côté du bouton est simplement recopiée.

L’interface permet également d’éditer une frame déjà enregistrée, de la modifier et de la sauver avec un autre nom. Pour modifier, il suffit de double-cliquer sur un point dans la liste, les deux segments ayant ce point pour extrémité deviennent bleu et suivent le pointeur de la sourie, on repositionne le point simplement en cliquant sur le diagramme.

Pour être honnête, la convivialité de cette interface (et des autres) n’est pas parfaite ! Certaine fois, il faut vachement se creuser les méninges pour créer un pas (le pas en crabe par exemple : je l’ai refait dix fois, j’en ai chier à chaque fois !!). Mais bon, lorsqu’on a pigé l’esprit du truc, on va assez vite : dix minutes pour créer un nouveau pas et l’intégrer dans un mouvement.

Etape 2 : Construction d’un programme de déplacement

Cette interface à pour rôle d’attribuer les frames à chaque patte pour faire un pas et d’enchaîner ces pas pour faire un déplacement. Elle est Largement plus compliqué que la précédente :

Entrons dans le détail (allez, un peu de courage !) :

Zone centrale, les chronogrammes :

Chaque ligne représente le temps pour une patte (P0 / ARD veux dire Patte n°0 / Patte arrière droite ). La septième c’est le servo translation. Chaque instruction donnée à une patte sera représentée par une boite de couleur dont la largeur représente son temps d’exécution. A droite des chronogrammes, on trouve des compteurs qui indiquent le nombre totale de points attribués à chaque patte (pour un match il y a 90 secondes x 50 points/sec = 4500 step). Il faut évidemment que les 7 compteurs indique la même valeur pour qu’un programme soit « calculable » (de toute façon, si c’est pas bon, le logiciel insulte l’utilisateur !).

A gauche, la bibliothèque de frame :

On peut ouvrir jusqu'à 8 frames simultanément. Lorsqu’on a ouvert un fichier .fra, le mouvement est représenté sur le petit diagramme gris, la liste des points apparaît dans la boite de couleur, les coordonnées de début, de fin et la durée (nombre de step) sont indiqués sous le bouton « open ».

Pour attribuer une frame à une patte, on valide la patte (ou les pattes) et cliquant sur le bouton à gauche du chronogramme. On double clique ensuite sur le dessin de la frame. La frame est alors ajoutée au chronogramme de la patte en utilisant la couleur de la boite qui contient la liste des points.

Pour faire un pas en crabe, il faut ouvrir quatre frames : une pour milieu droit, une pour milieu gauche, une pour avant droit et arrière droit (elle font la même chose), une pour avant gauche et arrière gauche.

Dans la marche en crabe, le servo translation ne sert pas. Pour un pas en avant il faut programmer ce servo en utilisant cette zone :

A gauche est indiqué la position du servo de 0 à 80, à droite le nombre de step (points intermédiaires). Pour attribué une position et un nombre de step au servo translation, il suffit de double-cliquer sur une lignes. On peut donc prédéfinir quatre couples position/nombre de step (en générale on en a besoin que de 2 !)

A la position 0, les deux triangles sont translatés aux maximum dans un sens. A 80 ils sont translatés aux maximum dans l’autre sens. 40 représente donc la position neutre dans laquelle les pattes droites et gauches sont alignées. 80 correspond à 8cm mais attention, c’est compliqué : une translation fait 8cm, à chaque translation le corps du robot se déplace de 4 cm, un pas est composé de deux translations et fait donc 8cm (faites un dessin !!!).

On voit donc que fabriquer un pas demande beaucoup de manipulation. Pour ne pas avoir à refaire cent fois la même chose, la dernière zone :

En bas à droite, le gestionnaire de pattern :

Une pattern c’est un script !

C’est quoi un script ? Suivez un peu : On est dans l’interface qui permet de les faire ! C’est un mouvement du robot (6 pattes + translation) pas encore traduit en fichier binaire.

Une pattern est donc un pas élémentaires (1 pas en avant rapide, 1 pas en crabe, 1 mouvement de tangage…) ou un assemblage de pas (marche en avant de 40 cm, rodéo, homologation…). Cette notion « hiérarchique » de pattern permet de construire très rapidement un nouveau programme en assemblant des briques de bases plus ou moins grosses. Par exemple, tout mes programmes de match commençaient par la brique homologation (fichier Pattern homologation.scp) qui consistait à renverser le premier palet.

Pour attribuer les pattern c’est très simple : on choisit un fichier pattern avec « open », le nom du fichier s’inscrit alors dans la zone en couleur (il vaut mieux avoir des noms de fichiers qui veulent dire quelque chose !!!). Lorsqu’on clique sur ajouter, la pattern est attribuées aux 7 chronogrammes avec la couleur de la boite nom_du_fichier.

Etape 3 : Calculer et télécharger un programme