Avec
l'apparition en 1998 de la boîte "Robotic Invention" Lego
Mindstorms est née pour moi la possibilité de
réaliser toutes sortes de robots et de p
rogrammer
la fameuse brique RCX (cf photo de droite). Cette brique intelligente
(qui constitue le cerveau de ces robots) a été
réalisée par les chercheurs du Massachusetts Intitute
of Technology (MIT), qui utilisent notamment les lego durant
les cours de robotique dispensés aux étudiants.
La brique, qui comporte 3 entrées capteurs et 3 sorties
moteurs, possède 32 Ko de mémoire vive ainsi que
de la mémoire morte à laquelle on ne peut avoir
accès.
Le langage de programmation proposé par Lego étant
finalement assez limité, d'autres langages se sont développés
indépendamment de cette entreprise, pour le plus grand
plaisir de la communauté des passionnés du Mindstorms.
Citons par exemple le langage NQC (Not Quite C) http://www.enteract.com/~dbaum/nqc/,
PbForth (reprise de l'ancien langage Forth), http://www.hempeldesigngroup.com/lego/pbforth/)
et legOS, auquel sera consacré notre rubrique.
LegOS est l'un des langages les plus puissants du RCX. Il
présente en effet l'intérêt de programmer
en C directement avec le compilateur du microprocesseur (Hitachi
H8), tandis que les autre langages utilisent le firmware (ou
microprogramme : programme qui gère le RCX dès
l'allumage) de Lego, avec seulement 32 variables disponibles.
LegOS remplace ce microprogramme par le sien. Les source du
Kernel sont disponible dès le téléchargement
de legOS.
Des chercheurs qui utilisent le legOS
Les chercheurs en intelligence artificielle ne s'y sont pas
trompé. C'est le cas notamment à l'Animatlab(1),
laboratoire de l'université Paris VI (Lip6) http://animatlab.lip6.fr
que j'ai visité récemment. Visite que je ne peux
m'empêcher de vous raconter.
Dès mon arrivée, je fus tout de suite invité
à discuter avec Benoît Girard et Vincent Cuzin
{benoit.girard ;vincent.cuzin}@lip6.fr), deux étudiants
qui travaillent justement sur des robots Lego.
Mais tout d'abord, rappelons en quoi consiste l'approche animat
que ces chercheurs essaient de mettre en application sur les
mindstorms : dans la recherche en IA dite "classique", un grand
nombre de chercheurs se sont orientés vers des approches
tentant de modéliser l'intelligence de l'homme, avec
plus ou moins de bonheur.. On pourrait citer dans ce cadre les
systèmes experts ou encore l'ordinateur Deep Blue, qui
a battu le champion du monde d'échecs Gary Kasparov.
L'approche "animat " (= animal artificiel) ne consiste pas en
cette approche, qui est d'essayer de doter des robots de tout
ce que l'homme a de particulier par rapport aux animaux (par
exemple comprendre le langage naturel, raisonner, jouer aux
échecs...), mais plutôt de leur donner les capacités
que l'homme partage avec les animaux (percevoir des objets,
s'orienter dans un environnement, éviter les obstacles,
enchaîner ses actions...). Cette approche suppose que
l'intelligence de l'homme n'a pu se développer que parce
qu'il avait déjà acquis des "capacités
adaptatives" héritées des animaux. Ces capacités
ont permis aux animaux de survivre dans un environnement imprévisible
et dangereux. Les organismes vivants ont pu acquérir
ces capacités par apprentissage, par développement
ou par évolution des espèces. On va donc donner
aux robots la possibilité d'apprendre, de se développer
ou d'évoluer pour qu'eux-mêmes se dotent de comportements
qui leur permettent de faire des tâches précises
en "survivant" de façon autonome dans leur environnement.
Le
projet des deux étudiants consiste donc à donner
un "cerveau" (que l'on appelle une "architecture de contrôle")
au robot Lego, qui va relier de manière "adaptative"
ses capteurs et ses actionneurs. Ce cerveau est d'ailleurs inspiré
de structures nerveuses que l'on peut trouver par exemple chez
le rat . Ces chercheurs travaillent en effet ici avec une équipe
de biologistes spécialisés dans ce domaine).
C'est ainsi qu'il m'ont montré un robot qui doit réagir
de façon autonome dans son environnement. Il doit se
nourrir (se recharger dans les zones noires, cf photo), dormir
(zones blanches) et éviter des obstacles pour survivre.
Le but est que le robot puisse vivre le plus longtemps possible
dans l'arène avec la présence d'un prédateur,
tout en développant des stratégies pour parer
les attaques de celui-ci. Il utilise des capteurs de lumière
pour détecter la couleur du sol. Ces même capteurs
servent à repérer le prédateur qui signale
sa présence par une lampe accrochée au-dessus
de celui-ci. On peut remarquer que les zones forment un dégradé
: le robot ira plus ou moins vite pour se recharger suivant
le niveau de couleur. C'est donc pour cela que le robot comporte
deux capteurs de lumière, pour voir s'il avance ou recule
dans le dégradé.
Le prédateur, sert pour sa part à donner de la
dynamique à l 'environnement, et à mettre en évidence
les capacités du robot à faire face à des
événements imprévus.
Des problèmes se sont bien sûr posés aux
deux chercheurs lors de la construction et de la programmation
du robot (le premier venant de la limitation du nombre d'entrées
capteurs, il a fallu ruser ; le deuxième résidant
dans un manque de précision des capteurs de lumière
pour distinguer parfaitement les différents niveaux de
couleurs des tâches). Mais ça, c'est le lot de
tout chercheur. Enfin tout cela, c'est pour en arriver au legOS(2).
Car c'est avec ce langage que travaillent la plupart des chercheurs
utilisant les Lego, langage qui permet de programmer le RCX
en C (avec, par exemple, la possibilité de créer
plus facilement des réseaux neuronaux).
Grâce à ce système, le robot communique
avec l'ordinateur (la place prévue sur le RCX étant
trop petite), d'où la présence de la tour infra-rouge
(IR) près du robot.
A la fin de chaque essai, des graphes permettent aux deux chercheurs
de mieux voir ce qui s'est passé durant l'évolution.
Ceci vous donne une idée de ce qui peut être fait
en Lego par des personnes dont on pourrait dire qu'elles ont
passé l'âge.
Voilà, après cette brève introduction,
j'espère que vous êtes convaincus de la puissance
de ce langage.
Pourquoi legOS ?
Tout simplement parce qu'il vous donne un accès total
à la mémoire du RCX et que vous bénéficiez
de la puissance du C pour votre RCX. D'ailleurs legOS nous le
précise dans son aide : "Think 32 not 32 variables".
Le langage C est vraiment puissant : il permet par exemple la
programmation de réseaux neuronaux ou autre programmation
avancée. Il offre également une bien meilleure
exploitation de la liaison IR entre PC et RCX.
L'objectif de cette rubrique est vous guider à travers
l'apprentissage de legOS qui n'est pas facile (pour ceux qui
ne connaisse pas trop le C).
Installation
Pré requis : linux, compilateur GCC (fourni généralement
avec Linux), bases en C.
Je sens déjà que certains d'entre-vous vont être
déçus : eh oui, tout cela se passe sous Linux.
Et Windows alors ? Je serais tenté de vous dire, question
de principe, que je ne trouve pas intéressant d'utiliser
un langage dédié à Linux sous Windows...
Votre visage s'éclaire alors. Vous vous dites "s'il
écrit cela, c'est qu'il doit y avoir une possibilité
de programmer LegOS sous Windows". La réponse est
oui(3). Mais pourquoi vouloir à
tout pris s'ennuyer avec Windows, alors qu'il existe pour vous
une autre solution... Celle d'installer dans votre ordinateur
Linux à côté de votre Windows. Vous ne le
saviez peut-être pas : on peut très bien, sur un
même ordinateur, faire cohabiter les deux systèmes
d'exploitation. Question de partitionnement.
En tout cas, ici, je ne parlerai pas de la programmation legOS
sous Windows... question de principe
Revenons à l'installation du logiciel legOS :
Il faut d'abord télécharger les packages suivants
:
-legOS : legOS-0.2.5.tar.gz
-rcx binutils : rcx-binutils-2.9.5.0.2.2-1.i386.rpm
-rcx egcs : rcx-egcs-1.1.2-1.i386.rpm
Vous pouvez les télécharger sur
http://legOS.sourceforge.net/ ou http://www.noga.de/legOS/
(ce dernier site n'étant plus mis a jour, je n'ai pas
essayé d'installer cette version qui est moins récente
que celle disponible sur legOS.sourceforge.net.
Télécharger ces packages en fonction de votre
distribution. Je vous conseille de télécharger
le premier en fichier *.tar.gz et les deux dernier en fichier
*.rpm. Cela sera beaucoup plus facile a installer.
Après avoir téléchargé l'ensemble,
lancer tout d'abord les deux derniers (les fichier en .rpm).
L'installation est automatique (si votre version supporte les
fichiers de ce type). En mode texte (si l'installation ne veut
pas se faire automatiquement en mode graphique), lancer la commande
: rpm -i "le_nom_du_package" . Cela devrait alors se passer
correctement.
Cette première phase permet d'installer les composants
qu'utilisera legOS par la suite pour compiler les programmes
que vous écrirez.
Pour installer legOS par lui même, il faut soit, en
mode graphique, utiliser l'archiveur, soit, en mode texte, lancer
une commande dans le répertoire où se trouve votre
fichier : tar xzf legOS-0.2.5.tar.gz. Je vous conseille fortement
de mettre ce fichier dans le répertoire HOME (répertoire
personnel), et de le décompresser aussi dans ce repertoire.
Il se mettra alors bien sagement dans un dossier nommé
legOS.
Vous voici donc avec legOS décompressé, mais non
installé. Avant de commencer l'installation, vous devez
éditer un fichier pour indiquer où se trouve les
différents composants installés auparavant. Il
suffit d'éditer le fichier Makefile.common et de changer
les paramètres pour le répertoire où se
trouve le cross-compilateur. Pour cela, et si vous avez bien
suivi ces instructions, il faut écrire /usr/bin/h8000-hitachi-hms-
à l'endroit où se trouve TOOLPREFIX.
Il faut maintenant passer en mode texte (ou lancer une console
en mode graphique) et lancer la commande make dans le répertoire
où se trouve legOS. Vous devriez voir des commandes se
lancer. LegOS se compile et s'installe.
Et voilà : legOS est installé.
Pour les impatients qui ne peuvent attendre les prochains
articles, voici quelques brèves remarques sur le fonctionnement
de legOS.
Sachez tout d'abord qu'il n'est pas compatible avec le firmware
(programme de gestion du RCX) de Lego. LegOS a en effet son
propre firmware. Tandis que le firmware de lego interprète
les commandes envoyées tour a tour par la tour Infra
Rouge (IR), legOS compile et exécute les programmes.
Si, dans les ancienne version de legOS, il fallait télécharger
dès que l'on voulait faire des essais un nouveau firmware
contenant ce dernier; aujourd'hui c'est de l'histoire ancienne
(le temps de téléchargement étant trop
long). Un protocole lx program permet de télécharger
les programmes d'une manière rapide, n'envoyant que vos
fonctions.
Pour commencer il faut donc télécharger le firmware
legOS qui se trouve dans le répertoire boot du répertoire
legOS. Pour cela, vous avez deux solutions : utiliser firmdl3
fourni avec legOS dans le répertoire util. Il existe
deux mode pour ce programme : fast, slow. Je vous déconseille
le mode fast (qui permet de télécharger le firmware
à grande vitesse, 4 fois plus vite qu'avec le mode slow)
car, souvent, le téléchargement se passe mal ...
Dès lors, il vaut mieux le télécharger
à petite vitesse, de la façon suivante : firmdl3
-s ../boot/legos.srec (le -s signifie ici que le programme va
télécharger le firmware en mode slow).
Le nom du fimware est donc legos.srec. Il a été
compilé avec le reste lors de l'installation (make).
On pourra remarquer que les sources sont disponibles et se trouvent
dans le dossier kernel.
Ce petit article vous a permis de mieux connaître et
surtout d'installer legOS, ce qui me semble difficile sans aide.
Dans les prochain articles, nous verrons comment compiler puis
télécharger un programme : tout d'abord un programme
exemple, puis un programme que nous avons réalisé.
Et nous commencerons aussi à apprendre quelques commandes.
La suite au prochain numéro...
(1) A
propos de l'Animatlab, lire l'interview
d'Agnès Guillot et de Jean-Arcady Meyer (octobre
2001). 
(2) Le
chercheur qui a mis au point ce langage a eu le plus grand mal
à faire reconnaître ce nom "legOS", Lego
voyant ceci du plus mauvais oeil !
(3) Pour
les irréductibles, inconditionnels de Windows (on se
demande pourquoi...), voici le processus d'installation de legOS
sous Windows (mais je le répète, il est bien meilleur
de programmer legOS sous linux (et c'est d'ailleurs ce que nous
ferons tout au long des différents cours)) :
vous devez d'abord télécharger les fichiers suivants
:
- LegOS-0.2.5.tar.gz
à partir de http://legOS.sourceforge.net/files/common/LegOS-0.2.5.tar.gz
Enregistrez
le sur votre disque à la racine : C:\ pour faciliter
l'accès par la suite.
- Cygwin
(version B20) à partir de http://legOS.sourceforge.net/files/windows/cygwin/cygwin.exe.
Les versions plus récentes ne fonctionnent pas à
cause de leur librairie.
-Et
enfin le H8 cross compiler pour Cygwin disponible sur http://legOS.sourceforge.net/files/windows/cygwin/win-h8-egcs-1.1.2.zip.
Installer
Cygwin dans le répertoire par défaut : c:\cygnus
(si vous voulez l'installer ailleurs, souvenez-vous du chemin...).
Décompressez win-h8-egcs-1.1.2.zip que vous installerez
dans le répertoire c:\cygnus\cygwin-B20\H-i586-cygwin32.
Exécutez Cygwin et tapez dans la fenêtre qui s'ouvre
: cd / (notez la différence entre / et \) puis tar xvzf
legOS-0.2.5.tar.gz. Cela décompressera legOS et le mettra
dans le répertoire /legOS (soit c:\legOS sous windows)
Editez alors autoexec.bat a l'aide de la commande sysedit dans
menu > exécuter. Trouver la ligne SET PATH puis insérez
cette ligne : C:\cygnus\cygwin-b20\H-i586-cygwin32;C:\cygnus\cygwin-b20
\H-i586-cygwin32\bin;c:\legOS\util;c:\legOS\util\firmdl;.
Si la ligne n'existe pas alors tapez cette ligne : SET PATH
= C:\cygnus\cygwin-b20\H-i586-cygwin32;C:\cygnus\cygwin-b20\H-i586-
cygwin32\bin;c:\legOS\util;c:\legOS\util\firmdl;%path%
Enregistrez. Vous devrez ensuite redémarrer l'ordinateur
pour que les changements se fassent.
Si vous ne pouvez pas éditer ce fichier (vous êtes
peut être sous NT, 2000 ou XP), éditez le fichier
Makefile.common dans le répertoire c:\legOS.
Vous aurez alors une ligne commençant par TOOLPREFIX=h8300-hms-
. Remplacez la par : TOOLPREFIX=/cygnus/cygwin-B20/H-i586-
cygwin32/bin/h8300-hms-.
Faites attention que cela correspond bien a votre répertoire.
Ouvrez alors Cygwin et tapez ces quelques commandes :
cd /legOS
make realclean ; make depend ; make
Après exécution, legOS devrait être installé
(si l'installation se passe mal, vous pouvez peut être
vous référer à l'édition de la ligne
dans le fichier Makefile.common).
Automates
Intelligents s'enrichit du 
Notre équipe rédactionnelle
s'enrichit. Les lecteurs connaissent déjà
sûrement Nanobapt* : nous vous avions présenté
ce jeune lycéen passionné de robotique
et des robots Lego, un mois à peine après
l'ouverture officielle d'Automates Intelligents**.
