Aseba Manuel de l`utilisateur Français - MOBOTS

1
ASEBA
Manuel de l'utilisateur
Français
Table des matières
Introduction
Didacticiel
Studio
Language de script
2
3
7
9
Stéphane Magnenat
Version du festival de robotique de l'EPFL, édition 2008
2
Introduction
ASEBA est un système pour prototyper rapidement le comportement de microcontrôleurs connectés en un réseau. Dans
le contexte de la robotique, les microcontrôleurs peuvent soit
être chacun un robot, soit être tous dans le même robot. De
plus, les robots et les microcontrôleurs peuvent aussi être
virtuels et fonctionner dans un simulateur, comme c'est le
cas dans challenge (Page 3).
Avec ASEBA, vous écrivez et debuggez vos programmes à
partir d'une application unique (Page 7) en utilisant un language de script de haut niveau (Page 9). Puis ASEBA compile le
script en bytecode et le charge sur les microcontrôleurs à travers le bus de communication.
Les microcontrôleurs exécutent le bytecode dans des machines virtuelles qui fournissent aussi un debugger intégré.
Les machines virtuelles assurent une exécution sûr (aucune
erreur de script ne peut perturber le microcontrôleur) et une
indépendance envers le fabricant (tout microcontrôleur 16
bits ou mieux est suffisant).
Les microcontrôleurs communiquent entre eux par des
messages asynchrones diffusés, que nous appelons événements. Ces messages peuvent également contenir des données. Cette architecture est avantageuse par rapport à un
modèle client/serveur car elle supporte une large plage de
stratégies de contrôle et de communication.
ASEBA est un logiciel libre, ainsi la communauté peut l'utiliser et le modifier librement. Vous trouverez plus d'informations sur la dernière version sur :
http://mobots.epfl.ch/aseba.html
3
Didacticiel
Pou r commencer
ASEBA challenge (Figure 1) est un
monde simulé où des robots contrôlés
par ASEBA cherchent de la nourriture.
Vous pouvez l'utiliser comme espace de
jeu pour écrire des scripts ASEBA ou
comme un jeu éducatif pour apprendre
ou enseigner la programmation.
Pour démarrer, vous devez lancer
ASEBA challenge, puis cliquer sur «Ajouter
un robot» et lui choisir un nom. Si vous
êtes un groupe, il faut ajouter un robot
pour chaque joueur. Vous pouvez enlever
tous les robots en cliquant sur «Enlever tous les robots».
Vous pouvez cacher les boutons en cliquant sur «Cacher
auto» : les boutons ne seront visibles que lorsque le curseur
de la souris sera proche. Vous pouvez laisser la caméra
bouger automatiquement en cliquant sur «Caméra auto». Si
vous bougez la caméra manuellement, les contrôles sont les
suivants :
• ctrl + bouton gauche souris : rotation
• ctrl + maj. + bouton gauche souris : déplacement sur x/y
• ctrl + maj. + bouton droite souris : déplacement sur z
Challenge affiche le score de chaque robot sur des
tableaux translucides suspendus au dessus de l'arène. Le but
de chaque robot est de rester vivant en collectant de l'énergie. Tant que le robot est vivant, ses
points augmentent ; quand il meurt, ils
sont divisés par deux. Quatre sources
d'énergie bleues nourissent les robots à
proximité. Quand une source est vide, elle
devient rouge et ne fournit plus d'énergie.
De temps à autres, une source plonge
dans le sol et les robots ne la voient plus
jusqu'à ce qu'elle réapparaisse.
Une fois qu'ASEBA challenge fonctionne,
vous devez démarrer ASEBA studio (Figure 3) pour programmer votre robot. Pour
chaque robot, vous devez lancer une instance de studio, qui peut être sur n'importe quel ordinateur (Figure 2). Nous
donnons une description détaillée de studio en page 7.
Figure 1
ASEBA
challenge
Figure 2 dialogue de
connection d'ASEBA studio
Figure 3
ASEBA
studio
4
Votre premi er contrôl l eu r d e robot
robot
ordinateur
Pour programmer un robot, vous devez d'abord comprendre comment il fonctionne. Un robot interagit en boucle avec
capteurs
actuateurs
le monde : il perçoit son état à grâce à ses capteurs, prends
des décisions avec son ordinateur intégré, et effectue des acmonde
tions avec ses actuateurs ; ces actions changent l'état du
monde, et le robot perçoit ce nouvel état au moment où il lit
Figure 4 Un robot interagit en
ses capteurs à nouveau (Figure 4).
boucle avec le monde à travers ses
Dans challenge, vous programmez un robot e-puck simcapteurs et ses actuateurs.
ulé. Il possède 8 capteurs de proximité répartis autour de
son corps et une caméra simplifiée pointée en avant et composée de 3 pixels de 20° d'ouverture chacun. Vous pouvez
lire ces valeurs et aussi choisir la vitesse des roues (Figure 5).
Écrivons maintenant votre premier contrôlleur de robot. Nous donnons une description
prox[7]
prox[0]
du language de script d'ASEBA en page 9. Dans
l'éditeur de texte au milieu de la fenêtre de
prox[6]
camX[1]
prox[1]
studio, écrivez les lignes suivantes :
camX[0]
camX[2 ]
prox[5 ]
prox[2 ]
leftSpeed = 5
rightSpeed = -5
Cliquez «Charger» et puis «Lancer». Vous devriez voir votre robot tourner sur place. Ce
code ne fait que spécifier la vitesse des roues
au démarrage du robot puis ne fait rien. Pour
avoir un meilleur comportement, il nous faut
prox[4]
prox[3 ]
permettre au robot de percevoir son environFigure 5. Les capteurs et les acnement, par exemple les obstacles ; et prendre des décisions,
par exemple éviter les obstacles.
tuateurs du robot e-puck simulé
Pour interagir avec le monde en continu, le robot doit exdans challenge.
écuter un script périodiquement. Ceci est possible grâce au
Les capteurs de proximité,
prox[0] à prox[7], retournent la
mot clé ontimer. Par exemple, en utilisant un capteur de
proximité avant, nous pouvons spécifier la vitesse des roues
distance en cm [0..12] aux
obstacles dans une direction spécien fonction de la distance à l'objet devant le robot :
fique, indiquée par une ligne pointillée.
ontimer
La caméra se compose de trois
leftSpeed = prox[0] - 6
rightSpeed = prox[0] - 6
pixels, camX[0] à camX[2], pour
chaque composante de couleur X
(R, G ou B — rouge, vert, bleu), et
Comme les capteurs de proximité retournent des distances
retourne le pourcentage [0..100]
entre 0 et 12 cm (si l'objet est plus loin que 12 cm, ils rede la composante correspondante
tournent quand même 12), la vitesse du robot sera de
-6 cm/s quand l'objet est proche, 0 cm/s quand l'objet est à
dans un arc donné limité par les
6 cm de distance, et 6 cm/s quand l'objet est éloigné. Le rolignes traitillées.
bot aura donc tendance à rester à 6 cm de tout objet devant
Les roues permettent au robot de
se déplacer et vous pouvez spécilui.
fier leurs vitesses (leftSpeed et
rightSpeed) en cm/s [0..13].
leftSpeed
rightSpeed
5
Un contrôlleur de robot plus élaboré
Garder une distance de sécurité à l'objet devant le robot
est une bonne chose, mais pour l'instant le robot ne peut pas
aller ailleurs. Pour faire que le robot se promène, nous
devons comprendre son principe de déplacement.
Le robot e-puck simulé dans challenge est de type robot à
roues différentielles ; ce type de robot choisit sa direction en
fixant des vitesses différentes à ses roues gauche et droite
(Figure 6). Si chaque roue a la même vitesse, le robot va en
avant ; sinon il tourne ; si les vitesses sont opposées, le robot
tourne sur place. Les véhicules à chenilles comme les pelleteuses de chantier utilisent le même principe.
Écrivons maintenant un petit code qui permet au robot
d'éviter les obstacles et d'aller tout droit s'il n'y en a aucun :
ontimer
leftSpeed = prox[1] - 6
rightSpeed = prox[6] - 6
Ce contrôleur lit la valeur des capteurs de proximité avant
gauche et droite. Tant qu'il n'y a pas d'obstacle, tant prox[1]
que prox[6] retournent 12 et donc le robot avance tout
droit à vitesse 6. Mais lorsqu'il y a un obstacle d'un côté, la
valeur du capteur correspondant descend. Par exemple, s'il y
a un obstacle à gauche, prox[6] (qui regarde à gauche) pourrait valoir 10 alors que prox[1] (qui regarde à droite) restera
à 12 ; et donc leftSpeed vaudra encore 6 mais rightSpeed
vaudra 4, ce qui fera tourner le robot à droite et donc éviter
l'obstacle présent à gauche.
Prendre des décisions
Les contrôleurs que nous avons vus jusqu'à maintenant liaient les valeurs des capteurs aux vitesses des roues à travers des expressions mathématiques, mais ne prenaient pas
de décision de type «si, alors». Néanmoins c'est parfois désirable ; par exemple lorsque nous voulons que le robot aille
soit tout droit, soit qu'il tourne sur place, et non pas qu'il
fasse des trajectoires courbes, nous pouvons écrire :
ontimer
var dists = prox[6] + prox[7] + prox[0] + prox[1]
if dists < 48 then
leftSpeed = 5
rightSpeed = -5
else
leftSpeed = 5
rightSpeed = 5
end
leftSpeed ==
rightSpeed
leftSpeed >
rightSpeed
Figure 6. La trajectoire du robot
change en fonction de la
différence de vitesse entre les
roues gauche et droite.
6
Ce contrôleur somme les distances à tous les capteurs de
proximité avant, et si cette somme est inférieur à 48 cm (ce
qui signifie qu'au moins un capteur voit un obstacle), le robot tourne sur place. Sinon il va tout droit.
Le language de script fournit aussi d'autres constructions
intéressantes, comme la boucle while qui exécute un bloc
de code plusieurs fois tant qu'une condition est vraie, ou la
boucle for qui exécute un bloc de code un certain nombre de
fois et change la valeur qu'une variable à chaque fois. Les
pages 9 et 10 listent toutes les constructions disponibles ;
n'hésitez pas à aller les voir.
Votre tour
Jouez un moment avec l'évitement d'obstacle afin de bien
comprendre les capteurs, les actuateurs, et la dynamique du
robot. N'hésitez pas à essayer des choses, le robot est dans
un simulateur et donc ne risque rien.
Une fois que vous vous sentez à l'aise, essayez de programmer le robot pour qu'il se dirige vers les sources de
nourriture quand elles sont bleues (0, 0, 100) (en rouge, vert,
bleu), et de les éviter quand elles sont rouges (100, 0, 0). Les
murs de l'arène sont gris (50, 50, 50). Essayez de jouer avec
vos amis et de programmer le meilleur contrôleur de robot.
Vous pouvez changer la couleur de votre robot (en modifiant
les variables colorR, colorG et colorB), et donc feindre
d'être une source de nourriture. Si les autres trompent votre
robot de cette façon, vérifiez la variable energy ; si sa valeur
n'augmente pas alors que le robot voit du bleu, c'est qu'un
autre robot le trompe.
Le but de challenge est d'apprendre la robotique, la programmation et ASEBA tout en s'amusant.
7
Studio
1
5
2
6
7
4
3
8
ASEBA studio est un environnement de développement intégré dans lequel nous éditons et debugons les scripts pour tous
les microcontrôleurs (Figure 7). Il fournit les fonctionnalités
suivantes :
• Édition concurrente. Chaque microcontrôleur possède son
propre onglet avec son script, le contenu de sa mémoire,
son statut d'exécution et ses commandes de debug. De plus,
une barre fournit des commandes générales de debug qui
affectent tous les microcontrôleurs. Ceci permet à la fois un
contrôle global de tous les microcontrôleurs et un contrôle
particulier de chacun.
• Colorisation de syntaxe. L'éditeur de script colorise la syntaxe et affiche les erreurs en rouge. Ceci améliore la lisibilité
des scripts.
• Compilation instantannée. Studio recompile les scripts
pendant que le développeur les écrit. Le résultat de la compilation (succès ou description de l'erreur) est affiché sous
l'éditeur. Ceci permet la correction des erreurs dès qu'elles
apparaissent, ce qui améliore la qualité du code.
• Inspection des variables. Studio liste les variables disponibles sur chaque microcontrôleur avec leurs valeurs. Nous
pouvons mettre à jour cette liste en un click. Cette liste
Figure 7. Photo d'écran d'ASEBA
studio. Les éléments entourés sont
les suivants :
1. Barre des commandes générales
de debug et onglets des microcontrôleurs
2. Éditeur avec colorisation syntaxique
3. Bar des messages de la compilation instantannée
4. Contenu de la mémoire avec le
nom des variables et leurs valeurs
5. Commandes de debug spécifiques au microcontrôleur
6. Définitions des constantes
7. Définitions et journal des événements
8. Documentation des fonctions
natives
8
fournit une vision rapide de l'état du microcontrôleur.
• Debugger. Studio intègre un debugger ; pour chaque microcontrôleur, il donne l'état courant d'exécution. Ce debugger
supporte l'exécution continue, pas à pas, ainsi que les
points d'arrêts. Un click droit dans l'éditeur de script permet de mettre ou d'enlever un point d'arrêt sur une ligne
donnée. Après un point d'arrêt ou un pas, les valeurs des
variables sont mises à jour.
• Événements. Nous pouvons spécifier les noms des événements, et, en double-cliquant sur un nom, nous pouvons envoyer l'événement correspondant. Sous la liste des
événements, un journal affiche les événements récents avec
leur heure et leurs paramètres.
• Documentation des fonctions natives. Studio liste les fonctions natives disponibles sur chaque microcontrôleur. La
bulle d'aide de chaque fonction donne une brève documentation.
• Définition des constantes. Nous pouvons définir des constantes qui sont disponibles sur tous les microcontrôleurs.
9
Language de script
En utilisant ASEBA studio, nous programmons les microcontrôleurs en écrivant des scripts dans un language simple. Syntaxiquement,
ce
language
ressemble
à
matlab
;
sémantiquement, c'est un language de programmation impératif avec un seul type simple (nombres entiers signés sur 16 bits)
et des tableaux. Nous allons maintenant décrire ses fonctionnalités :
• Commentaires. Les commentaires commencent avec un # et
finissent à la fin de la ligne.
# commentaire
var b # autre commentaire
• Variables. Les variables font référence soit à des valeurs
scalaires, soit à des tableaux de valeurs scalaires. Les
valeurs sont comprises entre -32768 et 32767, ce qui correspond à la plage des nombres entiers signés sur 16 bits.
Nous pouvons accéder aux éléments des tableaux avec
l'opérateur parenthèse carrée ; l'index des tableaux commence à zéro.
var
var
var
var
• Expressions et assignations. Les expressions permettent
les calculs mathématiques et sont écrites en syntaxe mathématique infixée commune. L'assignation utilise le mot clé =
et affecte le résultat du calcul d'une expression à une variable scalaire ou à l'élément d'un tableau. ASEBA fournit les
opérateurs +, -, *, /, % (modulo), << (décalage à gauche) et
>> (décalage à droite). Les opérateurs de plus grande
précédence sont *, /, % ; suivis de + et - ; suivis de << et >>.
Pour évaluer une expression dans un ordre différent, nous
pouvons utiliser une paire de parenthèses afin de grouper
une sous-expression.
a = 1 + 1
b = (a - 7) % 5
b = b + d[0]
c[a] = d[a]
• Conditions. ASEBA fournit deux types de conditions : if et
when. ASEBA fournit les opérateurs ==, !=, >, >=, < et <=. Tant
if que when exécutent un bloc de code différent selon
qu'une condition est vraie ou fausse ; mais when exécute le
bloc correspondant à vrai seulement si la dernière évaluation de la condition était fausse et que l'évaluation courante est vraie alors que if exécute le code chaque fois que
la condition est vraie, et le mot clé else exécute un code si
la condition est fausse. Cette différentiation permet l'exécution de code seulement quand quelque chose change, ce qui
est très pratique pour les applications robotiques.
if a - b > c[0] then
c[0] = a
else
b = 0
end
a
b = 0
c[10]
d[3] = 2, 3, 4
when a > b do
leds[0] = 1
end
10
while i < 10 do
v = v + i * i
i = i + 1
end
for i in 1:10 step 2 do
v = v + i * i
end
• Boucles. Deux constructions permettent la création de
boucles : while et for.
Une boucle while exécute un bloc de code plusieurs fois
tant qu'une condition est vraie. La condition est de même
type que celle utilisée par if.
Une boucle for fait itérer une variable sur un intervalle d'entiers, avec en option une taille de pas.
var a[3] = 1, 2, 3
var b[3] = 2, 3, 4
var c[5] = 5, 10, 15
var d
call vecprod(a, b, d, 3)
call vecprod(a, c[0:2], d,3)
• Fonctions natives. Nous avons conçu le language de script
d'ASEBA simple afin de permettre une compréhension aisée
par des développeurs novices et pour implémenter la machine virtuelle efficacement. Pour implémenter des calculs
complexes ou lourds, nous fournissons des fonctions natives implémentées en code natif pour une exécution rapide.
Par exemple, une fonction native est la solution de choix
pour effectuer un calcul de produit scalaire.
Les fonctions natives sont sûrs, dans le sens qu'elles spécifient et vérifient les tailles de leurs arguments, qui peuvent
être des constantes, des variables ou des accès à des
tableaux. Dans ces derniers, nous pouvons accéder à tout le
tableau, à un élément discret ou à un sous-intervalle du
tableau. Les fonctions natives prennent leurs arguments par
référence et peuvent modifier leurs contenus, mais ne retournent aucune valeur. Les fonctions natives sont appellées
par le mot-clé call.
var run = 0
• Événements. Les événements déclenchent l'exécution du
script et transportent des données de façon asynchrone ; ils
peuvent être externes, par exemple un événement défini par
l'utilisateur venant d'un autre microcontrôleur par le bias
du bus de communication, ou internes, par exemple générés
par un timer. La récéption d'un événement exécute, si défini,
le bloc de code commençant par le mot clé onevent suivi du
nom de l'événement. Le code au début du script est exécuté
quand ce dernier est chargé ou au reset. Le timer interne
lance périodiquement l'exécution du bloc de code commençant par le mot clé ontimer, si celui-ci est présent.
Afin de permettre l'exécution du code lors de la réception
d'un nouvel événement, le script ne doit pas bloquer et donc
ne pas contenir de boucle infinie. Par exemple, alors qu'un
programme de contrôle de robot traditionnel travaille à l'intérieur d'une boucle infinie, un script ASEBA fait le travail
dans l'événement timer après le mot clé ontimer.
Un script peut aussi envoyer des événements en utilisant le
mot clé emit. Cela permet à un script de déclencher l'exécution de code sur un autre microcontrôleur ou de communiquer avec le développeur. Les microcontrôleurs recoivent
les événements qu'ils envoient.
ontimer
if run == 1 then
leftSpeed = prox[1]
rightSpeed = prox[6]
if prox[1]+prox[6]<6 then
emit wall prox
end
else
leftSpeed = 0
rightSpeed = 0
end
onevent start
run = 1
onevent stop
run = 0