7 réponses à ce sujet

[Fabarbuck]

Hello tous!
Suite au topic sur les robots résolveur de labyrinthe, Pzaf a lancé l'idée de faire un simulateur. (voir: )
J'ai proposé de le faire en java, parce que c'est à mon avis l'option la plus simple et la plus adaptée.

Il faut maintenant qu'on voie ce qu'il serait intéressant d'intégrer dans une premiere version, et dans les versions futures, pour ne pas prendre de mauvaises décisions sur les fondements du programme à écrire.
Ce serait bien aussi que les personnes intéressées soit par l'utilisation ou la contribution au projet se manifestent !

Pour l'instant, je propose les listes de features suivantes:
Version basique
- mode texte: tous les résultats de la simulation sont retournés sous forme de lignes de texte
- pas d'interaction: tous les parametres de l'environnement et des robots sont déterminés 'en dur' dans le programme
- monde en 2D: il est beaucoup plus facile de faire un simulateur 2D, et c'est suffisant pour les robots qui nous intéressent.
- pas de simulation 'réaliste' coté physique: l'idée n'est pas d'avoir quelque chose qui soit représentatif du temps écoulé, mais plutot d'une succession de l'état du monde et des objets (robots) ; typiquement, on ne va pas forcément voir le robot évoluer ms par ms, mais plutot étape par étape (d'une case à l'autre du labyrinthe, par exemple)
- concentration sur les aspects IA: l'objectif du simulateur n'est pas de tester le code du robot, mais son comportement ; en gros, voir si la stratégie définie fonctionne, est efficace... mais pas de voir si le robot roule droit !


Version future
- petit affichage graphique du monde (quelque chose de modeste, hein )
- possibilité de paramétrer mondes, différents objets, et de sauver/charger ceux ci, ainsi que les différents états de simulation.
- raffinement des modeles pour les robots, actionneurs et capteurs, afin de pouvoir tester les algorithmes de traitement eux aussi (par exemple, portée des capteurs, gestion simple de trajectoires...)
- possibilité de régler des parametres graphiquement, de définir des aspects de l'IA non pas en dur dans le code du programme, mais à l'aide d'une interface graphique (boutons pour définir une séquence d'actions, langage type basic interpreté).
- possibilité de charger différentes IA de deux personnes différentes pour voir comment elles se comportent 'l'une contre/en présence de l'autre'

Ce que le simulateur ne fera jamais
(ou en tout cas ce ne sera pas moi qui le ferai)
- avoir un moteur physique réaliste
- etre précis quant au temps simulé/temps réel ; c'est lié à l'aspect physique. C'est prévu pour servir de simulateur d'IA ultra basique, rien de plus !
- etre en 3D
- garantir un bon fonctionnement ; ca veut dire que je développe pour me faire plaisir, tant mieux si ca vous amuse aussi, tant pis si vous etes du genre raleur à en demander toujours plus... en bref, je ne compte absolument pas me prendre la tete à maintenir un truc, faire en sorte que ca marche au poil dans toutes les situations et partout.
- proposer une interaction directe avec un robot réel (ce n'est pas completement impossible, mais c'est un travail immense, dans lequel je ne compte pas me lancer, meme à moyen terme).
- le café ! (et c'est bien dommage )


Voila le premier jet... j'attends vos commentaires, et de voir si ca intéresse des gens, aussi bien pour l'utilisation/le test que la contribution à la programmation. Pour info, quand on connait le C (ou langages similaires), le java n'est pas imbuvable, et il y a surement quelque chose que vous pouvez faire !

[uran]

Salut,
Comment intégrer "l'univers d'évolution" et le comportement du robot dans ce soft?
Sous forme de fichier excel pour l'univers (en gros un damier avec diverses valeurs à chaques cases pour définir les divers éléments comme murs, trous, adversaires, le chat de la voisine, etc etc)? d'organigramme ou de graphcet pour le robot ?

[Fabarbuck]

C'est un point important.

En fait, ce que je pense faire dans un premier temps, c'est utiliser tout simplement les structures de données propres au langage pour stocker ces informations ; dans les premieres versions, le comportement du robot sera contenu dans une fonction précise en java, appelée à chaque pas de simulation pour faire évoluer l'ensemble. Idem pour ce qui est de la gestion de l'environnement.

Par la suite, il y a différentes possibilités pour paramétrer ces deux éléments ; on peut penser par exemple à:
- un fichier texte/xml qui rassemble des infos sur les caractéristiques des objets, des parametres données en entrée de l'IA
- un pseudo interpreteur basic
- un systeme graphique pour gérer une séquence de réactions types (proche du graphcet, donc)

J'attaque la programmation d'un truc ultra basique à l'instant, apres y avoir réfléchi aujourd'hui. Je vous en dirai un peu plus plus tard.
Ce qui serait intéressant, c'est de savoir comment vous voyez les choses, ce que vous attendriez d'un soft comme ca...

[uran]

Une idée folle serait le système utilisé par "les livres dont vous êtes le héro", en gros un mode où à chaque pas effectué, tu as une liste de comportement possible et/ou probable en fonction du pas présent pour aller vers le pas suivant.
Sinon un interpréteur serait pratique pour décrire le fonctionnement du robot, juste quelques fonctions simple de conditions seraient dèjà bien pratique.
L'utilisation d'un mode graphique serait peut être plus intuitive pour faire des choses simples, mais risquerait d'être vite galère dès que l'on voudrait simuler un fonctionnement un peu plus complexe..

[Fabarbuck]

Bon, pour préciser les choses, voici comment je compte m'y prendre:
- d'un coté, une structure de donnée qui contient les objets (dont le robot, et les 'obstacles')
- d'un autre coté, un ensemble de fonctions qui gere l'état de ces objets.

En gros, un robot a:
- des caractéristiques propres (dimensions, vitesse... enfin pas tout de suite, mais c'est intégrable par la suite)
- des actionneurs (typiquement ses moteurs, dans un premier temps pas caractérisés plus que ca)
- des capteurs

un pas de simulation se passe comme suit:
Pour chaque objet dans l'univers:
- prendre chaque capteur, et calculer la valeur mesurée (mise à jour dans la bonne structure)
- pour chaque objet 'intelligent' (donc le robot), invoquer la fonction d'IA (qui va, en fonction des valeurs de capteur, décider des consignes pour les actuateurs)
- pour chaque objet physique, calculer la mise a jour de la position, etc, en fonction des consignes calculées précédement

et quand on a fait tous les objets, afficher les résultats (en mode texte ou en mettant à jour un petit affichage graphique), et s'il faut faire un pas de simulation supplémentaire, réitérer.
A noter que du coup, un pas de simulation représente en fait un temps réel un peu arbitraire (et plutot de l'ordre de la seconde), dont on se fout d'ailleurs, puisque tout ce qui nous intéresse, c'est de tester l'IA, voir si à une succession d'entrées (valeurs de capteurs), elle décide des 'bonnes' commandes (pour les actionneurs) pour que le robot fasse ce que l'on veut. Mais le niveau de ces commandes, c'est 'aller à gauche, droite, haut bas', pas 'mettre le registre pwmB à 0b00100101 pour obtenir telle vitesse sur le moteur gauche, d'apres calcul de l'asservissement et pour espérer aller dans la bonne direction....
biensur, ce dernier mode de fonctionnement est possible à long terme avec des modeles d'objets plus précis, un (meme petit) moteur physique, etc... mais ce n'est pas l'objectif prioritaire (d'autant que ca augmente significativement le boulot de programmation ! )


Il est bien entendu qu'on doit facilement pouvoir enregistrer une simulation pour l'analyser a posteriori, faire une simu pas à pas avec différentes conditions initiales ou différentes AI, et potentiellement, avoir un mecanisme automatique qui 'teste' différentes variantes d'une AI donnée, pour voir laquelle se comporte le mieux.... un peu comme les algos génétiques.

Vous noterez que pour l'instant, l'IA simulée est une fonction en java... c'est le plus simple à faire, et c'est ce que j'impémente poru l'instant. Ca veut dire que dans la premiere version, il faudra :
- savoir écrire (modifier, aller... ) du java
- avoir ce qu'il faut pour compiler les sources ainsi modifiées (c'est pas dur, mais bon, un poil peu convivial pour le profane pressé )

Coté interpreteur, le plus simple pour moi c'est de faire une interface graphique qui renseigne directement une structure de donnée contenant une liste d'actions simples, adaptées aux possibilités du simulateur. Enfin je n'ai pas encore réfléchi aux détails à vrai dire...

Il doit etre possible de faire réellement un interpreteur basic, mais cela nécessite:
- de sélectionner un langage précis et adapté à ce que l'on veut faire
- d'avoir l'infrastructure d'un interpreteur (parser...)
- de traduire chaque instruction en quelque chose qui colle au modele interne du monde et du robot (et bon, en basic, tu lis des ports du uC a priori, ce qui n'est pas directemen prévu dans le modele basique dans le simulateur, donc boulot supplémentaire pour l'intégrer.
Sinon un interpréteur serait pratique pour décrire le fonctionnement du robot, juste quelques fonctions simple de conditions seraient dèjà bien pratique.

Quant a avoir un simulateur asm du robot, c'est nettement plus compliqué, parce que:
- ca oblige a avoir un pas de simulation bien plus faible que ce que je pense utiliser (il faudrait se caler sur un cycle du uC en toute logique)
- ca oblige a avoir un modele precis du uC (et si je dois m'en taper un, comptez sur moi pour récupérer des choses pour atmega8... désolé pour les pics )
- ca oblige a avoir des modeles détaillés du reste du robot (comment se comportent, à cette échelle de temps plus précise, le pont en H? les moteurs? etc...)

Coté mode graphique, ca peut effectivement devenir chiant pour faire exactement ce que l'on veut... cela dit, il faut distinguer :
- interface graphique générale du simulateur, pour sélectionner parametres, etc...
- mode graphique pour l'affichage du monde (résultat de simulation)
- mg pour la 'programmation' de l'IA (sélectionner des actions basic, etc...)

Sachant que je compte en fait aborder l'implémentation de ces aspects dans l'ordre cité ici.

[Fabarbuck]

héhé bon c'était un bien long message.

J'ai donc fait la base du code, ca se passe plutot bien jusqu'à présent, meme si je n'ai rien de présentable pour l'instant.
J'ai fait une rapide recherche sur google, et il y a tout un tas de projets déja existants. Je n'ai pas eu le temps de creuser ce que j'ai trouvé, mais il y a peut etre des trucs exploitables, ou dont on peut se servir de base.

En fait je me demande ce qui est le plus intéressant:
- faire un truc completement à partir de zéro, completement comme on veut
- s'intégrer à un truc déja en place (plus ou moins), et tenter d'en faire ce qu'on veut
A vrai dire... je suis plutot partisan de la 1re approche, meme si c'est un peu con a priori... je vais voir si je trouve pas quelque chose qui sort du lot... parce que là, rien ne m'a a proprement parler emballé... en attendant, je crois que je vais programmer encore un pti peu

EDIT:
alors, j'ai trouvé pas mal de choses plutot sympathiques... et tout particulierement ceci:
http://www.harbaum.org/till/nanovm/
C'est adapté pour un pti robot qui vaut 50 euros chez conrad (http://www.conrad.fr/webapps/robot_programmable_asuro.html), et est prévu pour le suivi de ligne entre autres.
(pour le code donnant un suiveur de ligne, voir:
http://www.harbaum.org/till/nanovm/AsuroLine.java)

Je vais regarder de plus pres ce dont peut etre capable le code fourni, mais ca a l'air plutot pas mal à premiere vue. Pour le dire (tres tres) vite, c'est un basic stamp open qui interprete du java.

Je pense vraiment que je vais regarder en détail cette appli et travailler pour développer d'autres fonctions pour ca !
D'ailleurs, la page résume bien les choses:

You want to contribute? Great! Here are some of the things that would be a great contribution to NanoVM:

    * Making the NanoVMTool an eclipse plugin would allow even more people to use the NanoVM. This way a program developed within Eclipse could be directly uploaded to the target system without leaving eclipse.
    * A NanoVM emulator that emulates the AVR, asuro, or other native methods on the PC would allow to e.g. test programs with a virtual asuro before uploading them to the real thing.
    * A simple graphical programming layer above java would allow even complete beginners to work with nanovm equipped devices. A simple drag 'n drop gui allowing to build simple flow control diagrams and then translating these into java would be all that's needed to accomplish this.
    * You have a better idea? You are welcome ...

Personnellement, je pense qu'il faut avoir un support pour d'autres robots que simplement l'asuro. Apparement, ce n'est pas impossible ni meme difficile, mais il faut quand meme que je regarde ca de plus pres.

[Fabarbuck]

Arg. Ca faisait un moment que je n'étais pas allé voir le superbe site de l'association pobot (www.pobot.org), et j'y ai découvert tout un tas de trucs de simulation (entre autres). Je pense qu'il y a quelque chose à faire de ce coté ci... apres tout, pourquoi réinventer la roue?
Sinon, je pense que ce thread a plus sa place dans la catégorie IA (ou peut etre qu'il faudrait en lancer un autre... à voir).
Bref, mon appli toute pou... minimaliste risque de rester en l'état... enfin il faut que je voie, j'ai bien envie d'intégrer des choses à l'environnement de la NanoVM.

A part ca, rendez vous sur le site de pobot pour plus d'infos... par contre, ils ne disent pas s'ils prévoient une compétition en 2007... mais il n'y a pas de raison qu'ils n'en fassent pas (surtout s'il y a des intéressés qui se manifestent... alors manifestez vous )

[PZaf]

Je viens d'aller sur le site de Pobot et j'ai vu les différents simulateurs qu'ils proposent.

Lequel pourrait correspondre à notre besoin ? le dernier, celui de 2006 ?

Ensuite, qu'est-ce que nous devrons faire ?
- charger notre environnement (murs du labyrinthe, etc.)
- faire nos programmes de déplacement