Comme prevu j’ai pu me remettre aux Mebius ce mois ci. Je continue a bien avance sur le livre qui grossis a vue d’oeil (143 pages au jour d’aujourd’hui). J’ai aussi realise les optimisations dont je parlais dans le precedent post. Il s’agissait d’utiliser une structure d’arborescence mutlidimensionnelle pour une partie de la memoire du Mebius. Je craignais que ca ne me prenne un temps fou, et puis en deux jours c’etait regle. La je suis en train de refaire quelques runs pour prouver que la nouvelle version de l’algo fonctionne bin, qu’il n’y a pas de regression, et voir en quoi ca ameliore les performances.

A partir de Fevrier je commence un nouveau travail, mais j’ai negocie des arangements dans l’emploi du temps pour avoir 3 jours de conges par semaine. Je compte en consacrer un pleinement aux Mebius. Donc ca devrait bien avancer. J’ai deja defini les experiences que je veux faire sous la forme du plan du livre. Petit a petit je me dirige vers une organisation ou le livre devient une feuille de route que je remplis avec les resultats que j’obtient et les analyses que j’en fait. Et je voudrais augmenter ma productivite en preparant l’experience suivante pendant qu’une est en train de tourner, ou automatisant plus les runs d’une meme experience. Bref cette annee je veux passer a la vitesse superieure ! Cote code, l’algo des Cognits est tres probablement dans sa version definitive a quelques details pres (il y a surement moyen de l’optimiser). Il ne reste donc que la surcouche pour assembler plusieurs Cognits en un Mebius, mais ca ne represente pas vraiment de difficulte. Par contre il y aura aussi ce que j’appelle le module d’inference qui sera un gros boulot. Mais ca viendra plus tard, pour l’instant je m’occupe de voir ce dont les Mebius sont capables sans ce module.

Depuis mi-Octobre j’ai un boulot a plus-que-plein temps, je participe a des fouilles archeologiques. D’ou le nouveau blanc dans ce projet. Mais je fini dans trois semaines et je devrai pouvoir me remettre au Mebius debut Janvier. 

Dans les derniers choses que j’avais faite et dont je n’avais pas parle ici, l’experience ou les Mebius controlent leur acceleration a donne de tres bon resultats. Et cote livre, en redigeant des bouts du chapitre a propos de l’algorithme ca m’a permis de realiser qu’il y avait des ameliorations a apporter a l’algo par endroit, et c’est la prochaine chose que je veux faire. Ca m’obligera surement a refiare quelques tests mais je positive en me disant que ce travail de redaction est benefique a l’algo en me forcant a plus de verification, d’optimisation.

Bon finalement ce a quoi j’avais pense n’ameliore pas la vitesse de l’algo donc j’ai laisse tomber et suis revenu au bouquin. J’ai mis au propre une grosse partie de la description des structures de donnees qui contiennent la memoire des Cognits, et avance sur la mise au propre de l’experience ou le mebius ne controle pas sa vitesse mais son acceleration (experience que je n’avais finalement pas faite jusqu’a present). Et la, pan voila que ca explose ! Apres une journee a broyer du noir « ca marchera donc jamais » comme d’habitude, je me suis finalement rendu compte que c’etait juste un depassement de capacite dans une variable du cote de la simulation de l’environnement. Ouf ! Resolu en 1 seconde, et mes petits Mebius tournent du feu de Dieu…
Du coup je met plus trop de resultats par ici, sorry, faudra acheter le bouquin quand il sortira (dans un siecle) :-p . Non, je remettrai quelques resultats ici aussi un jour.

 

J’ai fini une optimisation sur la gestion de la memoire dynamique dans l’algo du Mebius. Je determine maintenant dynamiquement le type des references aux blocs memoires dans le segment de memoire du cognit. Par exemple s’il y en a moins de 256, un unsigned char suffit. Je peux ainsi reduire la taille des blocs memoires, et donc augmenter leur nombre dans le segment, ce qui a pour effet de rendre plus « intelligents » le Mebius. 
Ce faisant j’ai aussi remarque que je pourrais ameliorer encore la gestion de la memoire dynamique, cette fois pour ameliorer la vitesse d’execution de l’algo. Je vais y reflechir un peu plus maintenant.

Fini de debugger, ca tourne impeccable. Au passage j’ai implemente de nouveaux mecanismes de controle et ameliore la gestion de la memoire.

En faisant des tests tres longs pour generer des graphiques pour le livre j’ai trouve un bug dans la gestion de la memoire dynamique qui etait passe inappercu sur run moins long. Je l’ai resolu en partie mais il y a toujours quelque chose qui va pas. Je continue a investiguer…

Ces dernieres semaines j’ai ete tres pris par une competition de programmation et un petit boulot de traduction. J’ai encore quelques travaux en previsions pour les jours qui viennent mais je vais me remettre en parallele a la redaction du livre.

J’ai continue a beaucoup travailler sur la redaction du livre, principalement mettre au propre tout ce quej’ai fait jusqu’a present. Je me rend compte que ca represente deja un volume enorme ! Comme le resultat me plait je pense que je vais continuer a travailler la dessus pendant un bon moment.

 

Hier et ce matin je me suis occupe de l’ecriture d’un peitt bout de code en C++ pour interagir avec l’Arduino via la connection USB. Si je n’avais eu besoin que de recuperer quelques valeurs pour faire des graphiques ici je me serai probablement contenter de quelque chose comme Processing, mais comme de toute facon j’aurai besoin d’ecrire mes propres fonctions de communications quand je ferai un mebius « deporte » (mebius tournant sur mon pc mais recevant ses entrees et envoyant ses sorties via un arudino connecte au pc) autant resoudre le probleme tout de suite. Ca n’etait pas bien complique mais comme il y a quelques astuces autant les rapporter ici pour que ca serve eventuellement a d’autres.

D’abord j’ai utilise la librairie libserial. J’ai telecharge les fichiers, decompresse dans un sous repertoire de mon projet  et compile … et bien sur ca n’a pas compile. Apres avoir cherche un peu il semble que le probleme vienne d’une modification des parametres de compilation de g++ dans ma version de Ubuntu. J’ai resolu le probleme en rajoutant

#include <stdlib.h>
#include <string.h>

la ou c’etait necessaire cf les messages d’erreur de compilation. Pour utiliser cette librairie dans mon programme, j’ai rajoute dans le makefile le path vers les headers

-I./libserial-0.5.2/src/

et le link vers la librairie

-lserial

Le programme en C++ pour communiquer avec l’Arduino ressemble a ca :

D’abord j’inclus la libriaire avec

#include « SerialStream.h »

Ensuite je definis l’adresse du port USB. La il y a un truc a savoir. A priori on ne peux pas savoir sur quel TTY l’arduino sera connecte, ca change a chaque fois qu’on le connecte. Mais il y a un nom logique dans /dev/serial/by-path/ qui lui a priori est toujours le meme pour une meme prise usb sur votre pc (ca reste a confirmer mais chez moi ca marche).

char *serialport= »/dev/serial/by-path/pci-0000:00:1a.0-usb-0:1.3:1.0″;

Je definis un stream.

SerialStream my_serial_stream;

Ensuite il y a aussi un autre probleme au moment d’ouvrir le stream. Vous constaterez peut etre que seul root peut ouvrir un stream sur le TTY. En fait vous pouvez autoriser d’autres utilisateurs en les rajoutant au groupe du TTY. Faites un ls -l sur le TTY pour savoir dans quel groupe il est (a priori dialout) et ensuite ajouter votre user avec la commande sudo useradd -G <nom du groupe> <user> .

my_serial_stream.Open( serialport ) ;

Ensuite je verifie que le stream est bien ouvert
if (my_serial_stream.IsOpen()) {
cout << « Opened  » << serialport << « \n »;
} else {
cout << « Failed to open  » << serialport << « \n »;
exit(1);
}

Ici nouvelle astuce, quand vous ouvrez un stream sur l’Arduino ca declenche un reset (attention ca varie en fonction de la version de votre Arduino). Il faut donc attendre que le reset soit fini avant que votre programme puisse dialoguer avec l’Arduino. Ici je pause simplement pendant 3 secondes.
sleep(3);

Ensuite je configure le stream comme ca :
my_serial_stream.SetBaudRate( SerialStreamBuf::BAUD_9600 ) ;
my_serial_stream.SetCharSize( SerialStreamBuf::CHAR_SIZE_8 ) ;
my_serial_stream.SetNumOfStopBits(1) ;
my_serial_stream.SetParity( SerialStreamBuf::PARITY_NONE ) ;
my_serial_stream.SetFlowControl( SerialStreamBuf::FLOW_CONTROL_HARD ) ;

Et je suis maintenant pret a dialoguer. Pour envoyer un octet :

char buffer=1;
my_serial_stream.put( buffer );

Pour lire un octet (en mode bloquant, ie le programme attend qu’il y ait un octet a lire) :

my_serial_stream.get( buffer ) ;

Finalement je ferme le stream :
my_serial_stream.Close() ;

Cote arduino, l’ecriture d’un octet se fait par :

Serial.write(val);

La lecture (en mode non bloquant) se fait par :

Serial.readBytes(&val,1);

Vous pouvez utiliser Serial.available() pour verifier qu’il y a quelque chose a lire, et le mettre dans une boucle infini pour simuler une lecture en mode bloquant, ou faire de la synchronisation entre l’Arduino et votre programme.

Avec ca je vais maintenant pouvoir afficher des resultats obtenus par le Mebius sur l’Arduino, ici et dans mon rapport…

 

J’ai fini de rediger le premier chapitre de mon livre qui presente ce qu’est le projet mebius, son historique et le but du livre. Maintenant je vais commencer par mettre au propre les resultats que j’ai obtenu jusqu’a present. Ce soir j’ai ameliore mon processus de mise en oeuvre pour simplifier le travail en parallele en tout simule et en embarque sur mon Arduino.

 

Suivre

Recevez les nouvelles publications par mail.