Premier essai – Mongoose

Ce soir j’ai testé Mongoose, un petit framework ultra léger en C.
Voilà ce que j’ai apprécié dans ce projet :
– exclusivement en C, c’est bien pour faire de l’embarqué,
– très léger, deux fichiers,
– serveur de fichiers,
– SSL, protection par mot de passe,
– marche sous Linux, Mac OS X, Windows, …

Mon premier test a consisté à faire une petite interface en Google Web Toolkit qui enverra une requête au serveur. Le serveur sera chargé de répondre un petit texte qui sera affiché. Le serveur est aussi chargé de fournir les fichiers.

Bref, un exemple tout bête mais qui m’a permis de prendre en main les deux outils. Le résultat est plutôt concluant, Mongoose semble vraiment une très bonne solution pour développer des services REST en C. Le code source est très court, la preuve plus bas.

C’est pas super intéressant, mais si quelqu’un les veut je lui fait péter les sources.

#include ... standard headers ...
#include "mongoose.h"

static const char *ajax_reply_start =
 "HTTP/1.1 200 OKrn"
 "Cache: no-cachern"
 "Content-Type: text/htmlrn"
 "rn";

// A handler for the /ajax/send_message endpoint.
static void myCallback(struct mg_connection *conn,
                             const struct mg_request_info *request_info) {
 const char *text = mg_get_header(conn, "text");
 mg_printf(conn, "%s", ajax_reply_start);
 mg_printf(conn, "Mongoose says %s", text == NULL ? "send me some text" : text);

}

static void *event_handler(enum mg_event event,
                          struct mg_connection *conn,
                          const struct mg_request_info *request_info) {
 void *processed = "yes";

 if (event == MG_NEW_REQUEST) {
   if (strcmp(request_info->uri, "/myCallback") == 0) {
     myCallback(conn, request_info);
   } else {
     // No suitable handler found, mark as not processed. Mongoose will
     // try to serve the request.
     processed = NULL;
   }
 } else {
   processed = NULL;
 }

 return processed;
}

static const char *options[] = {
 "document_root", "war",
 "listening_ports", "8080",
 NULL
};

int main(void) {
 struct mg_context *ctx;

 // Setup and start Mongoose
 ctx = mg_start(&event_handler, options);
 assert(ctx != NULL);

 // Wait until enter is pressed, then exit
 printf("Simple app started on ports %s, press enter to quit.n",
        mg_get_option(ctx, "listening_ports"));
 getchar();
 mg_stop(ctx);

 return EXIT_SUCCESS;
}

Fonera + Arduino = Compteur de mail

Je viens de m’acheter une Fonera+ pour mettre OpenWrt dessus.

En ouvrant la boite et en connectant le port série à mon Arduino, j’ai même réussi à afficher du texte sur un écran LCD.

Voici le résultat, qui pour l’instant est un peu brouillon :
D’un point de vue technique voici comment j’ai procédé:
  • Accéder à RedBoot sur la Fonera+
  • Installer OpenWrt sur une Fonera+
  • Configurer la Fonera+ pour qu’elle accède à mon réseau wifi
  • Installer python-mini et pyserial sur le routeur
  • Connecter l’afficheur LCD sur mon Arduino
  • Connecter l’Arduino au port série du routeur
  • Créer un script python qui va chercher la liste des nouveaux mails et anime le texte sur l’afficheur
Rien de bien compliqué en soit, mais en affichant le nombre de mails et surtout les expéditeurs du mail, on obtient un petit effet sympa.
La prochaine étape sera d’aller chercher plus de données (twitter, météo …), de mettre tout ça dans un boîtier bien propre avec deux ou trois boutons et d’utiliser un afficheur un peu mieux (rétro-éclairé, 2 ou 4 lignes).

AReVi – Mac Os X Leopard 10.5

Il y a quelques soucis pour compiler AReVi sur la nouvelle version du système de chez Apple.

En effet, il y a quelques soucis lors de l’édition de lien avec OpenGL.
Pour utiliser AReVi sous Leopard, il faut donc rajouter quelques flags qui vont intervenir lors de l’édition de lien. Pour cela, il faut modifier le fichier arevi-config contenu dans le dossier lib/.
Dans le fichier il faut appliquer les modifications suivantes (vers les lignes 429-432) :
LEOPARD=”-Wl,-dylib_file,/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib”
EXECCMD=”${CC} -o ${binary} -flat_namespace -bind_at_load ${LEOPARD}”
DYNLIBCMD=”${CC} -o ${binary} -flat_namespace -dynamiclib
-install_name `basename ${binary}` ${LEOPARD}”
PLUGINCMD=”${CC} -o ${binary} -flat_namespace -bundle ${LEOPARD}”

N’oubliez pas ensuite de refaire un ./armake conf avant de relancer la compilation.
Si ça marche pour moi, alors pourquoi pas pour vous ?

Installler AReVi sur Ubuntu

A chaque fois c’est la même galère, il faut retrouver la liste des paquets nécessaires pour compiler AReVi.
Voici donc (en exclusivité) cette liste:

build-essential flex bison libx11-dev libglut-dev libz-dev libbz2-dev libxml2-dev libxslt1-dev libmagick9-dev libimlib2-dev libalut-dev

Voilà, en installant tous ces paquets vous pouvez :

  • Faire de la 3D (glut, x11)
  • Appliquer des textures à vos objets (magick, imlib)
  • Parser du XML (xml2, xslt)
  • Mettre du son 3D (alut)

C’est déjà pas mal pour un début. Je n’ai pas la liste pour les bindings lua, tcl et java, parce que je ne les ai pas installés.
Cette liste permet aussi d’installer la hLib(2) et les ArWidget.

Réseau de neurones

Je n’avais jamais utilisé les réseaux de neurones. Cela ne pouvait plus durer, je m’y suis mis. Après avoir bouquiné quelques docs sur le sujet, je me suis fait un petit perceptron en python.

Le perceptron est LE réseau de neurones de base. J’ai utilisé une fonction d’activation de type tangente hyperbolique, ce qui permet aux neurones de prendre des valeurs comprises entre -1 et 1.
Après avoir implémenté l’algorithme de rétro-propagation (c’est ce qui permet de changer le poids des connections), j’ai essayé de lui faire apprendre des opérateurs booléens (AND, OR, XOR, NAND, …).
Le résultat a été plutôt surprenant. L’apprentissage est rapide mais surtout efficace. Le réseau que vous pouvez voir ici permet de faire 6 opérations binaires entre deux bits (AND, OR, XOR et les inverses). Il y a 5 neurones en entrée : 2 pour les bits d’entrée et 3 pour pouvoir choisir l’opérateur. Les deux sorties représentent le résultat de l’opérateur et son opposé. Je lui ai fait apprendre les tables de vérité de chaque opérateur une centaine de fois (je ne suis pas convaincu qu’il faille autant d’itérations).
Le résultat est très probant. En appliquant un seuil sur la sortie on retrouve les tables de vérité sans problème. Ma prochaine étape, essayer d’apprendre des choses un peu plus fun, reconnaître des formes, des caractères, …