Je me fais le relais de Linuxfr.org, en espérant que ce peu de bruit puisse amener quelques contributions complémentaires.

À quelques semaines de la sortie du Cahier de l’admin Debian Squeeze, Roland Mas et moi‐même venons de lancer une campagne de financement pour réaliser la traduction anglaise de ce livre, mais aussi pour publier cette traduction sous licence libre !

Vous pouvez soutenir ce projet en commandant un exemplaire du livre à paraître (aussi bien la version française qu’anglaise). Selon le montant du soutien, vous avez le choix entre de nombreuses récompenses.

Cerise sur le gâteau, si vous soutenez le projet en cliquant sur ce lien, environ 12 % de l’argent donné sera reversé au projet Debian.

 

Plus d’informations sur  linuxfr.org,

Sinon, c’est par là :

• Campagne de financement,
• Site officiel du projet.

Si l’idée de modéliser un puzzle peut paraître quelconque, au premier abord,  le résultat final est bien sympathique. Jugez par vous-même :

Click here to view the video on YouTube.

Laissez-vous guider sur le blog de Torglut.

C’est en vidéo, c’est en Français et c’est par ici (http://torglut.blogspot.com/) !

Bonne visite !

Le site de l’April : www.april.org

Bien sûr, nous pouvons toujours nous en sortir avec Dia, Inkscape, Openoffice ou tout autre logiciel permettant le tracé de formes géométriques, mais le fait de de disposer de modèles de composants (widgets), à l’échelle, facilement positionables et alignables apportent un confort non négligeable.

Vous l’avez compris, Evolus Pencil Project rempli parfaitement ce rôle.

Pencil Project, à ne pas confondre avec l’outil de dessin et d’animation 2D du même nom (pencil), est une extension Firefox, développée sous licence GPL par la société Vietnamienne Evolus. Elle est tout de même disponible en version « standalone« , grâce à une exécution avec Xulrunner.

L’interface est sobre et la prise en main extrêmement rapide. L’application est fournie avec plusieurs styles de « widgets » qui s’intègrent dans votre maquette par un simple glissé / déposé. Des guides dynamiques aident au positionnement des composants. Les principales fonctions de dessin vectoriel sont disponibles (dessus, dessous, alignement, agrandissement, rotation, etc…) et permettent de fignoler la mise en page pour un résultat très propre.

Copie d’écran

L’enregistrement des fichier se fait sous l’extension « .ep », un format XML propre à Evolus Pencil. Pour la réutilisation d’un dessin dans un document ou tout simplement pour l’impression, il faut passer par un export au format PNG. Des exports vers d’autres formats (OpenOffice, Word, PDF, … ) sont prévus moyennant l’ajout de « templates ». A ce jour, je n’ai pas exploré cette piste, le format PNG me convenant parfaitement. Je regrette juste l’impossibilité d’imprimer directement depuis l’application.

Exemple de maquette  ( le message d’erreur a été vu sur : http://www.risacher.com/la-rache )

Lien :

Sur ce site, tu vas apprendre à construire une borne d’arcade en 6 mois. Les esprits chagrins diront que 6 mois, c’est très long.
Effectivement, c’est très long, surtout qu’on peut construire une borne d’arcade en 24 heures.
Seulement voilà, je suis assez mauvais en bricolage, d’où les 6 mois
Je remercie au passage l’auteur du site ci-dessus, sur lequel je me suis basé pour construire la borne.
Ce site est donc fait pour toi, qui possèdes à peu près le même niveau que moi en bricolage, c’est à dire un niveau 0 sur une échelle de 10.

Pour la leçon de bricolage, c’est par là !

]]> http://www.jopa.fr/index.php/2009/08/17/construire-sa-borne-darcade-en-6-mois/feed/ 3 http://www.jopa.fr/index.php/2009/07/31/miro-yet-another-video-player/ http://www.jopa.fr/index.php/2009/07/31/miro-yet-another-video-player/#comments Fri, 31 Jul 2009 08:05:51 +0000 Jopa http://www.jopa.fr/?p=1610 Ce qui est plaisant dans le monde du libre, c’est l’abondance  de logiciels: pour un besoin défini, il n’est pas rare que plusieurs applications correspondent, à moins bien-sûr que ce besoin ne soit très particulier ! Nous pouvons prendre comme exemple les suites bureautique, les clients de messagerie ou encore les environnements graphiques. C’est à l’utilisateur de faire son choix et c’est peut-être une des raisons qui déroute les adeptes de solutions commerciales.

Mais ce qui est vraiment génial, c’est la possibilité de partir à la découverte d’applications, sans même un besoin particulier. Il suffit de surfer un peu et lire quelques articles à droite et à gauche pour dénicher une perle qui pourra orner notre boîte à outil logicielle. C’est un bon passe temps et une activité très ludique pendant que « maman » regarde ses séries à la TV.

C’est dans cet état d’esprit que j’ai essayé Miro (anciennement appelé Democracy Player ou DTV).

Miro est un lecteur vidéo qui est capable de jouer pratiquement n’importe quel fichier vidéo et offre plus de 6000 émissions Web TV et podcasts vidéos gratuits. Il est dôté d’une interface simple mais bien finie, conçue pour la vidéo HD en plein écran. Comme Miro télécharge la plupart des vidéos, il est possible ensuite de les visionner sans connexion internet.

Actuellement en version 2.5, Miro s’installe très facilement, il suffit de suivre les instructions sur le site officiel. Bref, pas de quoi se priver ! Voilà un bon outil qui cohabitera très bien aux côtés de Totem et de VLC.

D’un point de vu système, Mir:ror est directement reconnu sous Linux et accessible via le handler de périphérique /dev/hidrawX (où X est le numéro de périphérique, normalement « 0″ si c’est le premier appareil du genre connecté).

La petite application « discover-device« , fournie avec Mirware, permet de le détecter automatiquement :

Attention tout de même aux droits, le périphérique n’est par défaut accessible que par root, il faudra lui changer les droits ou utiliser le script « installer.sh » pour le faire, avant de pouvoir l’exploiter avec un utilisateur standard.

Commençons par voir ce qu’il se passe avec un simple « cat » du fichier :

Des hiéroglyphes s’affichent lorsque nous approchons ou retirons un tag… C’est plutôt bon signe, et visiblement c’est binaire ! Nous devrions y voir plus clair avec un affichage en hexadécimal.  Hexdump est idéal pour ça !

La première ligne (0000 0000 0000 0000 0000 0000 0000 0000 *) nous indique que tant qu’il ne se passe rien, on lit des zéros… Où…Qu’on lit des zéros tant qu’il ne se passe rien ! (c’est plutôt normal).
Les deux lignes suivantes (0102 0000 d008 1a02 5303 4202 00d2 0000 – 0000 0000 0000 0000 0000 0000 0000 0000) s’affichent lorsqu’un tag est approché, les deux dernières ( 0202 0000 d008 1a02 5303 4202 00d2 0000 – 0000 0000 0000 0000 0000 0000 0000 0000 ) lorsqu’on éloigne le tag.

Après plusieurs tests, j’en déduis assez facilement que les deux premiers octets (0102 ou 0202) codent l’évènement. J’en ai repéré 4 types :

• 0×0102 : Tag rfid détecté,
• 0×0202 : Tag rfid retiré,
• 0×0501 : Le mir:ror est mis à l’envert,
• 0×0401 : Le mir:ror est remis à l’endroit.

Les 12 octets suivants semblent identifier la puce RFID.

A titre de test, écrivons rapidement un petit bout de code C, prenant le device en paramètre et affichant les évènements et le tag associé :

// Jopa - Petit test du Mir:ror : test_mirror.c
#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[]) {
  FILE *mirror;
  short unsigned int block;
  short unsigned int event;
  char tag[25];
  int i;
 
  //Vérification du paramètre (device)
  if (argc!=2) {
        printf ("Usage : %s mirror_device \n\n",argv[0]);
        exit(-1);
  }
 
  // Ouverture du fichier device
  mirror = fopen(argv[1],"rb");
  if (!mirror) {
        printf("Accès à  %s impossible !\n",argv[1]);
        exit(-1);
  }
 
  // Boucle en lecture
  while (1) {
     fread(&event,2,1,mirror);
     if (event!=0) {
        // Evenement detecté, lecture de l'ID
        for (i=0;i<6;i++) {
            fread(&block,2,1,mirror);
            sprintf(&tag[i*4],"%04X",block);
        }
 
 //Affichage en fonction de l'événement
        switch (event) {
            // Tag On
            case 0x102 :
                printf("%s : ON\n",tag);
                break;
 
             //Tag Off
             case 0x202 :
                 printf("%s : OFF\n",tag);
                 break;
 
             //Mirror envers
             case 0x501 :
                 printf("MIR:ROR ENVERS\n");
                 break;
 
             //Mirror endroit
             case 0x401 :
                   printf("MIR:ROR ENDROIT\n");
                    break;
 
             //Default
             default :
                   printf("Evénement inconnu\n");
        } //switch
      } //if (event
   } //while (1)
} // main()

En quelques lignes, nous ouvrons le périphérique dont le handler est passé en paramètre et bouclons sur sa lecture, 2 octets par 2 octets.
Quand autre chose que « 0″ est détecté, c’est forcément un changement d’état. Nous lisons ensuite l’identifiant de la puce RFID.
La dernière partie affiche un message en fonction de l’évènement détecté.

Il ne reste plus qu’à le compiler et le tester :
$ gcc test_mirror.c -o test_mirror
$ ./test_mirror

Pour compléter l’exemple, nous pouvons rajouter l’exécution d’un script associé au tag et à son approche ou son éloignement. Les scripts pourraient être stockés dans le répertoire de l’utilisateur et porter l’<id>-on.sh ou l’<id>-off.sh comme nom. Pour l’exemple :

• 0000D0081A025303420200D2-on.sh : Lancement de Firefox sur le blog de Jopa

#!/bin/sh
firefox http://www.jopa.fr

• 0000D0081A025303420200D2-off.sh : Lancement de Thunderbird

#!/bin/sh
thunderbird

$ chmod +x ~/0000D0081A025303420200D2-*.sh

Adaptons un peu le code en ajoutant une variable pour le nom du script et une commande « system » dans le « switch/case ».

   // Jopa - Test Mir:ror
 
#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[]) {
  FILE *mirror;
  short unsigned int block;
  short unsigned int event;
  char tag[25];
  // Ajout d'un variable script
  char script[256];
  int i;
 
  //Vérification du paramètre (device)
  if (argc!=2) {
        printf ("Usage : %s mirror_device \n\n",argv[0]);
        exit(-1);
  }
 
  // Ouverture du fichier device
  mirror = fopen(argv[1],"rb");
  if (!mirror) {
        printf("Accès à  %s impossible !\n",argv[1]);
        exit(-1);
  }
 
  // Boucle en lecture
  while (1) {
     fread(&event,2,1,mirror);
     if (event!=0) {
        // Evenement detecté, lecture de l'ID
        for (i=0;i<6;i++) {
            fread(&block,2,1,mirror);
            sprintf(&tag[i*4],"%04X",block);
        }
 
 //Affichage en fonction de l'événement
        switch (event) {
            // Tag On
            case 0x102 :
                printf("%s : ON\n",tag);
                //Construction du nom de script et exécution
                sprintf(script,"./%s-on.sh",tag);
                system(script);
                break;
 
             //Tag Off
             case 0x202 :
                 printf("%s : OFF\n",tag);
                 //Construction du nom de script et exécution
                 sprintf(script,"./%s-off.sh",tag);
                 system(script);
                 break;
 
             //Mirror envers
             case 0x501 :
                 printf("MIR:ROR ENVERS\n");
                 break;
 
             //Mirror endroit
             case 0x401 :
                   printf("MIR:ROR ENDROIT\n");
                    break;
 
             //Default
             default :
                   printf("Evénement inconnu");
        } //switch
      } //if (event
   } //while (1)
} // main()

Ceci n’est bien entendu qu’un exemple, écrit rapidement et pas forcément très propre. Mais il permet de mettre en évidence la simplicité avec laquelle il est possible d’accéder à des informations RFID et ouvre la porte sur des développements qui peuvent être rapidement prometteurs.

$ sudo apt-get install subversion pkg-config python perl g++ bison flex gperf libnss3-dev libgtk2.0-dev libnspr4-0d libnspr4-dev msttcorefonts libgconf2-dev libcairo2-dev libdbus-1-dev

Si comme moi, vous jouissez d’une distribution 64 bits :

$ sudo apt-get install gcc-multilib g++-multilib gobjc-multilib gobjc++-multilib

Et en option :

$ sudo apt-get install wdiff lighttpd php5-cgi sun-java6-fonts

Nous allons ensuite installer les utilitaires nécessaires pour l’accès au SVN google ( depot tools ) :

$ mkdir CHROME
$ cd CHROME
$ svn co http://src.chromium.org/svn/trunk/tools/depot_tools

Et récupérer les sources :

$ export LANG=C
$ depot_tools/gclient config http://src.chromium.org/svn/trunk/src http://chromium-status.appspot.com/lkgr
$ depot_tools/gclient sync

gclient va rapatrier un peu plus de 3 Go ( C’est que ce n’est pas du code de fillette tout ça ! ) …

Révision 43806 extraite.

________ running ‘/usr/bin/python src/tools/gyp/gyp_dogfood src/build/all.gyp’ in ‘/usr/local/src/CHROME
Updating projects from gyp files…

A ce stade, j’en suis à me demander comment, avec un code source de 3Go, je vais obtenir un navigateur réputé pour sa légèreté et sa rapidité d’exécution… Même si, par défaut, les sources incluent toutes les plateformes, les librairies utilisées et tout un tas de bazard…

Pour le savoir, le mieux est de lancer la compil :

$  cd src/build
$ ../../depot_tools/hammer

Par defaut, chromium est compilé en mode debug et c’est plutôt logique pour une version de developpement. Pour forcer le mode release :

$ ../../depot_tools/hammer –mode=Release

Les binaires sont placés dans le répertoire src/sconsbuild/debug ou srv/sconsbuild/release suivant le mode compilé.

$ CHROME/src/sconsbuild/release/chrome

Comme vous le verrez sur la page de démarrage, ornée d’un immanquable panneau stop rouge, le navigateur est en version pre-alpha… En bref, ne vous attendez pas à quelque chose de très stable…

Pour plus d’informations, vous pouvez consulter les instruction de compilation, sur le wiki officiel : http://code.google.com/p/chromium/wiki/LinuxBuildInstructions