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).

Un feu tricolore minimaliste (so british)

Afin de tester mon programmateur PicKit2 acheté récemment, je me suis lancé le défi de programmer un feu tricolore avec un tout petit pic, le PIC12F510. L’avantage de ce pic est qu’il contient vraiment plein de fonctions (timer, entrées analogiques) et que grâce à son oscillateur interne, on peut utiliser les 6 broches comme entrées/sorties (5 I/O, 1 I).
Les points durs ont été :
  • de configurer le PIC12F510 pour avoir toutes les sorties en GPIO;
  • de réaliser un timer;
Le circuit est très simple à réaliser, il suffit de :
  • connecter les broches du pic utilisées pour l’ICSP à un connecteur utilisable par le PicKit2;
  • connecter les diodes rouge, orange et verte aux pattes non utilisées, respectivement, GP2, GP4 et GP5;
  • ne pas oublier cependant de mettre une résistance entre chaque LED et sa sortie;
Pour le programmer, j’ai utilisé :
  • un ordinateur sous Mac OS X Leopard;
  • un PicKit2 avec la commande pk2cmd;
  • gputils
  • un Makefile (fournit plus bas)
Le code est le suivant MiniPic0.asm :

LIST p=PIC12F510, r=hex, f=INHX8M
include "P12F510.inc"

; Fusibles
__config _IOSCFS_ON & _MCLRE_OFF & _CP_OFF & _WDT_OFF & _IntRC_OSC
; Point de départ de l'application
org 0x00
init
movwf OSCCAL ; Calibration de l'oscillateur interne
bcf STATUS,PA0 ; Page 0 de la mémoire
;Initialisation des registres pour passer toutes les sorties en GPIO
;ADCON0: ANS<1:0>, ADCS<1:0>, CHS<1:0>, GO/DONE, ADON
movlw 0x00
movwf ADCON0
;CM1CON0: OUT, /OUTEN, POL, T0CS, ON, NREF, PREF, WU
movlw 0xF1
movwf CM1CON0
;OPTION: /GPWU, /GPPU, T0CS, T0SE, PSA, PS<2:0>
movlw 0xC7
option

; Initialisation des entrées/sorties
movlw ~0x34 ; Configuration des sorties (0) et entrées (1)
tris GPIO
movlw 0x00 ; On met tout à zéro
movwf GPIO

loop
movlw 0x20 ; Feu vert
movwf GPIO
call wait ; Attente
call wait
call wait

movlw 0x10 ; Feu orange
movwf GPIO
call wait ; Attente

movlw 0x04 ; Feu rouge
movwf GPIO
call wait ; Attente
call wait
movlw 0x14 ; Feu rouge + orange
movwf GPIO
call wait ; Attente

goto loop ; On recommence

; Une fonction d'attente
wait
; On charge le compteur
movlw 0x10
movwf FSR
movlw 0xFF
movwf INDF ; 0xFF @ 0x10
incf FSR, 1
movlw 0xFF
movwf INDF ; 0xFF @ 0x11
incf FSR, 1
movlw 0x0F
movwf INDF ; 0x0F @ 0x12

wait1
; On se place à la première adresse
movlw 0x10
movwf FSR

wait_decr
; On décompte
decfsz INDF, 1
goto wait_decr

wait_next
; Quand on arrive à zéro
; On passe au registre suivant
incf FSR, 1

wait2
; On quitte si on est arrivé au dernier registre
comf FSR, 0
andlw 0x13
btfsc STATUS, Z
return
; Sinon on décrémente le registre
decfsz INDF, 1
; Si le registre n'est pas vide on reprend le décompte
; A partir du premier registre
goto wait1
; Si le registre est aussi vide, on passe au suivant
goto wait_next
end
Et vous pouvez utiliser le Makefile suivant pour programmer/alimenter votre montage :

DEVICE=pic12f510
TARGET=MiniPic0.hex

AS=gpasm -q -w2 -p${DEVICE}
PK2=pk2cmd -P${DEVICE}


all: ${TARGET}

upload: ${TARGET}
$(PK2) -M -F${TARGET}
verify: ${TARGET}
$(PK2) -Y -F${TARGET}
dump:
$(PK2) -GF `date +%s`.hex
erase:
$(PK2) -E
$(PK2) -C
on:
$(PK2) -T
off:
$(PK2) -W

clean:
rm -f *.cod *.hex *.lst
%.hex: %.asm
${AS} $<
Pour finir, voici une vidéo du montage en fonctionnement :

Ajout d’un lecteur de carte SD au Routeur WRT54G

J’ai finalement craqué et ai ouvert mon routeur Linksys WRT54G (v2) pour ajouter un lecteur de carte SD.

Le principal intérêt, c’est de rajouter de la mémoire … beaucoup de mémoire, sachant que le routeur à l’origine ne possède que 8 Mo. L’autre intérêt, c’est de perdre la garantie. Et oui, faut pas rêver non plus, quand tu ouvres ton routeur et que tu soudes des fils directement sur les composants, il ne faut pas non plus croire au père Noël.
Donc la première étape, c’est de souder le lecteur de carte. Le plus dur, c’est de souder les fils sur le composant “RP3”, c’est relativement serré et en plus il faut en faire tenir 3 côte à côte.
Une fois ces soudures faites, c’est trop facile. Il n’y a plus qu’à mettre un peu de colle chaude pour bien faire tenir les fils (en essayant de pas appuyer dessus comme une brute … si si je confirme, ça arrache les fils).
Pour faire quelque chose qui a vraiment trop la classe, on peut ensuite souder les fils sur un connecteur de carte SD et faire un petite fente dans son routeur pour pouvoir changer la carte facilement.
La configuration avec OpenWRT est ensuite assez simple. J’ai pas mal modifié la configuration pour alléger au maximum le routeur … mais j’ai encore du boulot pour arriver à la version finale qui m’ira bien, trop de boulot.
Et voici le résultat final :

AReVi sur Ubuntu Hardy

Ce qui est bien avec Ubuntu, c’est que ça m’assure de poster un nouveau message tous les 6 mois.

Bref, voici la liste des paquets à installer sous Ubuntu Hardy (8.04) pour installer AReVi :

build-essential bison flex libglut-dev libimlib2-dev libmagick9-dev libavcodec-dev libavformat-dev libxslt-dev libopenal-dev libalut-dev

Avec ça, vous aurez : la 3D, le son 3D, les textures (jpg, png, bmp, gif, …), le support du XML et de la vidéo.

AReVi sur Ubuntu … la suite

Certains utilisateurs d’AReVi aiment bien faire de belles IHM GTK pour accompagner leurs projets.
Pour pouvoir compiler leurs sources sur Ubuntu, l’installation du package suivant devrait être suffisante :

libglade2-dev

Il se chargera d’installer toutes les dépendances nécessaires.

Installer l’AudioVideoEncoder d’AReVi sur Ubuntu

Il suffit d’installer les paquets suivants :

libavcodec-dev libavformat-dev libpostproc-dev libavutil-dev

et de modifier le fichier src/ExtContrib/AudioVideoEncoder/audioVideoEncoder.cpp, ligne 96 en enlevant le &, pour obtenir :

c=st->codec;

Le reste des paquets à installer pour ARéVi est disponible plus bas sur ce site.

Conversion de vidéo pour l’iPhone / l’iPod Touch

J’ai pas mal lutté pour arriver à encoder mes vidéos pour mon iPod Touch.

Je n’avais pas trouvé d’utilitaire me permettant d’enchaîner la conversion de fichiers. Du coup j’ai bouquiné les documents fournis par Apple pour me faire mon propre convertisseur.
Et voilà le résultat, un petit utilitaire utilisable en ligne de commande.
Ah oui, j’oubliais le plus important, pas besoin d’acheter Quicktime Pro pour que mon utilitaire marche.
Pour l’installer, il suffit de copier l’exécutable iPhoneConverter (disponible dans le dossier build/Release) dans votre dossier /usr/local/bin, dans un terminal :
cd /iPhoneConverter/build/Release
sudo cp iPhoneConverter /usr/local/bin
Son utilisation est la suivante :
iPhoneConverter fichier1 fichier2 … fichierN
Par exemple :
cd Movies
iPhoneConverter test.mov Films/film1.avi

On obtiendra dans le dossier Movies :
  • [iPhone] test.m4v
  • Films/[iPhone] film1.m4v
Sinon si vous préférez une bonne vieille interface graphique, je peux aussi vous recommander un petit utilitaire nommé QTAmateur.

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.