Langage pour le contrôle d'atomes robotiques
HoRoCoL (Homogeneous Robotic Component Language) est une approche langage pour la programmation des agents. L’objectif est de pouvoir décrire dans un formalisme textuel la suite des actions et des synchronisations que devront faire les agents durant l’exécution d’une tâche.
Cette page illustre le langage HoRoCoL dans le contexte du projet MAAM. Un atome robotique est vu comme un agent.
Les premiers jalons de ce langage ont été posé. Ils s’appuient sur l’API dont l’étude préalable était nécessaire afin de connaître le type d’objet informatique manipulé par le langage. Chaque molécule offre une vision synchrone et centralisée au programmeur (point de vue macroscopique). Le mécanisme de compilation permet de passer de cette vision à une exécution asynchrone et répartie (point de vue microscopique). Par ailleurs, un modèle où le même code peut s’exécuter sur des structures aux propriétés topologiques identiques mais de tailles différentes à été retenu.
Le langage HoRoCol est construit au dessus d’un noyau classique de langage séquentiel (variables scalaires, affectation, conditionnelle, boucle). La partie vectorielle du langage permet la manipulation concurrente d’atomes. A cette fin, des structures de contrôle spécifiques (where, loop parallèle, ;, parofseq, seqofpar) sont proposées. Le code s’exécute implicitement sur l’ensemble des atomes actifs. Lorsque du code doit être appliqué à un sous ensemble de la molécule, il suffit de d'activer la sous partie souhaitée via la construction where. Contrairement à un if séquentiel qui n’exécute qu’une de ses branches, le where permet l’exécution concurrente de 2 programmes s’appliquant à des sous ensembles distincts de la molécule. De plus le where ne termine que lorsque tous les atomes ont terminé l’exécution de leur branche. On a donc une synchronisation implicite en fin de where.
Pour une présentation détaillée du langage, voir ici.
Pour illustrer l'utilisation d'HoRoCol avec les atomes robotiques, on souhaite faire marcher une rangée d'atomes robotiques durant un certain temps. Il est nécessaire de manipuler deux types d'agents différents et donc de connaître leur API de contrôle de bas niveau.
La figure 1 nous montre une version simplifiée de l'API MAAM. Elle permettra d'illustrer l'exemple qui suit. La version complète de l'API est disponible à l'adresse http://michel.dubois.ubs.chez.com/index_API2.htm. Cette API est définie dans un programme HoRoCoL à l'aide du fichier MAAM.xml.
Figure 1
La figure 2 nous montre l'API des agents de type Clock. Elle est décrite dans un programme HoRocol à l'aide du fichier Clock.xml.
Figure 2
Dans cet exemple, la programmation au niveau social consiste à l'instanciation de tous les agents, à leur initialisation et à l'exécution en parallèle de deux programmes concernant chaque type d'agent. On considère, comme état initial, une rangée d’atomes interconnectés ayant leurs servo-moteurs dans leur position canonique i.e. les pattes des atomes sont toutes centrées (voir figure 3a). Pour faciliter la compréhension du code, on suppose que l'on dispose dans l'environnement de programmation des constantes left, right, qui désignent respectivement le numéro des pattes gauches et droites qui sont au sol. De même les constantes min, middle et max désignent respectivement les positions minimale, canonique et maximale d'un servo-moteur.
import MAAM.xml; // declaration file of the maam agent type
import Clock.xml; // declaration file of the clock agent type
programHorocol walking_row_with_timeout { // the goal for the row is to walk during 3 minutes
type maam use MAAM.xml; // association of the maam agent type with its xml interface
type clock use Clock.xml; // association of the maam agent type with its xml interface
maam a1, a2, a3 = newAgent(maam); // instanciation of 3 agents with the maam type
clock watch=newAgent(clock); // instanciation of 1 agent with the clock type
... // construction of the initial state of each agent :
... // - a row of 5 interconnected atoms with all legs centered;
... // - a clock with the current time.
||(°p_row°,[p_clock]); // run in parallel 2 control programs
}
Le programme p_clock ordonne à l'agent watch de faire un compte à rebours pendant 3 minutes. Le fichier Clock.xml définit la méthode waitOneSeconde() pour les agents de type Clock. Au bout des 3 minutes, le programme p_clock se termine, ce qui provoque la terminaison du programme p_row qui a été lancé en mode interruptible.
int time=180; // time is a shared variable for clock typed agents
parofseq(clock) {
where (true) {
while (time>0){
waitOneSecond(); // send message to agent watch
time--;
}
}
}
L’algorithme itératif présenté dans le programme p_row décrit le calcul permettant à cette dernière d’avancer (1 itération = 1 pas pour l’ensemble des atomes). Son invariant est qu'à chaque itération, les pattes se mettent d'abord en position arrière. Il comporte 3 phases qui peuvent se répéter indéfiniment :
la première étape consiste à positionner la rangée toutes pattes en arrière (voir figure 3.b);
la deuxième étape consiste à lever puis à poser les pattes gauches en avant pour les atomes impairs et lever puis poser les pattes droites en avant pour les atomes pairs (voir figure 3.c);
la dernière étape permet de lever puis poser les pattes restantes en avant (voir figure 3.d).
Pour la première étape, il n'est pas nécessaire de lever les pattes. Aucun synchronisme entre pattes est exigé : on utilisera la construction parofseq. Afin de maintenir la rangée en équilibre, il est nécessaire de ne lever au plus qu’une patte sur 2 par atome à un instant donné. Les deux dernières phases exigent un synchronisme entre agents. On a donc une séquence de 2 seqofpar. La figure 3.b montre l’état de la rangée avant le premier bloc seqofpar. La figure 3.c montre l’état de la rangée avant le deuxième bloc seqofpar.
Lorsque le but est atteint ( ici marcher pendant 3 minutes), le programme sort de la boucle infinie while portant sur les atomes de la rangée.
On voit que cet algorithme est adapté à des rangées de taille quelconque.
Figure 3
Le code du programme p_row est le suivant :
while (true) {
parofseq(maam){
// put all legs on ground in back position
where (true) {
getLeg(left).moveTo(min,min);
getLeg(right).moveTo(min,min);
}
}
// the synchronized walk can start when all the agents have their legs on the ground behind
seqofpar(maam){
// lift, put at 45° ahead and descend the left legs for the odd atoms.
where (maam.getID() % 2==1) {
getLeg(left).moveTo(min,middle);
getLeg(left).moveTo(max,middle);
getLeg(left).moveTo(max,min);
};
// lift, put at 45° ahead and descend the right legs for the even atoms.
where (maam.getID() % 2==0) {
getLeg(right).moveTo(min,middle);
getLeg(right).moveTo(max,middle);
getLeg(right).moveTo(max,min);
};
}
// All the legs on ground have to be in front
seqofpar(maam){
// lift, put at 45° ahead and descend the right legs for the odd atoms.
where (maam.getID() % 2==1) {
getLeg(right).moveTo(min,middle);
getLeg(right).moveTo(max,middle);
getLeg(right).moveTo(max,min);
};
// lift, put at 45° ahead and descend the left legs for the even atoms.
where (maam.getID() % 2==0) {
getLeg(left).moveTo(min,middle);
getLeg(left).moveTo(max,middle);
getLeg(left).moveTo(max,min);
};
}
}
Publication :
CLAWAR 2003 :
"Control of Interconnected Homogeneous Atoms: Language and Simulator"
- pages 391-398
- M. Dubois, Y. Le Guyadec and D. Duhaut
- Proceedings of the 6th International Conference on Climbing and Walking Robots and the Support Technologies for Mobile Machines
- Edited by Giovanni Muscato & Domenico Longo
- Professional Engineering Publishing Limited, Bury St Edmunds and Londo, UK