Nouvelle adresse

Mes nouveaux posts seront désormais sur : http://blog.ithasu.org/.

Pour le flux RSS, il faudra maintenant utiliser cette adresse : http://blog.ithasu.org/feed/.

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 OK\r\n"
 "Cache: no-cache\r\n"
 "Content-Type: text/html\r\n"
 "\r\n";

// 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;
}

Et maintenant sous Pachube

Week-end productif, pour comparer je viens de faire la même manip qu'hier sous Pachube. Voici le résultat intégré dans ce post.



Et le script pour envoyer, toujours assez simple et lancé sur ma Fonera avec cron :

APIKEY="?"

WURL="http://weather.yahooapis.com/forecastrss?w=581787&u=c"
TEMP=`curl "${WURL}" 2>/dev/null | grep "" | sed -e "s/^.*temp=\"/0, /" | sed -e "s/\".*$//"`
curl --request PUT --data-binary "${TEMP}" --header "X-PachubeApiKey: ${APIKEY}" http://api.pachube.com/v2/feeds/15809.csv

Premier essai : Nimbits

Nimbits est un service à la Pachube qui permet de logger des données sur internet.

J'ai fait un petit script Bash pour ma Fonera qui permet de logger la température à partir des données fournies par Yahoo Weather ... oui, j'aurai pu mettre un capteur sur ma Fonera, mais j'en avais pas et puis même j'aurai eu la flemme.

Franchement, ça marche comme Pachube, il suffit de faire un POST avec la nouvelle valeur (j'ai utilisé Curl en Bash sous OpenWrt). Bon ça marche, je mets à jour ma valeur, j'utilise cron pour l'actualiser régulièrement.

Maintenant une petite comparaison entre Pachube et Nimbits. A mon avis un des gros avantages de Nimbits est qu'il est vraiment open source, c'est à dire qu'il est possible de créer son propre serveur, au contraire de Pachube qui ne permet pas de le faire (en tout cas, j'ai bien cherché, j'ai pas trouvé). Une contrainte cependant, est que le serveur est écrit pour Google Apps (développé en Java).

Un avantage de Pachube est qu'il est beaucoup plus aboutit graphiquement, l'interface de Nimbits est encore à travailler un peu.

Il y a encore plein de trucs à tester, notamment les notifications Twitter / Mail / GTalk déclenchées sur des dépassements de seuil.

Le script :

#!/bin/sh

MAIL=xxx@domain.com

SECRET=????????-????-????-????-????????????

NAME=PointName

URL=http://app.nimbits.com/service/currentvalue

WURL="http://weather.yahooapis.com/forecastrss?w=581787&u=c"

VALUE=`curl "${WURL}" 2>/dev/null | grep "" | sed -e "s/^.*temp=\"//" | sed -e "s/\".*$//"`

curl -d "email=${MAIL}&secret=${SECRET}&point=${NAME}&value=${VALUE}" "${URL}"

Thème pour Dotclear

Allez, des fois que quelqu'un lise ce blog, voici un lien vers le site de ma femme. Il contient l'ensemble des objets quelle a réalisé avec ses petites mains ...

http://www.ateliers-recreatifs.fr/

Mon préféré du moment ce sont les cadres 3D avec une photo qui flotte au milieu, ça fait vachement classe dans notre salon.

Son site est évidemment bien plus actif que le mien avec au moins une réalisation par semaine. Au passage, c'est moi qui est réalisé le thème (enfin le CSS, les images c'est elle) pour dotclear 2 :)

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 :