FaitMain.org

5 petits trucs sur la photographie culinaire

2013-02-01T00:00:00Z

Cuisine | Art Niveau: Vulgarisation Brin de cuisine

Contrairement à ce qu'on croit, réaliser une jolie photo culinaire nécessite de la préparation. D'abord, imaginer, et cette étape doit avoir lieu avant même d'avoir réalisé la recette ! Ensuite, si l'on est tout seul à revêtir à la fois la toque de cuisinier, les gants des assistants lumière et la casquette de photographe, mieux vaut s'organiser. C'est bien plus facile à plusieurs ...

Retrouvez toutes les recettes sur http://www.brindecuisine.fr

1. Scénariser ¶

Certains plats délicieux ne sont pas forcement présentables, il est donc nécessaire d'en tenir compte. Par exemple, pour un plat mijoté, il vous sera nécessaire de veiller à soigner le découpage de votre viande, ainsi que le parage de vos légumes, pour pouvoir les présenter d'une manière agréable à l'œil.

Le tajine est un bon exemple. Pour le rendre appétissant, j'ai disposé les morceaux dans une assiette, en otant le jus de cuisson

Penser aussi dès cette étape à l'harmonisation du plat avec la vaisselle et le décor, que vous pouvez choisir neutre ou signifiant.


Un fond blanc et un voilage très simple sont un exemple de décor neutre.	Un décor signifiant donne aussi beaucoup d'ambiance à une photo.

2. Éclairer ¶

Privilégiez autant que possible la lumière naturelle, c'est elle qui donne les couleurs les plus appétissantes. Dehors ou derrière une fenêtre, le soleil permet de multiples éclairages. Un voilage servira de diffuseur. Attention à la lumière directe, qui donne des ombres dures.


Une lumière du jour rasante donne de la profondeur à l'image	La lumière artificielle est plus difficile à gérer. Mais parfois, on n'a pas le choix, notamment en hiver, lorsque le jour est de courte durée.

Les nuages forment le meilleur des diffuseurs.

3. Préparer ¶

Avant de réaliser votre photo, faites votre mise en scène avec la vaisselle et accessoires, sans le plat. Cela vous permettra de vérifier quelle prise de vues est la plus adaptée. Variez la focale, les angles et l'orientation de la lumière, la distance de prise de vues, et si votre appareil se débraye, la profondeur de champ : ces paramètres ne donnent pas du tout les mêmes effets.

La macro donne toute sa place au sujet de la photo

4. Cadrer ¶

La photo culinaire se prête à de nombreux styles photographiques. Clair ou sombre, en plan rapproché ou plus éloigné, en nature morte ou avec présence humaine, à vous de trouver votre préféré. Ou bien de varier selon les recettes. Voici quelques exemples :


Lifestyle, c'est-à-dire prise de vue intégrant la présence humaine	Style "nature", lumière du jour et ingrédients frais


Plan rapproché en studio, double éclairage latéral de même puissance.	Clair-obscur.


La vue plongeante est adaptée aux recettes familiales, réalisées dans de grands plats.	Le high key consiste à éclairer fortement le sujet, et à légèrement surexposer afin qu'il n'y ait aucune zone de couleur noire, et le moins possible d'ombre grise.

5. Planifier ¶

Les préparations froides permettent évidemment de prendre tout son temps, mais ce n'est pas le cas des plats chauds dont l'aspect se matifie en refroidissant, le rendant moins appétissant. Il faut donc que tout soit prêt avant de mettre votre préparation dans le cadre de la photo. Je vous conseille de poser votre appareil sur pied, l'allumer, cadrer, et d'ensuite seulement disposer les éléments.

Réagissez sur cet article .

Cable d'interface pour Raspberry Pi

2013-02-01T00:00:00Z

Informatique | Électronique Niveau: Vulgarisation François Dion

Exemple de circuit fait main relié a un Raspberry Pi, avec un cable fait main.

Une des fonctions qui a contribué au succès du Raspberry Pi, c'est la possibilité d'interface avec le monde extérieur. On parle ici des GPIO (en anglais les « General Purpose Input and Output » – entrées et sorties pour tout usage), qui se retrouvent au connecteur P1. En fabricant notre propre câble, on pourra se connecter à des DELs (diodes électroluminescentes), des moteurs ou autres composants physiques.

Comment faire un cable d'interface GPIO ¶

Nous allons faire du recyclage aujourd'hui. En effet, le type de câble que l'on va faire, un câble plat a 26 conducteurs, est très proche d'un câble très commun que l'on peut retrouver un peu partout, dans le fond d'un tiroir, dans une boite de vieux composantes d'ordinateur... Il suffit de fouiller un peu, il y en a des dizaines de millions qui ne demandent qu'à se rendre utile une fois de plus.

De quoi s'agit'il ? D'une nappe pour disque dur IDE (ou ATA ) à 40 conducteurs. On peut aussi utiliser un câble ATA66/133 à 80 conducteurs, mais c'est beaucoup plus de boulot, et il y a le risque de se retrouver avec un câble qui ne fonctionne pas, dû à un court-circuit entre la mise à la masse et notre signal. Je recommande donc plutôt les câbles à 40 conducteurs, plus vieux et très communs :

Cable IDE pour disque dur, 40 conducteurs.

Au boulot ¶

Nous aurons besoin de 2 connecteurs, et non de 3. Avec un câble comme celui de la photo, on coupe une section avec des ciseaux :

On coupe l'extra avec des ciseaux.

Il faut ensuite diviser le câble. En effet, on n'a besoin que de 26 conducteurs, et on en a 40. Avec le fil rouge a gauche, on compte 26 fils et on marque avec un feutre permanent la division. On compte du cote droit pour s'assurer que l'on a bien 14 fils, pas un de plus ou de moins.

Marquer au feutre une ligne qui délimite 26 et 14 conducteurs.

La prochaine étape consiste a faire une incision avec un couteau genre X-acto ou un scalpel, dans la rainure entre les 2 fils, et ceci sans endommager l'isolation des fils. Le plus simple c'est de commencer l'incision au couteau et de la finir à la main, en tirant de chaque cote de l'incision.

Faire l'incision et séparer les 2 parties.

Il faut maintenant couper le connecteur exactement sur la septième rangée de trous, en partant de la droite. On peut le faire avec une petite scie a découper le métal, ou encore avec une meule a découper, dans le genre Dremel.

Faire la découpe. Ici, on a mis un connecteur male de 2x13 pour s'assurer de ne pas se tromper d'endroit.

On enlève la partie du dessus, puis la section de câble à 14 conducteurs, et puis finalement, après avoir fait une entaille, on enlève la partie de dessous.

On enlève la portion de droite.

On est prêt à connecter notre câble à notre Raspberry Pi. Le fil rouge marque la position #1 sur le connecteur P1. Il faut donc insérer le câble pour que ce fil rouge soit du cote de la carte SD, et non pas du cote du connecteur RCA / video composite (jaune) :

Conducteur rouge sur position #1, pres de la carte SD.

Connections ¶

Afin de vérifier le fonctionnement de notre câble, on va faire une connexion de 2 DELs, une rouge et une verte. Pas besoin de fil ou soudure car on va simplement insérer les DELs dans les trous du câble.

En suivant le diagramme ci dessous :

La patte courte de la DEL rouge et de la DEL verte vont se connecter au troisième trou du cote gauche
La patte longue de la DEL rouge au deuxième trou du cote droit
La patte longue de la DEL verte au troisième trou du cote droit

Le Python ¶

Avant toute chose, on doit se procurer un module Python du nom de RPi.GPIO . C'est un module qui permet de contrôler les GPIO sur un Raspberry Pi. Sur Raspbian, il est maintenant inclus, mais si on utilise une autre version de Linux, on peut l'installer grâce a

easy_install RPi.GPIO

ou bien par apt-get :

$ sudo apt-get install python-rpi.gpio

Créer un fichier portant le nom flashled.py ayant le contenu suivant :

#!/usr/bin/env python
""" 2 DEL qui s'allument en alternance """
import RPi.GPIO as gpio
import time

PINR = 0  # on utilisera 2 sur un RPi V2
PING = 1  # on utilisera 3 sur un RPi V2

gpio.setmode(gpio.BCM)  # mode Broadcom
gpio.setup(PINR, gpio.OUT)  # DEL rouge en mode sortie (OUT)
gpio.setup(PING, gpio.OUT)  # DEL verte en mode sortie (OUT)

#On alterne pour l'eternite
try:
    while True:
        gpio.output(PINR, gpio.HIGH)
        gpio.output(PING, gpio.LOW)
        time.sleep(1)
        gpio.output(PINR, gpio.LOW)
        gpio.output(PING, gpio.HIGH)
        time.sleep(1)
except KeyboardInterrupt:
    gpio.cleanup()

PINR est le GPIO pour la DEL rouge (0 pour un Rpi V1 et 2 pour un V2)
PING est le GPIO pour la DEL verte (1 pour un Rpi V1 et 3 pour un V2)

On sélectionne le mode Broadcom (BCM), et on active les 2 GPIO comme sorties (OUT). La boucle va alterner entre DEL rouge allumée / DEL verte éteinte durant 1 seconde, et DEL rouge éteinte / DEL verte allumée durant une seconde ( time.sleep(1) ). Si on fait un CTRL-C durant l'exécution, le programme termine après avoir fait le ménage, par l'entremise de gpio.cleanup() .

On y va ¶

Normalement, on doit toujours protéger une DEL avec une résistance, pour limiter le courant. Toutefois, comme les GPIO ne peuvent fournir que 20mA et que dans ce test on allume les DELs de façon intermittente, on peut ignorer cette résistance sans risque dans ce cas particulier.

Pour un usage prolongé, on va devoir ajouter une résistance en série de 220 a 360 Ohm.

Pour lancer le script que l'on vient de sauver, on doit le rendre exécutable, et le lancer avec permission root (sudo), à cause du module RPi.GPIO qui a besoin d'accéder en écriture à /dev/mem :

$ chmod +x flashled.py
$ sudo ./flashled.py

CTRL-C interrompt l'exécution.


DEL Rouge	DEL Vert

Ceci conclut notre petit article. Dans un prochain numéro, nous allons fabriquer un adaptateur pour plaque de prototypage.

Réagissez sur cet article .

Cindermedusae - Les Créatures Génératives

2013-01-02T00:00:00Z

Art | Informatique Niveau: Avancé Marcin Ignac Traduction: Tarek Ziadé

Cet article est une traduction adaptée de l'article de Marcin Ignac originalement paru en anglais sur son blog à cette addresse .

Vous pouvez retrouvez tous les projets de Marcin ici : http://marcinignac.com/projects/category/featured/

Les méduses en action

Cindermedusae est un projet qui me tient beaucoup à cœur. Il a été réalisé très vite (en une semaine) et a été intensif. Mais les résultats que j'ai obtenus sont très concluants. J'ai toujours aimé l'idée de livre génératif et la première fois que j'ai entendu parler du concours de Written Images cela m'a tout de suite donné envie de participer.

Written Images est un projet de livre génératif qui a été financé via la communauté KickStarter et qui présente des images générées par des programmes fournis par des artistes. Chaque impression de livre est calculée individuellement — afin de créer des livres uniques.

Cindermedusae a été selectionné avec 47 autres projets pour faire partie du livre.

Un des livres imprimés © d_effekt

Je travaillais encore chez shiftcontrol à cette époque, pour un projet de jeu sous-marin pour la ZDF appelé Universum Der Oceane en collaboration avec les architectes de Hosoya Schaefer . Vous pouvez trouver plus d'information sur ce projet ici .

Nous avions beaucoup de réunions pour discuter de l'ergonomie du jeu et du comportement des créatures sous-marines — et c'est probablement ce qui m'a intéressé aux méduses géantes.

Ces animaux sont extraordinaires — j'adore la façon dont elles se déplacent lentement . Un choix parfait pour tordre des fils de fers avec du code.

Animation procédurale ¶

L' animation procédurale consiste à animer des objets en temps réel par le biais d'un ensemble de règles procédurales, c'est-à-dire une description des règles de fonctionnement du monde physique et un ensemble de conditions initiales.

Ce n'est pas la première fois que je fais de l'animation procédurale. En fait, toute la Scène démo en use et abuse. Un bon exemple est le torus en forme de cactus dans l'introduction de mon projet Borntro .

Le code original de Cindermedusae est en C++ et utilise la bibliothèque Cinder mais je décris dans cet article les idées de base de l'animation de méduses avec des exemples de code en processing.js , le portage de Processing en Javascript.

La plupart des exemples sont interactifs et en 2D — c'est plus facile à comprendre (et à dessiner !). Dans quelques cas je présente des exemples en 3D et il faut un navigateur compatible WebGL pour que cela fonctionne.

Tête de la méduse ¶

Commençons avec un cercle — ou une sphère en 3D, vue du dessus. C'est l'ensemble des points équidistants d'un point unique, le centre du cercle. Si ce cercle a pour coordonnées (0, 0) , et que le rayon du cercle est r , tous les points du cercles peuvent être décrits comme les fonction de l'angle phi , variant de 0 à 2π.

x = r * cos(phi)
y = r * sin(phi)

L'étape suivante consiste à ajuster dynamiquement le rayon avec une fonction sinusoïdale pour qu'il varie de 0.925 à 1.075 soit de 92.5% à 107.5% de sa valeur initiale.

On multiplie aussi l'angle par dix pour avoir cet effet de vague dix fois dans le cercle.

x = r * (1 + 0.075 * cos(phi * 10)) * cos(phi)
y = r * (1 + 0.075 * cos(phi * 10)) * sin(phi)

Les segments rouges que vous voyez sur l'image sont les segments séléctionnés comme points de départ pour accrocher les tentacules de la méduse. Nous nous y intéresserons plus tard.

Vue des têtes du dessus — cliquez pour le code

Si l'on regarde la tête de notre méduse en 2D sur le côté, c'est aussi un cercle, puisqu'à la fin nous jouons avec des sphères.

La différence avec le calcul précédent est que cette fois-ci, la variation de l'angle theta va de 0 (en haut) à 2π (en bas)

La tête est symétrique le long de l'axe Y, donc nous construirons 2 points à chaque étape — un à gauche et un à droite :

x = r * cos(theta)
y = r * sin(theta)
x' = -x
y' =  y

Sachant que la tête de la méduse ressemble plus à un dôme qu'une sphère, nous devons faire une forme qui est convexe au dessus et concave en dessous.

Il suffit d'inverser la valeur de la coordonnée Y en atteignant π/2, ou 90' dans notre cas. On ajoute aussi r/2 pour pousser l'arc de cercle obtenu après π/2 vers le bas, afin que les deux arcs ne se confondent pas :

if (theta < PI/2) {
    x = r * cos(theta) y = r * sin(theta)
} else {
    x = r * cos(theta)
    y = -r * sin(theta) + r * 0.5
}

Enfin, on arrondit les angles pour un meilleur rendu, et aussi pour éviter des artefacts d'ombre. Je ne vais pas décrire cette étape ici, car c'est juste un if et un sin supplémentaires. Vous pouvez lire le code source fourni.

Vue des têtes de côté — cliquez pour le code

Il y a de meilleures techniques d'animations mais comme Written Images n'était pas un concours d'animation, j'ai utilisé l'outil le plus simple : sin() . Personne ne verra la différence sur des pages statiques de toute façon.

Pour chaque frame où je calcule les positions x et y, je calcule aussi la droite normale à la surface .

Ensuite, si l'animation est lancée, je déplace le point le long de la normale en utilisant la valeur de la fonction sin() à un instant t . Cette formule déplace les points mais sans rien faire de plus, la tête se mettrait à faire des pulsations comme un cœur, en grossissant et rétrécissant — car tous les points se déplacent en phase.

C'est pourquoi j'ajoute y * 0.5 à t pour introduire un décalage de phase le long de l'axe Y et la structure en fil de fer ( wireframe ou mesh en anglais) commence à bouger d'une manière un peu plus naturelle.

x += normal.x * sin(t + y * 0.5)
y += normal.y * sin(t + y * 0.5)

Vue animée des têtes de côté — cliquez pour code & animation

J'ai décidé de combiner toutes les étapes dans un script processing.js en 3D, et à ma surprise le code obtenu est quasiment un copier-coller de la version C++. J'ai essayé de garder le code le plus simple & clair possible pour cet article, donc il n'est pas optimal : les performances ne sont pas au rendez-vous.

Vue animée en 3D — cliquez pour code & animation

Tentacules ¶

Problème Etant donné une courbe — ou plutôt une ligne polygonale, fabriquez un mesh en forme de tube autour de cette ligne.

Solution On démarre avec trois vecteurs perpendiculaires :

Forward - généralement le vecteur normal à l'endroit où je veux accrocher la tentacule — ou si j'ai l'équation de la courbe, ce serait le vecteur tangeant.
Up - choisi arbitrairement : (0,1,0) et
Left qui peut être calculé avec la règle de la main droite .

La formule de la règle de la main droite s'applique ainsi :

L = U x F

Où x est le produit vectoriel des deux vecteurs à trois dimensions.

Pour le deuxième point de notre ligne, on a le nouveau vecteur F' et l'on conserve le même vecteur L , on peut calculer le nouveau vecteur U' :

U' = F' x L

En répétant cette opération pour chaque point/segment de la ligne, on obtient une série de coordonnées pour chaque vecteur Up , Front et Left .

Règle de la main droite

Tous ces calculs sont inspirés du repère de Frenet .

Si vous développez dans Cinder, vous n'avez pas à vous soucier de tous ces calculs, car le développeur Chaoticbob a contribué un système encore plus performant : les Parallel Transport Frames .

Maintenant que nous avons les vecteurs Up et Forward , il est facile de construire des triangles. Dans l'exemple suivant j'ai ajouté deux élements supplémentaires. Le premier ajout est une réduction du vecteur Up pour que la pointe de la tentacule apparaisse plus fine.

Le deuxième ajout est un enroulement de la tentacule en fonction de la position de la souris. La tentacule est de plus en plus enroulée au fur et à mesure que l'on se rapproche de la pointe — la force de cette enroulement est représentée par des lignes rouges.

Tentacules animées — cliquez sur l'image

Nous sommes maintenant prêts à attacher les tentacules à la tête. Je regroupe tous les éléments car le travail des ombres masquera les discontinuités de la surface.

Tentacules & corps animés — cliquez sur l'image

Rendu final ¶

J'ai utilisé une géométrie de triangles beaucoup plus dense pour le rendu ci-dessus, pour des plus belles courbes et pour éviter des artefacts d'antialiasing.

Rendu final

Ombres procédurales ¶

Lorsque j'ai commencé ce projet, je faisais des essais avec de la Transluminescence et j'avais des rendus assez beaux .

Mais j'ai changé d'avis après être tombé sur le travail de Ernst Haeckel et son livre incroyable : "Kunstformen der Natur" . Je savais que c'était la bonne voie.

La première étape est d'utiliser de la lumière diffuse standard juste pour vérifier que mon wireframe est suffisament lisse et n'a pas de normales au comportement étrange.

Lumière diffuse appliquée au modèle 3D.

Hachurage ¶

Il y a beaucoup d'articles de recherche sur les techniques pour avoir un rendu croquis . J'ai basé mon implémentation sur du code issu du livre OpenGL Shading Language Book

L'algorithme génère d'abord des traits verticaux avec les coordonnées de texture, puis choisit la densité des traits en fonction de la lumière diffuse. Moins il y a de lumière, plus la densité des traits augmente.

Un paramètre important pour un beau rendu est de bien choisir l'épaisseur des traits : ni trop fin pour ne pas avoir d'effet de moiré , ni trop épais pour ne pas perdre en finesse de rendu.

Un grand rendu hors-écran dans un framebuffer object de 4080 sur 2720 pixels, et l'antialiasing aident beaucoup à choisir la bonne épaisseur.

Hachurage — cliquez pour la version hi-res

Malheureusement il n'y a aucun exemple basé sur processing.js, en partie car j'utilise des fonctionnalités qui dépendent des extensions WebGL GLSL , comme GL_OES_standard_derivatives et les fonctions dFdx / dFdy .

Pour aller plus loin, vous pouvez consulter le livre mentioné.

Couleurs ¶

Chaque image est composée de cinq couches :

un fond jaune
des coins de page orange
un hachurage en noir
des reflets bleus
des bordures roses

Les reflets bleus et les coins de pages ont été bruités pour donner une impression de coloriage à la main.

Colorisation — cliquez pour la version hi-res

Résultat final combiné

Paramétrage ¶

J'ai aussi créé une interface graphique de paramètrage très simple. Cette interface me permet de jouer avec l'ensemble des paramètres de la simulation et de regarder comment la créature évolue en temps réel. Pour les paramètres qui varient entre une valeur minimale et maximale, l'interface me permet de calibrer ces limites afin de garder un rendu de méduse réaliste.

Interface de paramétrage

La suite ? ¶

J'ai très envie de continuer le travail sur ce projet. Une amélioration évidente serait d'optimiser le code pour que le nombre de frames par secondes (FPS) soit correct. Il plafonne actuellement à 10 FPS.

Je pensais aussi faire un portage sur WebGL pour que les utilisateurs puissent s'amuser à créer leurs propres créatures en ligne.

Enfin, j'aimerais étendre le système et jouer avec d'autres types d'organismes ou de plantes.

Réagissez sur cet article .

Le monde merveilleux des CNCs

2013-02-01T00:00:00Z

Électronique | Informatique Niveau: Moyen Alcor Walter

2012 a vu l'impression 3D devenir un sujet qui n'intéresse plus uniquement les blogs spécialisés et certains geeks au fond de leur garage ; on entend dire que "monsieur tout le monde" aura bientôt une imprimante 3D à coté de son imprimante-jet-d'encre-A4-photo-wifi. L'effet "nouveauté" est réel même si on ne sait pas encore l'avenir d'un tel produit. C'est également l'image industrielle de ses semblables (découpe laser, découpe plasma, tours numériques, CNCs etc) qui s'estompe ; on s'imagine possible d'utiliser, voire de construire ou d'acheter ces outils. D'ailleurs on vient de s'y mettre et voici ce qu'on peut vous dire pour vous accompagner lors de votre lancement :

Ce que nous allons apprendre de la CNC qui est dans ma cave

Un peu d'histoire pour mieux comprendre ¶

L'histoire de la machine-outil à commande numérique n'est pas récente, on trouve la première machine-outil en 1751 ( Jacques de Vaucanson invente le tour à charioter), les premières machines-outils automatisées (par cames) au XIXème siècle et c'est vraisemblablement en 1942 que l'histoire de la machine-outil à commande numérique débute, grâce à John T. Parsons .

La programmation se faisait avec des cartes perforées, tout d'abord pour les calculs et quelques années plus tard - lorsque les servomoteurs ont été mis au point - pour le contrôle. Cependant, les coûts et les usages réservent de telles machines à l'industrie de pointe, à l'armement, etc et ne sortent que rarement des laboratoires de recherche.

La technologie va continuer de se perfectionner mais aussi devenir plus abordable et va rejoindre les bureaux d'études et les chaînes de production de produits destinés au grand public. À tel point que depuis deux ou trois décennies cette technologie devient accessible aux petites entreprises et aux passionnés avertis ; demain elle arrivera peut-être dans le grand public sous la forme d'une imprimante 3D, qui sait ?

Définition ¶

Une CNC (Computer Numerical Control) ou MOCN (Machine-Outil à Commande Numérique) est donc tout d'abord une machine-outil : elle permet selon ses caractéristiques d'effectuer diverses opérations - percer, scier, rectifier, découper, fraiser, plier, graver, tarauder, souder, visser, déposer un matériau, etc - nécessitant des gestes précis et/ou répétitifs, sur des matériaux divers. Dans le cas d'une CNC, ces opérations seront donc commandées par un ordinateur ou un dispositif numérique.

Sous la dénomination "CNC" se retrouvent de nombreux dispositifs qui diffèrent entre eux principalement par l'outil qui est utilisé. Je présenterai ici le principe d'une CNC permettant d'usiner par retrait de matière à l'aide de fraises, forets, etc. Cette CNC a été imaginée et construite par un particulier à qui nous l'avons achetée récemment. Enfin, ma connaissance du domaine est très récente et surtout autodidacte ; je n'ai jamais suivi de formation et n'ai aucun diplôme de technicien d'usinage ou autre.

Possibilités ¶

Les matériaux qui peuvent être usinés sont très divers, la caractéristique principale qui les différencie est la dureté. Plus le matériau est dur, plus il faudra que la CNC, ainsi que l'outil qui l'équipe aient la qualité et la puissance nécessaires pour usiner le matériau. Cependant pour commencer à usiner sans forcément aller rapidement, c'est principalement l'outil et la vitesse de rotation de celui-ci qui vont influer.

Voici une liste non exhaustive de matériaux que l'on peut usiner :

acier
aluminium
laiton
polycarbonate
bois massif
contreplaqué
résine
mdf
mousse

Dans certains cas, l'usinage requiert de l'huile de coupe, de l'air sous pression, ou autre. Le but recherché est de refroidir le matériau et l'outil, mais également de lubrifier pour réduire les frottements et l'usure prématurée. L'air comprimé est plus adapté lors de la découpe du polycarbonate par exemple pour éviter que le matériau fonde et vienne se recoller sur l'outil ou le matériau. Attention à ne pas utiliser n'importe quel produit, pensez d'abord à votre sécurité et à votre santé. Dans tous les cas, avec ou sans huile de coupe, le port d'un masque, de lunettes de protection et de bouchons d'oreille est obligatoire si la CNC n'a pas d'équipement vous protégeant des nuisances (projections de copeaux, de fluide de coupe, fumées, casse, bruit, etc).

En dehors de l'industrie, les domaines d'utilisation d'une CNC sont nombreux, voici quelques exemples : Le modélisme (ailes et panneaux d'avions, châssis de voiture, éléments de bâtiments), l'électronique (circuits imprimés, boîtier pour montages), la réparation (poignées, butées, guides, engrenages), la décoration, l'ébénisterie, la lutherie, la mécanique, etc.

L'imagination, l’expérimentation et la recherche de chacun amèneront leur part de nouveauté dans ce domaine.

Structure ¶

Observons techniquement de quoi est composée une CNC, en partant de la table qui accueillera le matériau à usiner. La base est similaire à ce qu'on aurait dans le cas d'un usinage manuel : le matériau doit être solidement fixé à une table d'usinage à l'aide d'un étau, de butées, de pinces, ou collée, etc, selon les besoins. Parfois la table d'usinage peut-être une table aspirante ou un "martyr".


Table d'usinage "martyr"	Table aspirante

L'usinage du matériau peut se faire avec un outil (une fraise, un foret, une lame, une pointe à graver, etc) dont les caractéristiques sont adaptées au matériau et à l'opération à réaliser. Cet outil est monté sur ce qu'on appelle une broche, c'est-à-dire, l'ensemble formé par le système de fixation de l'outil et le moteur permettant la rotation à l'origine de l'usinage.

Tout cela est très proche de ce qui est mis en place lors d'une opération manuelle. Maintenant voyons comment l'action de l'homme a été remplacée par la commande d'une machine :

Si on usine avec un outil en position verticale, 3 axes (X, Y et Z) suffisent pour le déplacer dans l'espace. Et pour se repérer dans cet espace orthonormé, on utilisera l'unité de mesure du système international ou l'unité du système anglo-saxon.

De nombreuses CNC ont pour base un châssis rigide sur lequel les différents organes de la machine reposent pour opérer. Essentiellement deux catégories de structures existent : la table mobile et le portique mobile . Dans le premier cas, le portique est fixé sur le châssis en son centre et c'est la table d'usinage qui se déplace sur un axe (X). Dans le deuxième cas, plus courant, c'est l'inverse : la table est fixée au châssis et le portique se déplace sur l'axe (X) pour parcourir la table d'usinage. Ce dispositif est moins coûteux en espace et se révèle plus versatile, c'est le cas de notre CNC.

Le portique est mobile sur toute la longueur du châssis.

Le portique quant à lui sert de base pour le déplacement sur l'axe Y du porte broche. Le porte broche enfin sert de base pour le déplacement sur l'axe Z de la broche.

L'ensemble des axes X, Y et Z permet de déplacer l'outil de coupe verticalement.

Dans certaines situations, il est pratique d'avoir un quatrième, cinquième ou énième axe pour orienter l'outil et/ou orienter le matériau ; ainsi des opérations peuvent s'appliquer sur des faces du matériau non accessibles sur une CNC 3 axes.

Mécanique ¶

La liberté de mouvement est donc gérée par ces axes mais il faut encore assurer le déplacement avec force et précision ; ceci est possible grâce à de nombreuses solutions mais je vais expliquer ici la plus populaire : les moteurs pas à pas, les vis à billes et les axes supportés.

Le moteur pas à pas est un moteur dont le fonctionnement est relativement fiable, puissant, précis mais pas très rapide. Lorsque les moyens le permettent, des servomoteurs pas à pas sont utilisés, permettant d'avoir une correction en cas d'erreur - le servomécanisme permettant l'asservissement et la rétroaction (on donne une commande et on vérifie qu'elle se réalise). Un ou parfois plusieurs moteurs pas à pas peuvent être utilisés pour mouvoir chaque axe.

Le moteur pas à pas de l'axe Z, couplé indirectement à la vis à billes

La vis à billes permet de convertir la rotation du moteur en translation (comme lorsqu'on visse une vis !). Les billes remplacent les pas de l'écrou, limitant ainsi les frottements et augmentant considérablement la précision. Le couplage entre le moteur et la vis à billes peut être :

direct, au moyen d'un coupleur d'axe spécifique qui protégera de la casse le moteur et la vis,
ou indirect, au moyen de poulies et de courroies qui permettront une démultiplication de l'effort tout en gardant une certaine souplesse de mouvement.

Pour finir, un axe supporté est un axe rond en acier trempé monté sur un support en aluminium permettant ainsi de fixer et soutenir l'axe sur toute sa longueur. Ces axes sont donc très utiles pour des axes longs qui pourraient fléchir s'il n'étaient pas supportés. La partie mobile glisse sur l'axe grâce à des paliers montés sur des douilles à billes . On conserve ainsi une grande stabilité lors du déplacement.

Un peu de mécanique ...

D'autres solutions existent :

les vis trapézoïdales (meilleures que le pas de vis classique) et les axes non supportés sont bon marché mais sont plus sensibles à l'usure et sont moins précis que la solution vis à billes et axes supportés.
les rails guidés à billes sont coûteux mais remplacent avantageusement les axes supportés et douilles à billes, offrant encore plus de précision et de stabilité.
les vis à rouleaux satellites offrent également un niveau supérieur de puissance, de durabilité et de précision par rapport aux vis à billes. On les trouve sur des machines dont les conditions de mise en œuvre sont soumises à de fortes contraintes ce qui explique leur coût élevé.

Les moteurs pas à pas et les contrôleurs ¶

Pour comprendre le pilotage d'une CNC, il faut d'abord connaître un peu le fonctionnement d'un moteur pas à pas :

Un moteur pas à pas est conçu pour effectuer un tour complet en un certain nombre de pas. Cette caractéristique est indiquée sur le moteur sous la forme 1,8°/step ou 200 steps/rotation . Le pas correspond donc à l'unité de mouvement du moteur. Cette rotation peut se faire dans le sens des aiguilles d'une montre ou inversement.

Le moteur pas à pas est généralement alimenté sur 4 fils, reliés deux à deux à des bobines. C'est en alimentant ces bobines et en tenant compte de la polarité d'alimentation, que le moteur tournera d'un pas dans un sens ou dans l'autre ; en alternant cette alimentation dans un ordre précis, on fait faire plusieurs pas au moteur. Sans rentrer dans le détail du fonctionnement, cela signifie qu'il faut être capable d'alimenter le moteur avec un courant de forte intensité en alternant très rapidement les bobines et les polarités, tout en conservant une qualité d'alimentation. Pour cela, on peut utiliser un contrôleur de moteur , sur lequel on branche directement le moteur pas à pas et une alimentation électrique. Ce contrôleur peut être paramétré pour limiter le courant fourni aux bobines afin de ne pas abîmer le moteur.

Alimentation du contrôleur de moteur pas à pas

Le contrôleur de moteur limite le courant fourni aux bobines par hachage ; il est par conséquent possible d'utiliser une alimentation fournissant une tension supérieure à ce que peut supporter le moteur. Le hacheur limite le courant en fonction du réglage disponible sur le contrôleur de moteur. Sachant que la vitesse de montée du courant à la valeur nominale décroit à l'approche de celle-ci, il est intéressant d'utiliser une alimentation capable de fournir plusieurs fois la tension dont on à besoin : le hachage du courant empêchera de toute manière qu'on dépasse les valeurs désirées et on profitera d'une vitesse de montée du courant bien meilleure ce qui permettra une réponse optimale des moteurs.

Le contrôleur de moteur pas à pas possède également une interface de commande composée de 3 fils prenant en charge une commande chacun, sous forme de niveau logique binaire (0 ou 5V) :

[ENABLE] moteur allumé ou éteint,
[DIRECTION] direction de rotation horaire ou anti-horaire,
[STEP] rotation de l'axe du moteur d'un pas.

Le moteur peut donc être :

éteint (ENABLE à 0V) : aucune autre commande n'est interprétée et l'axe du moteur est en rotation libre (on peut le positionner à la main),
ou allumé (ENABLE à 5V) : en l'absence de commande de rotation, le moteur maintient une position (on ne peut pas le bouger manuellement) ; lorsqu'une commande de rotation arrive (passage de 0 à 5V sur le fil [STEP]), le moteur effectue une unité de rotation dans le sens qui lui est commandé pas le fil de direction.

La vitesse de rotation du moteur dépend au final de la fréquence des commandes sur le fil [STEP]. La documentation du contrôleur est importante pour connaître la durée des impulsions et leur séquencement afin de bien optimiser le contrôle du moteur.

Un peu d'électronique ...

Calculer la précision de la CNC

En connaissant l'angle d'un pas du moteur pas à pas, ainsi que le pas de vis à billes et le rapport de couplage, on peut calculer la précision théorique de la CNC. Par exemple, pour l'axe X :

notre moteur pas à pas peut effectuer un angle minimum de 1.8°, soient 200 pas par tour,
la poulie crantée sur l'axe du moteur a 15 dents ,
la poulie crantée sur la vis à billes a 20 dents,
la vis à bille a un pas de 5mm (1 tour de vis déplace l'écrou de 5mm).

La précision théorique de l'axe X de la CNC est donc de :

(5 mm / 200 pas) * ( 15 / 20) = 0,025 * 0,75 = 0,01875 mm

La précision de cet axe est ici théorique puisqu'aucune mesure du jeu des différentes parties mécaniques n'a été faite. Bien qu'un soin important ait été apporté aux technologies utilisées, il existera toujours une marge d'erreur lors de l'usinage dans laquelle intervient également le type d'opération, sa vitesse d'exécution, la nature du matériau, l'usure de l'outil, etc. Une autre source éventuelle d'imprécision est à évaluer également, même si aujourd'hui les chances sont faibles d'avoir ce problème, c'est la capacité électronique et surtout informatique à traiter des informations avec une grande précision, tant pour le calcul que pour la commande.

Dans notre cas, il reste possible d'augmenter la précision sans trop de difficulté, soit en augmentant le rapport du couplage moteur/vis à billes, soit en remplaçant le moteur par un moteur plus précis (attention de conserver des caractéristiques suffisantes - couple moteur, vitesse), ou plus simplement, si les moteurs pas à pas le permettent, en adaptant l'électronique de contrôle pour permettre d'augmenter le nombre de pas par rotation.

La commande numérique ¶

On comprend que le moteur pas à pas répond à l'impératif de précision, mais le principe de commande est trop basique pour pouvoir être programmé directement par l'homme.

Dès lors, l'interface de commande de chaque contrôleur de moteur pas à pas sera reliée à un dispositif numérique afin de permettre un contrôle intelligible et programmable par l'homme.

Ce rôle sera tenu soit par l'ordinateur, soit par des systèmes dédiés à cette tâche. Une troisième solution intermédiaire consiste à utiliser un ordinateur pour les calculs et l'affichage, couplé à un contrôleur de CNC pour le pilotage. La principale contrainte est d'être capable de délivrer les commandes au contrôleur de moteur (enable/step/direction) de manière très rapide et synchrone. L'ordinateur seul ne présente pas une solution idéale ; seul le port parallèle permet de répondre en partie à ces impératifs mais l'architecture matérielle n'est pas optimisée pour ce type d'utilisation et un ralentissement de quelques microsecondes ne peut être toléré. Compléter ou remplacer l'ordinateur par du matériel dédié est un peu plus coûteux mais permet un contrôle plus adapté aux contraintes des CNCs.

Schéma théorique d'une CNC 3 axes avec 2 moteurs sur l'axe X

Ce système de commande envoie donc des informations de contrôle des moteurs, mais peut aussi gérer l'activation et le réglage de la vitesse du moteur de la broche, l'aspiration des copeaux, l'adjonction d'eau ou d'huile de coupe, la ventilation des fumées, le changement d'outil automatique, etc. Le système de commande nécessite cependant d'être informé de certains événements, par exemple, la prise d'origine des axes (calibration du repère orthonormé). Cette opération requiert l'utilisation de contacteurs de position sur chaque axe, informant de manière précise le bout de course des axes. Autre exemple, lorsqu'un outil est fixé à la broche, la hauteur de celui-ci doit être mesurée à l'aide d'un contacteur pour que la commande ajuste le parcours d'outil. Certains servomoteurs peuvent également envoyer un retour au système de commande.

Un des deux contacteurs de position de l'axe Y

Toutes ces possibilités peuvent être gérées par l'homme en utilisant un langage de programmation spécifique. Le langage le plus populaire aujourd'hui pour le contrôle des CNCs est le G-Code ; le dispositif numérique sera donc en mesure d'interpréter ce langage pour commander, entre autres, les contrôleurs de moteurs pas à pas. Ce langage met à disposition des instructions de déplacement de l'outil de coupe, de vitesse de coupe, de gestion de chemins, etc.

Le langage peut-être écrit directement par l'homme d'après les dessins techniques du projet, en effectuant un certain nombre de calculs - pas toujours évidents - pour prévoir le passage des outils. Mais cette tache de calcul du passage d'outils, ainsi que la création des dessins techniques sont aujourd'hui assistés par ordinateur.

Les outils informatiques qui interviennent dans le domaine des CNCs sont rangés dans les catégories suivantes :

CAO (= CAD en anglais) : Conception Assistée par Ordinateur. Permet de concevoir et d'élaborer les dessins techniques des pièces à réaliser. Les fichiers sont souvent des formats propriétaires contenant des informations de plans 2D ou de volumes 3D.
FAO (= CAM en anglais) : Fabrication Assistée par Ordinateur. Permet de calculer les chemins des opérations d'usinages sous forme de parcours-outils. Les fichiers sont également propriétaires mais les outils permettent pour la plupart d'exporter ces parcours-outils en G-Code.
Interpréteurs G-Code et contrôleurs de CNCs (G-Code parser and CNCs controller en anglais) : Permet d'interpréter le G-Code et de commander les contrôleurs de moteurs de la CNC.

La norme décrivant le G-Code est cependant rarement implémentée en sa totalité, ni toujours conformément, et ce pour plusieurs raisons :

d'une part, le langage a été standardisé en 1980 après 20 ans d'utilisation, et cette norme n'a pas évoluée depuis 1980 ; depuis, de nombreux fabricants de machines ont donc adapté le langage à leurs besoins.
d'autre part, l'automatisation des tâches de conception et de fabrication a rendu certaines instructions moins utiles, voir inutiles.

Voici la chaîne de logiciels que j'utilise ; ces logiciels ont été choisis spécifiquement dans le domaine du libre :

CAO ¶

FreeCAD gère de nombreux formats de fichiers en importation et en exportation. L'outil est assez facile à prendre en main : un certain nombre "d'ateliers" permettent de gérer la modélisation 3D à différentes étapes et en fonction des besoins. Un système de graphe permet de revenir sur les étapes de modélisation sans utiliser d'historique linéaire. L'approche globale est la modélisation paramétrable basée sur des contraintes. Beaucoup plus facile à prendre en main qu'à expliquer !

LibreCAD gère la modélisation 2D avec une approche traditionnelle, un peu comme si vous êtiez sur une table à dessin, avec rapporteur, équerre, papier millimétré, calques, etc.

FAO ¶

HeeksCAD + plugin HeeksCNC. Ce plugin permet le calcul de passages d'outils en partant de modèles 2D ou 3D. La prise en main est plutôt ergonomique et le novice s'y retrouve facilement après avoir regardé un ou deux tutoriaux vidéos. Les opérations d'usinage de poche, de profil, de perçage, d'ébauche en zigzag, etc sont disponibles mais il reste des bugs et il manque des opérations. Dommage que le développement semble en pause parce que le plugin est fort intéressant et il n'y a pas beaucoup de concurrent dans le monde libre sur ce créneau. Voir également PyCam.

Interpréteurs G-Code et contrôleurs de CNC ¶

LinuxCNC, anciennement EMC2 est incontournable et presque seul dans ce domaine. L'outil possède plusieurs interfaces graphiques bien pratiques. Il gère le port parallèle de votre ordinateur mais peut aussi gérer plusieurs types de cartes dédiées au contrôle de cnc. Il accepte le G-Code le plus couramment utilisé. Il est livré par défaut sur une distribution Ubuntu 10.04 LTS spécialement optimisée pour LinuxCNC.

Il existe de nombreux autres logiciels libres de CAO et des scripts et petits outils de FAO très pratiques (voir notamment le plugin de génération de G-Code pour Inkscape, F-Engrave, etc). Et dans la catégorie interpréteur G-Code/contrôleur de CNCs, l'arrivée de solutions embarquées ( Grbl sur Arduino et son portage SmoothieWare sur mbed, Smoothieboard et autres) sont à tester rapidement ! Elles permettront à terme de ne plus utiliser le port parallèle et d'obtenir de meilleures performances.

Port parallèle et CNC

Comme je l'indiquais plus haut, un ordinateur seul n'est pas vraiment conçu pour répondre aux contraintes de commande numérique. Lors du paramétrage de LinuxCNC, un programme permet d'effectuer un test de latence un peu empirique mais fonctionnel, dont le résultat permettra de régler le débit du port parallèle de votre ordinateur. Pour optimiser la réponse de l'ordinateur et gérer au mieux l'envoi des données sur le port parallèle, LinuxCNC utilise le noyau linux temps réel RTAI dont le développement semble ne pas évoluer rapidement. De ce fait, il est difficile de l'adapter à un environnement logiciel et du matériel récents. Il est d'ailleurs recommandé d'installer le CD de LinuxCNC 2.5.1 (Ubuntu 10.04 LTS compilée avec RTAI) sur un ordinateur simple cœur et dont la configuration mémoire ne dépasse pas 1Go. Ces recommandations vont devenir rapidement problématiques pour les utilisateurs, même si le logiciel n'est effectivement pas gourmand en puissance, il deviendra de plus en plus difficile de trouver ce type de matériel d'occasion. Le développement est cependant toujours très actif et tente justement de se séparer de noyau temps réel RTAI.

Et maintenant ? ¶

Cet article aborde les bases du fonctionnement d'une CNC 3 axes pour hobbyiste ; il reste ensuite à apprendre les techniques d'usinage ainsi que la conception et la fabrication assistés par ordinateur. Ne pas oublier que c'est un métier avant tout, ce qui n'empèche pas, avec du sérieux et des précautions, d'attaquer le sujet sous divers angles. Sur internet on trouve assez facilement des informations et de l'aide :

Plusieurs communautés existent, comme par exemple usinages.com ou pour les anglophones : cnczone.com .

Les sites des fabricants d'outils et des logiciels de CAO/FAO (principalement dans la communauté du libre) ont souvent des ressources très bien faites et complètes. Consultez la documentation de LinuxCNC , qui va bien au delà de l'utilisation du logiciel et donne de nombreuses références, explications et exemples.

Enfin, le détournement d'un tel outil est bien sûr possible, jetez un oeil sur hackaday.com par exemple !

Réagissez sur cet article .

Piloter des dispositifs sans fil

2013-02-01T00:00:00Z

Électronique | Informatique Niveau: Avancé Jonathan Schemoul

Montage avec la Leonardo

Partie 1: Réception en 433 MHz

Vous avez sans doute entendu parler ou vu des détecteurs de fumée, d'ouverture de porte, des télécommandes, des prises murales, etc. sans fil ?

Que ce soit les modèles chers que vous trouvez en magasin ou les modèles chinois bon marché, la plupart, s'ils ne sont pas avancés, utilisent la bande de fréquence 433 MHz (n'essayez pas ceux en 315, ils sont illégaux en France). Certains autres sont en 2.4 ghz, mais nous les laisserons de coté pour l'instant.

En ce qui concerne ces capteurs en 433 MHz, il se trouve qu'ils utilisent pour la plupart un protocole très simple, introduit par des circuits intégrés chinois à bas coût, les PT2262 côté émission et les PT2272 côté réception (d'autres plus exotiques comme les SC5262 / SC5272, HX2262 / HX2272, EV1527, RT1527, FP1527 ou encore HS1527 peuvent être trouvés et fonctionneront aussi).

Plutôt que de nous lancer dans l'acquisition de ces chips, on va utiliser notre microcontrôleur, plus que capable de le faire, pour décoder et encoder les signaux, grâce à la librairie RC-Switch pour Arduino , ou RCSwitch-pi pour la Raspberry Pi .

Regardons de plus près ce que nous avons à disposition :

Un Arduino (ici un Leonardo , mais un Uno ou un clone quelconque fera l'affaire) - Une breadboard
Un 433 MHz RF link kit (un émetteur, un récepteur) - Des fils à breadboard

Montage détaillé

Niveau détecteurs :

Un détecteur d'ouverture de porte
Un détecteur PIR


Détecteur PIR	Détecteur d'ouverture de porte

Regardons ce détecteur d'ouverture de porte de plus près :

Gros plan sur le détecteur d'ouverture de porte

On voit bien le PT2262 pour l'encodage et à gauche des jumper pour choisir le code (ainsi chaque émetteur aura un code différent). Pas besoin de déduire le code de ces jumpers, on va faire un petit programme Arduino qui nous les dira au fur et à mesure de leur activation.

Installation de la librairie RC Switch ¶

Télécharger RCswitch_2.3.zip et extraire le contenu dans le sous-repertoire "libraries" (s'il n'existe pas, créez le) de votre répertoire "sketchbook", pour que cela donne :

sous Mac, /Users/VOTRE_UTILISATEUR/Documents/Arduino/libraries/RCswitch
sous Linux, /home/VOTRE_UTILISATEUR/sketchbook/libraries/RCswitch
sous Windows, C:UsersVOTRE_UTILISATEURDocumentsArduinolibrariesRCswitch

Connexion du récepteur ¶

Le récepteur est simple, il suffit de le connecter au courant (+5v et GND) et à un pin de l'Arduino ayant une interruption.

Récepteur

Voici un petit tableau des interruptions :

Carte	int.0	int.1	int.2	int.3	int.4	int.5
Uno, Ethernet	2	3
Mega2560	2	3	21	20	19	18
Leonardo	3	2	0	1

Sur notre Leonardo, si nous voulons connecter notre récepteur sur l'interrupt 0, il nous faut le connecter sur le pin 3 :

Montage

Reçevoir des codes ¶

Pour cela, nous allons lancer l'IDE Arduino et charger l'exemple de RCSwitch, "ReceiveDemo_Simple".

Pour le Leonardo, il faut ajouter "while (!Serial) ;" avant d'écrire sur le port série (lié à l'utilisation de l'USB après le lancement) :

Le code dans Arduino IDE

Envoyons le croquis sur la carte, et lancons le moniteur série (Outils > Moniteur Série, après avoir vérifié que le port était le bon dans Outils > Port série).

Actionnez votre senseur (ici le détecteur d'ouverture de porte, en écartant les deux parties) :

Montage

Et magie, des codes s'affichent dans le moniteur série :

Retours dans le port série

Ce code, 13464924 dans cette capture d'écran, est l'id unique de votre senseur, 24bit est la taille de celui-ci et 1 le protocole utilisé (ici celui du PT2262).

Si l'on active un autre senseur (le capteur de mouvement ici, il s'allume en rouge lorsqu'il détecte un mouvement) :


Détection de mouvement	Deux codes

On voit que l'on reçoit un nouveau code : 12449942 .

Note : si vous ne voyez rien dans la console avec un Leonardo, c'est quelque chose qui arrive souvent, n'hésitez pas à ouvrir un autre moniteur série que celui livré avec l'IDE Arduino. Par exemple, putty fait très bien l'affaire même sous Linux. La commande "putty -serial /dev/ttyACM2 -sercfg 9600" permet d'ouvrir ttyACM2 en 9600 baud. (remplacer /dev/ttyACMx par COMx sous windows :))

Interprétation ¶

De là à garder ces codes et à donner une information humainement compréhensible, il n'y a qu'un pas.

Essayons d'envoyer une information utile sur le port série

#include <RCSwitch.h>
#define couloir 12449942
#define porte 13464924

RCSwitch mySwitch = RCSwitch();

void setup() {
    Serial.begin(9600);
    mySwitch.enableReceive(0);
}

void loop() {
  if (mySwitch.available()) {

    int value = mySwitch.getReceivedValue();

    while (!Serial) ;

    switch (value) {
        case porte:
            Serial.println("Quelqu'un a ouvert la porte
!");
            break;

        case couloir:
            Serial.println("Quelqu'un marche dans le couloir !");
            break;

        default:
            Serial.print("Dispositif inconnu: ");
            Serial.println(value);
            break;
    }

    mySwitch.resetAvailable();
  }
}

D'abord dans setup() on initialise mySwitch sur l'interrupt 0, ensuite, dans le loop() lorsque l'on reçoit un message, on agit selon ce qui est reçu. On envoie un message simple "Quelqu'un a ouvert la porte !" ou "Quelqu'un marche dans le couloir !" selon le cas.

Voici ce que l'on reçoit sur le port série :

Capture du port série

Comme vous pouvez le voir, on a l'information, mais elle se répète. C'est dû à la nature du protocole, qui ne permet pas de vérifier la réception de l'information. Du coup, elle est envoyée plusieurs fois pour être sûr de sa réception.

Pour régler ce problème, il suffit d'ajouter un timer sur la réception, pour ne l'avoir qu'une seule fois :

#include <RCSwitch.h>
#define couloir 12449942
#define porte 13464924

RCSwitch mySwitch = RCSwitch();

// On limite à un évènement par seconde long
#define debounceDelay 1000

// On a deux détecteurs, donc on a deux timers.
last_times[2] = {0,0};

void setup() {
    Serial.begin(9600);
    mySwitch.enableReceive(0);
}

bool debounce(int number) {
    if ((last_times[number] == 0) ||
        ((millis() - last_times[number]) > debounceDelay)) {
        last_times[number] = millis();
        return true;
    }
    return false;
}

void loop() {
  if (mySwitch.available()) {

    int value = mySwitch.getReceivedValue();

    // on remet à zero le timer
    while (!Serial) ;

    switch (value) {
        case porte:
            if (debounce(0))
                Serial.println("Quelqu'un a ouvert la porte !");
            break;
        case couloir:
            if (debounce(1))
                Serial.println("Quelqu'un marche dans le couloir !");
            break;
        default:
            Serial.print("Dispositif inconnu: ");
            Serial.println(value);
            break;
    }

    mySwitch.resetAvailable();
  }
}

Notre fonction debounce permet, pour un détecteur donné (de 0 à 1 ici), de dire si c'est un nouvel événement ou pas. Voici ce que cela donne si j'ouvre la porte, marche jusqu'à une autre porte puis ouvre cette autre porte inconnue :

Capture du port série

Comme vous pouvez le voir, nous n'avons pas de timer sur l'émetteur inconnu mais on en a un sur ceux qui sont connus.

La suite ? ¶

Dans la deuxième partie nous verrons comment envoyer des signaux à une prise en 433 MHz, et envoyer et recevoir des signaux entre Arduino selon le même principe.

Réagissez sur cet article .

Rencontre au LabFab de Rennes

2013-02-01T00:00:00Z

Électronique | Informatique | Art Niveau: Vulgarisation Florian Strzelecki

Hugues Aubin en train de montrer une carte Arduino à un atelier du LabFab

Depuis que je fréquente Hugues Aubin aka @Hugobiwan sur Twitter, je suis chaque fois surpris non seulement par ses projets et par les nouvelles qu'il apporte, mais aussi (et surtout) par la ferveur et l'énergie qui l'animent.

Rencontre avec le porteur du projet "LabFab", un FabLab à Rennes, qui a ouvert ses portes l'année dernière, et qui va bientôt employer à temps plein une personne pour accueillir le public.

Petite introduction ¶

Lorsque je lui demande de se présenter en quelques mots, il me tend sa carte : Hugues Aubin, "Chargé de Mission TIC", sous les logos de Rennes Métropole et de la Mairie de Rennes. Sa situation est assez exceptionnelle pour être notée, car elle lui permet de faire le pont entre des activités de la ville, et les activités de toute l'agglomération.

Son lien avec le LabFab ? Il l'a mis en place, en contactant les bonnes personnes, et en réunissant des acteurs locaux qui se posaient déjà les mêmes questions sur les FabLab, les Hackerspaces, et tous ces lieux qui proposent des espaces de fabrication au plus proche des gens.

Parce que le LabFab ne s'est pas fait tout seul ! D'abord, il y a l'Ecole européenne supérieure d'Art de Bretagne , qui prête des locaux pour le LabFab. Et tout comme Telecom Bretagne , l'intérêt pour eux est ce qu'un FabLab apporte aux étudiants.

Il y a la ville de Rennes, ainsi que Rennes Métropole , qui s'intéressent tous deux à ce qu'un FabLab peut apporter à ses habitants. Et n'oublions pas non plus la région Bretagne , qui participe pour des raisons similaires.

Enfin il y a les associations BUG et la Cantine Numérique Rennaise (CNR), centrés sur les communautés et les nouvelles technologies, ce que représente parfaitement le LabFab.

L'expérience du LabFab à Rennes ¶

La question qui revient souvent, me dit-il, c'est comment apprivoiser ces espaces ? Comment les inclure dans la société et dans ses projets ? Parce que même s'il ne fait pas de doute que ces lieux ouverts sont très intéressants, il reste à savoir comment les mettre en place.

À l'origine, le but de l'expérience est d'essayer quelque chose, et d'essayer vite, en investissant peu de moyens d'une part, mais surtout sans attendre quelque chose en retour : ni objectif, ni réussite, ni résultat particulier. Le but est justement de savoir comment ça va se passer, comment l'espace est pris en main, et qui s'y intéresse.

Alors avec juste quelques hommes, des locaux et un peu de matériel, le LabFab est mis en place, avec différents axes de recherche.

Tout d'abord, que le lieu soit utile aux gens qui viennent. Qu'il serve à l'éducation populaire pour accéder au numérique, et aux objets qui touchent à ces technologies. Hugues insiste d'ailleurs sur l'approche de consommation actuelle de la technologie, qui amène selon lui peu d'innovation, et qui bloque l'émergence de nouveaux usages, notamment démocratiques.

Aujourd'hui, Internet sort des PCs, mais il reste l'apanage des spécialistes et de ceux qui savent.

L'école des Beaux Arts formant des étudiants au design, elle cherche à obtenir plus d'intégration dans la fabrique de nouveaux usages, avec les technologies de l'information (réseau, électronique, communication inter-objets, etc.), dans les savoirs dispensés.

Ils veulent générer une dynamique entre les étudiants et l'usage du LabFab.

On retrouve aussi cette notion de mixité que ce soit pour la ville ou Télécom Bretagne : comment faire venir autant des professionnels que Monsieur et Madame tout le monde ? Comment intéresser à la fois des ingénieurs, des chercheurs et des spécialistes ? Des jeunes, vieux, amateurs, néophytes et tous les curieux ?

Il y a une réelle volonté d'attirer tout le monde en même temps.

Les axes de recherche ne manquent décidément pas, et Hugues est intarissable sur le sujet. Il me raconte pêle-mêle que ce projet apporte un tas de questions, que les gens se posent un tas de question : quel va être le regard des experts auprès des amateurs ? Quelles questions est-ce que cela pose, de fabriquer des choses sans brevet, sans règles sur la "propriété intellectuelle" ?

Sans compter que si le LabFab s'inscrit dans un environnement local, il y a une volonté d'essaimer, de faire qu'un écosystème international se développe.

En 2012 à Montréal lors du MakerFair, ce qui se voyait le plus c'était "tout le monde monte son FabLab" !

Le public et le réseau des FabLab ¶

Parce que le LabFab de Rennes, ce n'est qu'un tout petit élément finalement. Depuis début 2012, c'est un véritable réseau de lieux qui est en train de se développer : Hugues me parle du Vietnam, de Québec, de Dakar, ou encore du Burkina Faso, bref, tout un ensemble de pays avec des communautés francophones.

Le problème rencontré aujourd'hui en Afrique, c'est qu'ils apprennent éventuellement leur langue maternelle et le français, mais rarement l'anglais. Alors que les documentations techniques, elles, sont toutes en anglais.

La traduction des documents et le partage de ces traductions, est devenu l'un des objectifs du LabFab.

Parce que le public aujourd'hui est vraiment très hétérogène : j'ai pu moi-même m'en rendre compte avec une petite séance photo lors d'un atelier sur Arduino.

Nous avons des artistes, des vieux bricoleurs, etc. L'année dernière avec la CNR, c'est 26 ateliers que nous avons fait. Et ils ont tous été complets en moins de 48h ! Ça représente plus de 450 débutants qui ont été formés !

Un public hétérogène pour cet atelier du LabFab sur Arduino connecté.

Le succès est au rendez-vous, parce qu'outre les ateliers fréquents, il y a les différents salons auxquels est invité Hugues pour parler du FabLab Rennais :

Entre Laval Virtual et le forum des usages à Brest, Vivacité, nous avons aussi reçu des invitations pour aller à l'étranger. Ce n'était pas prévu du tout à l'origine.

Plusieurs "Starter Kit" sont disponibles pour former les gens sur Arduino.

Hugues ayant un emploi du temps de ministre, l'entretien touche bientôt à sa fin, et il y a encore une question ou deux que je me pose. La première, c'est "comment peut-on utiliser le LabFab ?".

Il n'y a pas de règles très précises. Les gens doivent venir avec un projet, c'est à dire une phrase qui présente le projet et éventuellement un dessin de ce que c'est censé faire, et c'est tout. On ne juge pas des projets, chacun peut faire ce qu'il a envie, et chacun a accès au matériel du LabFab (kit Arduino pour du prototypage, une MakerBot, etc.). On demande seulement à ce que le porteur du projet partage quelque chose en échange.

Intrigué, je lui demande pourquoi cette règle : pourquoi ne pas simplement imposer une licence ou proposer des licences libres - puisque c'est le but.

Les gens qui viennent n'ont pas forcément la culture du logiciel libre ou de Creative Commons. Parfois ils ne savent même pas que ça existe. Alors on leur demande de partager quelque chose : leur produit, une compétence, un savoir ou une petite partie de leur projet. Certains arrivent et savent tout de suite quelle licence utiliser, mais la majorité découvre le concept en venant ici.

Ça laisse songeur…

Le futur du LabFab ¶

Le succès étant au rendez-vous, Hugues est serein pour l'avenir. Il a présenté un rapport d'activité à Rennes Métropole le 21 Décembre dernier, un bilan d'une quarantaine de pages qu'il m'invite à télécharger sur le site du LabFab une fois publié.

Il est plein d'espoir pour 2013, surtout qu'il a obtenu la création d'un poste à temps plein pour l'année. Et puis il y a tellement de projets, et tellement d'expériences à tenter.

Le lendemain de notre entretien, je suis passé à un atelier sur "Arduino connecté", où j'en ai profité pour faire quelques photos. Il y avait quelque chose de magique à voir autour de cette table toutes ces personnes : plusieurs étudiants, un vieux pépé qui a fait de l'électronique, un couple qui vient en apprendre plus, et tous avec des connaissances et compétences très variées.

Si seulement j'avais un peu plus de temps… En tout cas, je vous invite à franchir les portes de ce FabLab, il y a plein de bonnes choses.

Réagissez sur cet article .

Un Juke Box avec le Raspberry-Pi

2013-02-01T00:00:00Z

Electronique | Informatique Niveau: Découverte Tarek Ziadé

Le Raspberry-PI Jukebox

Après trois mois d'attente interminable, j'ai finalement reçu mon Raspberry Pi (R-Pi), accompagné d'un joli T-shirt Element 14 .

J'ai plusieurs projets en tête avec un peu d'électronique, mais pour me familiariser avec la bête, j'ai décidé de commencer par un projet simple qui marcherait avec un R-PI nu.

Le projet est un Juke-Box sans fil que je peux trimballer chez moi, qui se connecte à mon réseau local en wifi - et qui fournit une application web où tout le monde peut se connecter pour ajouter des morceaux de musique dans une file d'attente.

Le projet final est une petite boite qui contient le R-PI et :

une clé USB pour stocker de la musique. J'ai choisi la PNY 16G qui est vraiment toute petite.
un dongle USB wifi. J'ai choisi l' Airlink Nano pour les mêmes raisons : il dépasse à peine du port USB.
Une batterie USB pour ne pas avoir à brancher le R-PI sur le courant ou sur mon ordinateur. J'ai choisi celui-ci qui s'avère être beaucoup plus volumineux que le R-PI, mais qui fournit jusqu'à 1 ampère de courant - ce qui couvre les besoins et devrait permettre d'éviter à avoir recours à un Hub USB alimenté.
Un mini-speaker. J'ai commandé le X-Mini II qui est tout simplement incroyable. Ce petit speaker sort un très bon son vu sa taille, est auto-alimenté et on peut en brancher plusieurs à la suite. J'en ai acheté un deuxième pour mon fils et je le recommande chaudement. Dans tous les cas, le Juke-Box peut toujours être branché sur de vraies enceintes.

Petit détail agréable : Le speaker et la batterie USB ont été tous les deux livrés pré-chargés.

La carte SD ¶

Carte SD 4 Gigas

A réception du R-PI, j'ai branché une carte SD qui traînait chez moi et elle ne marchait pas du tout. J'ai contrôlé que la carte était bien alimentée avec un multimètre et j'ai testé trois autres cartes SD glanées dans les appareils photos de la famille en me disant que quelque chose clochait à ce niveau là.

Avec la dernière carte que j'ai testé, le R-PI bootait mais freezait au bout d'un moment avec une -101 error .

Il s'avère que le R-PI est très sensible au type de carte SD qu'il reçoit. Rien à voir avec la marque ou le prix de la carte, ou sa classe. Certaines marchent, certaines de marchent pas...

Le plus simple est de prendre une carte qui est listée ici : http://elinux.org/RPi_VerifiedPeripherals#SD_cards

Je suis allé au supermarché du coin et j'ai pris une SanDisk SDHC 4G class 4 à 7 euros - et tout a fonctionné.

Préparer la carte SD pour le R-PI sous Mac OS X est très simple. Il y a même un script Python : RasPiWrite qui automatise la tâche.

J'ai eu quelques bugs avec ce script pour ma part, j'ai donc utilisé quelques commandes shell.

J'ai d'abord téléchargé l'image Raspbian officielle. C'est une Debian optimisée pour le R-PI :

cd /tmp
wget http://files.velocix.com/c1410/images/raspbian/2012-12-16-wheezy-raspbian/2012-12-16-wheezy-raspbian.zip
unzip 2012-12-16-wheezy-raspbian.zip

Vous pouvez regarder sur http://www.raspberrypi.org/downloads s'il y en a une plus récente.

Une fois que l'image est téléchargée et dézippée, il convient de la transférer sur la carte SD avec la commande dd .

Sous Mac OS X , la commande diskutil list m'a permis de trouver le disque correspondant à la carte : /dev/disk3

Puis le transfert s'opère en démontant la carte et en utilisant dd :

$ diskutil umountDisk /dev/disk3
Unmount of all volumes on disk3 was successful

$ sudo dd bs=1m if=/tmp/2012-10-28-wheezy-raspbian.img of=/dev/rdisk3
[... 5-10 minutes ...]
1850+0 records in
1850+0 records out
1939865600 bytes transferred in 388.257496 secs (4996338 bytes/sec)

$ diskutil eject /dev/disk3
Disk /dev/disk3 ejected

Notez que la commande dd prend beaucoup de temps à s'exécuter. La copie peut durer de 5 à 10 minutes.

La notation rdisk3 est spécifique à Mac OS X. Elle permet d'accélerer la procédure. Sous Linux, il faut enlever le "r" .

Une fois que la carte est prête, il suffit de la plugguer dans le R-PI et de le démarrer avec un écran et un clavier branchés.

Configuration de base et wifi ¶

Vous devriez voir défiler la séquence de boot puis obtenir un écran de configuration.

étendez la partition sur toute la carte SD grâce à expand_rootds ,
overclockez votre R-PI dans le menu overclock : J'ai mis le mien en medium
activez le serveur SSH dans ssh
désactivez le desktop dans boot_behavior

Je n'ai pas reconfiguré le clavier car j'utilise un QWERTY.

Une fois la configuration effectuée, branchez le dongle Wifi et relancez le R-PI via Finish , Raspbian va appliquer au redémarrage la configuration, et un prompt de login doit apparaître.

Pour se logguer le user est pi et le mot de passe raspberry .

Une fois loggué, éditez le fichier /etc/network/interfaces pour que le dongle s'autoconnecte au réseau. J'ai branché le dongle sur le port USB du bas, ce qui correspond selon iwconfig à l'interface wlan0 .

Voici ma configuration pour wlan0 :

auto wlan0

iface wlan0 inet dhcp
    wpa-ssid Villa_Des_Mouches
    wpa-psk motdepasse

Villa_Des_Mouches est le ESSID de mon réseau wifi. Une fois le fichier modifié, relancer le réseau :

$ sudo /etc/init.d/networking restart

Votre R-PI va obtenir une adresse IP sur le réseau sur laquelle on pourra se connecter en SSH pour la suite.

Éteignez le R-PI avec sudo halt , puis débranchez l'écran et le clavier. Branchez la clef USB à la place du clavier et relancer le R-PI.

Au bout d'un moment il devrait réapparaitre dans le réseau et être accessible en SSH. Le seul défaut de cette technique est que l'adresse IP peut changer. Une adresse IP statique peut être préférée mais dans mon cas ce n'est pas très grave car je retrouve facilement le R-PI en scannant le réseau avec nmap 192.168.1.* .

$ ssh pi@192.168.1.96
Linux raspberrypi 3.2.27+ #250 PREEMPT Thu Oct 18 19:03:02 BST 2012 armv6l
...

Last login: Sun Oct 28 23:10:12 2012
pi@raspberrypi ~ $

Pour la suite, il est plus simple de tout faire en SSH car à moins d'avoir un écran adapté, la résolution du mode console du R-PI sur un écran moderne va vous brûler les yeux en 5 minutes.

Testez que le son fonctionne en branchant une enceinte amplifiée sur le R-PI et en téléchargeant un WAV et en le jouant avec aplay :

$ wget http://www.freespecialeffects.co.uk/soundfx/sirens/police_s.wav
$ aplay police_s.wav
Playing WAVE 'police_s.wav' : Unsigned 8 bit, Rate 22000 Hz, Mono
^CAborted by signal Interrupt...

Vous devriez entendre une sirène.

Installez maintenant mpg123 pour jouer des MP3 présents sur la clef USB. Il a fallu monter le disque manuellement par contre :

$ sudo mkdir /media/usbstick
$ sudo mount -t vfat  -o uid=pi,gid=pi /dev/sda1 /media/usbstick

$ mpg123 "/media/usbstick/01 Hidden Orchestra - Flight Mixtape.mp3"
High Performance MPEG 1.0/2.0/2.5 Audio Player for Layers 1, 2 and 3
    version 1.14.4; written and copyright by Michael Hipp and others
    free software (LGPL/GPL) without any warranty but with best wishes

Directory: /media/usbstick/
Playing MPEG stream 1 of 1: 01 Hidden Orchestra - Flight Mixtape.mp3 ...

MPEG 1.0 layer III, 320 kbit/s, 44100 Hz joint-stereo
Title:   Hidden Orchestra - Flight Mixtape
Artist:  Hidden Orchestra (Joe Acheson)
Comment: Exclusive mix for http://www.parisdjs.com
Album:   Paris DJs Podcast
Year:    2012                            Genre:  Podcast

Victoire ! Et un super mix de ParisDjs avec un son propre.

mpg123 utilise environ 6% de CPU, ce qui est plus qu'acceptable.

Application JukeBox ¶

Pour la partie JukeBox, je comptais écrire une petite application web au dessus de mpg123 et je le ferais peut-être un jour, mais il en existe déjà plusieurs.

Jukebox est écrite en Python avec Django et fournit les fonctionnalités de base d'un JukeBox, à savoir un affichage des morceaux présents et un moyen pour les utilisateurs du réseau d'ajouter des morceaux dans la playlist.

L'application Django Jukebox

Pour installer JukeBox, il faut un environnement Python/Virtualenv mais aussi la librairie libshout3 qui est utilisée par l'application :

$ sudo apt-get install python-virtualenv libshout3 libshout3-dev pkg-config python-dev

Une fois les paquets systèmes installés, il faut créer un virtualenv et y installer ez_setup puis JukeBox :

$ virtualenv --no-site-packages jukebox
$ cd jukebox
$ bin/easy_install -U distribute
$ bin/pip install ez_setup
$ bin/pip install jukebox

Pour la configuration de Jukebox, tout est expliqué ici : https://github.com/lociii/jukebox#readme

Le gros défaut de cette application est qu'elle force les utilisateurs à utiliser un compte social comme Twitter - et je n'ai pas eu le temps de plugger un système d'authentification plus simple.

Quoi qu'il en soit je suis ravi du résultat - ce petit juke box peut se brancher sur de bonnes enceintes et rivaliser avec les systèmes sans fils hors de prix du marché, comme les Sonos .

Réagissez sur cet article .

Tribune - Semences stériles et données futiles

2013-02-01T00:00:00Z

Autre | Écologie Niveau: Vulgarisation David Larlet

Champ de blé

La problématique des semences génétiquement modifiées pose des questions d'ordre éthique, sanitaire et social. Les semences stériles — utilisant le gène au doux nom de Terminator — sont emblématiques de la société Monsanto qui est prête à diffuser à tout prix ses semences, même gratuitement à titre humanitaire pour avoir un contrôle de la production mondiale de nourriture.

Les schémas de pensées court-termistes — apportant un confort immédiat — ont tendance à se reproduire d'un domaine à un autre et c'est notamment ce qui est en train de se passer avec le Web.

Après une étape de standardisation prometteuse qui permettait une interopérabilité entre les différentes publications (RSS, Atom, trackbacks), la mode est plutôt à la centralisation des données (Twitter) voire à leur déconnexion du Web (Facebook) au profit d'un confort de publication bien réel avec la promesse de l'instantanéité et de l'approche ubiquitaire.

Le tout associé à une flatterie de l'égo par une quantification du partage (nombre de retweets/likes/followers/etc) qui se rapproche, osons le dire, d'une compétition malsaine capitaliste du toujours plus, d'une approche en consommateur des liens sociaux, d'une course effrénée à la socialisation numérique qui détruit les communautés locales au profit d'une communauté de suiveurs inconnus.

Or, au même titre que les associations pour le maintien d'une agriculture paysanne (AMAP) , il existe une voie pour un web ouvert qui encourage l'artisanat et la réutilisation via un modèle acentré et local. Certaines initiatives comme La Distribution ou CozyCloud encouragent de telles approches permettant de garder un contrôle sur ses données et même un hébergement sur son propre serveur afin d'assurer la pérennité de ses URI. L'avènement d' outils de publication générant des fichiers statiques facilite grandement le déploiement et l'hébergement de ses idées et minimise les connaissances techniques nécessaires à son expression sur le web. Les problèmes techniques restants à résoudre sont la notification de manière distribuée et l'agrégation en temps-réel mais ceux-ci ne pourront être validés qu'après une adoption à large échelle de tels services, permettant d'atteindre la masse sociale critique pour rendre ces services utiles.

Étudions la liste des composants nécessaires pour garder son indépendance vis-à-vis de services web centralisés :

un nom de domaine , ce qui coûte entre 5 et 15 € selon le niveau de support et de confiance que l'on souhaite avoir à ce niveau, en bonus non négligeable vous pouvez associer à ce domaine un certificat SSL qui assurera la confidentialité des échanges entre vos visiteurs et vos publications. Même si vos écrits ne sont pas critiques, pensez au fait qu'une banalisation de tels usages permet de rendre une telle pratique moins suspecte lorsqu'elle est nécessaire (nous ne vivons pas tous en démocratie) ;
un hébergement , il en existe à tous les prix et si vous vous dirigez vers un site au rendu statique grâce à des générateurs locaux vous n'êtes soumis à aucune contrainte technique si ce n'est celle de l'espace disque et de la bande passante qui ne devraient pas poser problème dans un premier temps au moins ;
un logiciel de téléversement , permettant de déployer le contenu généré sur le serveur d'hébergement. Il en existe de nombreux qui ne demandent aucune connaissance technique particulière.

Et voilà ! Il ne reste plus qu'à faire connaître votre URI au reste du monde. N'oubliez pas de produire un flux permettant à vos visiteurs de s'abonner à vos publications (cela est normalement géré par le générateur) sans avoir à dépendre d'une plateforme non pérenne et centralisée.

Barbelés

Vos publications, même à titre futile, constituent une partie de votre identité numérique, vos interactions sur le web participent à votre propre définition et à vos relations sociales. Il serait dommage de laisser des services tiers monétiser votre identité et vos interactions avec vos amis, d'autant plus qu'ils ne garantissent aucun engagement dans la durée et conduisent à de véritables génocides de données — que j'appelle datacides — lors de la fermeture brutale des entreprises qui ont du mal à trouver un business modèle rentable associé à la gratuité du service proposé.

Si vous êtes un jardinier numérique, je vous encourage à reprendre le contrôle de vos semences^W^données afin de pérenniser votre récolte^W^identité numérique. Il n'est pas trop tard pour nourrir d'idées ouvertes et gratuites vos concitoyens du web.

Réagissez sur cet article .

The Midst ?

2013-02-01T00:00:00Z

Art | informatique Niveau: Vulgarisation Bérenger Recoules

Un arbre récursif

The Midst est un projet de art-game se jouant en ligne : comme cela arrive souvent aux personnages principaux de jeux vidéo, la petite-amie de Héro s'est fait enlever ; cette fois ci ce sont de méchants pixels blancs qui ont fait le coup (the white meanies) ; en conséquence Héro est condamné à errer dans un labyrinthe de fenêtres pop-up en noir et blanc truffé d'obstacles, dans le but de dénicher une sortie et d'alors pouvoir peut-être retrouver sa dulcinée.

Ce jeu se décline aussi en un atelier et une série de ressources en ligne permettant de découvrir les technologies à l’œuvre : beaucoup de processing.js pour la création graphique et l'animation, une généreuse portion de Webpd pour la synthèse sonore en temps réel, un soupçon de HTML5 et une pincée de jQuery pour faire en sorte que tout cela fonctionne dans une page web. C'est du coup l'occasion de comprendre comment implémenter une succession de petits jeux simples allant du pong au casse-brique ...

Le code complet du jeu est disponible et consultable en ligne à cette adresse : https://github.com/b2renger/TheMidst

Au programme et en vrac : système à particules, physique et vecteurs pour l'animation, interaction, tweening , collisions non orthogonales, synthèse sonore, musique générative...

Du point de vue des technologies on utilise des outils libres et gratuits et qui disposent d'une large communauté d'acteurs internationaux. Cet article va se concentrer sur webpd qui n'est pas encore complètement documenté alors que processing.js , lui, dispose déjà d'une communauté vibrante et d'une multitude d'exemples de code en ligne.

Pour rappel, Processing est un langage de programmation apparu en 2001 au MIT, qui a pour vocation de faciliter l'apprentissage de la programmation objet en l'appliquant au dessin, à l'animation, à l'interaction et à la visualisation de données. Aujourd'hui il y a une très large communauté internationale et le langage permet aussi bien de développer pour des ordinateurs, que pour des téléphones Android ou encore des navigateurs web.

Pure Data est un langage de programmation visuelle né en 1996, il est la résultante d'une partie des travaux de Miller Puckette à l'IRCAM : c'est le petit frère libre et gratuit de MAX/MSP. Il permet de créer du code en reliant des boîtes entre elles à l'aide de fils : c'est un langage de programmation très utilisé pour la création sonore, mais aussi graphique ainsi que pour l'interaction.

La Structure du jeu et du code ¶

Le code du jeu est structuré de manière assez simple. Pour chaque fenêtre nous avons recours à un canvas html qui va exécuter un sketch processing ainsi qu'un patch Pure Data. Deux pages html sont présentes, index.html et level-template.html qui font appel a différents scripts JavaScript permettant d'aller chercher les fichiers level*.pde (pour l'animation) et level*.pd (pour le son).

Écran d'accueil

Lorsqu'on clique sur le bouton "start" une fenêtre pop-up va s'ouvrir : c'est le premier niveau incarné par la fenêtre "level-template.html" : à partir de ce moment là toutes les ressources seront chargées dans cette même fenêtre de 200x200 pixels. On se déplace ainsi de niveau en niveau en cherchant où sont les murs et où sont les passages vers les cases adjacentes.

La case de début du jeu.

La base de code produite au niveau un permet d'avoir une ellipse (notre personnage principal), qui est animée de deux façons : la première consiste à modifier la largeur et la hauteur de cette ellipse en fonction de son éloignement de la souris et la seconde animation consiste à permettre à ce personnage de se déplacer dans l'espace de chaque case à l'aide de l'application de lois physiques.

Le personnage à une masse, une position, une vélocité ainsi qu'une accélération. Une force de friction a aussi été implémentée. Lorsque l'on clique quelque part, le personnage va alors subir une modification de son accélération qui va donc se répercuter sur sa vitesse puis sur sa position. La relation est tout simplement une addition de vecteurs : pour obtenir le nouveau vecteur de vélocité on lui ajoute le vecteur accélération; pour obtenir le nouveau vecteur de position on y ajoute le vecteur de vélocité etc.

A partir de là tout est permis. L'avantage d'utiliser Processing dans ce contexte se situe dans le fait que l'on peut avoir accès à des notions de programmation objets, il est donc possible de structurer sont code à l'aide de classes et du coup de gagner une certaine flexibilité. De plus procession offre tout un tas de primitives de dessin dont la syntaxe est grandement simplifiée.

Le moteur audio : webpd ¶

Webpd est une librairie JavaScript qui permet de faire de la synthèse audio en temps réel. Pour ceux qui connaissent déjà Pure-Data, s'en est un port partiel pour JavaScript : cela veut dire que vous pouvez faire tourner certains patchs directement dans votre navigateur. Pour ceux qui ne connaissent pas Pure-Data je vous invite à lire la suite...

Le hello world de Pure Data.

The midst présente une particularité au niveau du gameplay et de l'implémentation du moteur audio. J'ai choisi volontairement de conserver la même fenêtre pour tous les niveaux, cela signifie qu'à chaque fois qu'on l'on quittera une case une nouvelle page va se charger (un canvas avec un sketch Processing et un patch Pure Data). J'ai donc choisit de créer l'ambiance sonore de chaque case à l'aide d'un "drone" audio, c'est à dire un accord tenu le temps que l'on reste dans la case, mais cet accord est modulé par la position du héros dans sa case ainsi que par son animation.

La source audio.

L'accord est formé de deux sons : un oscillateur, et un phasor (forme d'onde en triangle), on utilise la convention MIDI pour choisir la fréquence à laquelle vont osciller ces deux sources, l'objet [mtof] permet la conversion de notes midi en fréquences.

Une première enveloppe contrôlée par l'animation du personnage.

Une seconde enveloppe contrôlée par la position du personnage dans la case.

La sortie audio : l'objet [dac~] représente les haut-parleurs de votre ordinateur.

Il reste maintenant à dupliquer ce code quatre fois (et changer la valeur de la note midi jouée à chaque fois pour former un accord) puis à interfacer le code de notre ambiance sonore avec notre code processing.js qui régit l'animation de notre personnage principal, c'est à dire permettre à notre code processing.js d'envoyer des messages à webpd pour moduler le son de notre synthétiseur en temps réel.

L’interfaçage d'un seul drone avec processing JS.

En ce qui concerne le son de collision on peut se servir d'un bruit blanc qui va être modulé par une enveloppe maison.

La source sonore est cette fois un bruit blanc [noise~].

L'enveloppe "maison" : un enveloppe attack (1ms) decay (10ms).

Les deux parties assemblées.

Pour jouer ce son, on pourra maintenant envoyer un message de type :

patch.send("pjstick","bang");

Il ne nous reste alors plus qu'à tout assembler, pour obtenir la base du moteur audio du jeu :

Le moteur audio au complet

Nous ne sommes bien sûr pas du tout obligés de synthétiser tous les sons ! Il est possible de charger des sons et de les jouer comme on le souhaite (une fois, en boucle, ou alors juste des bouts à droite à gauche). Si vous y arrivez, le dernier niveau vous permettra de découvrir une première approche de la musique générative pour le web. L'avantage de Pure Data et qu'il existe une large communauté de musiciens qui l'utilisent, ceux-ci seront à même de mettre en place un moteur audio complet et interactifs pour le web.

The Midst ... ¶

Comme je le mentionnais au début ce jeu est aussi un atelier dont la première édition aura lieu du 16 janvier au 20 février à Stereolux à Nantes , sous forme de six séances de deux heures, qui permettront à leurs participants de se familiariser avec ces technologies mais aussi de développer une case du jeu. J'espère qu'avec le temps le jeu s'étoffera que le labyrinthe s'étendra... alors si vous souhaitez contribuer n'hésitez pas à me contacter !

Réagissez sur cet article .

What The Feuille ?

2013-02-01T00:00:00Z

Écologie | Informatique Niveau: Vulgarisation Tarek Ziadé

Tarek & Ronan en train de tester What The Feuille (by Kenneth Reitz)

Le Hackathon est un mot-valise, m'apprend Wikipédia — contraction de hacking et de marathon . Un marathon de hacking est un évènement durant lequel des développeurs vont travailler ensemble pour tenter d'accélérer le développement d'un projet en se concentrant dessus le temps d'un week-end ou parfois d'une semaine.

Dans la communauté Python, on parlera plus de sprints , terme inventé par Tres Seaver pour décrire les réunions de 2-3 jours pendant lesquelles des paires de programmeurs bossaient sur Zope 3 — un logiciel écrit en Python.

Les Hackatons organisés par AngelHack sont encore une autre variante : vous avez 24 heures pour produire un projet de A à Z dans des locaux où tous les participants se réunissent et restent éveillés toute la nuit — soignés à coup de pizzas et Red Bull par les organisateurs.

A la clé, la possibilité de gagner un A/R à San Francisco pour pitcher des Angel Investors de la Silicon Valley.

La plupart des projets sont des applications web. Plus rarement des applications desktop ou du hardware.

Il ne faut pas se leurrer, à mon avis, derrière la plupart des équipes participantes se cachent des startups en devenir qui planchent sur leur sujet depuis des mois voir des années — pour elles, un concours comme AngelHack est une opportunité de s'exposer aux investisseurs, voire d'avoir la chance d'aller leur rendre visite en Californie.

De mon coté — la partie startup/pitch ne présentait aucun intéret. Mais l'idée d'essayer d'écrire une appli fonctionnelle et moderne en 24h par contre...

On s'est donc inscrit avec Olivier & Ronan et on a participé au concours sans carte de visite, ni rien à vendre — juste l'envie de hacker une appli.

What The Feuille ¶

What The Feuille c'est l'excellent nom trouvé par Olivier pour l'application que l'on a décidé de construire pendant le hackathon.

Le but de cette application est de deviner de quelle plante ou quel arbre provient une feuille que l'on vient de prendre en photo depuis son mobile ou sa tablette.

Oui, j'ai déjà vu des promeneurs prendre des photos avec une tablette en forêt.

On a choisi assez rapidement d'écrire cette application web entièrement en Javascript et HTML5 pour le coté utilisateur, sans passer par des dévelopements spécifiques à la plateforme iOS ou Android pour plusieurs raisons :

même si des outils comme PhoneGap permettent de développer une application mobile qui est ensuite compilée pour chaque plateforme native, le principe de subir une modération sur l'app store d'Apple ou Google Play nous rebute profondément.
le HTML5 et le Javascript sont compris par tous les périphériques, et notre application n'a pas besoin d'accéder à des fonctionnalités avancées des mobiles ou tablettes, comme l'envoi de texto.
le HTML5 et le Javascript pour les applications mobile, c'est l'avenir !
avec un peu de responsive design , la même interface marchera aussi sur les ordinateurs de bureau ou laptop. Cette technique consiste à adapter la mise en page en fonction du périphérique qui se connecte sur le site : téléphone, tablette, ou ordinateur. En fonction de la taille de l'écran, le serveur essayera d'optimiser l'affichage.

Côté serveur, l'application web n'a pas grand chose à faire : servir 2 ou 3 écrans, récupérer les photos et les stocker, et enfin lancer l'algo d'apprentissage automatique - ou machine learning en anglais.

Mais mine de rien, ce genre d'application touche à pas mal de domaines de programmation :

du responsive design , de manière à pouvoir afficher l'application sur une tablette, un téléphone, etc ;
du stockage d'images et de méta-données associées, avec potentiellement beaucoup, beaucoup d'entrées ;
une bonne dose de Javascript pour les interactions avec l'utilisateur ;
du machine learning pour toute la partie intelligente ;
de la programmation web pour lier le tout, avec les composantes classiques comme l'identification, le templating, etc.

Pour résumer le fonctionnement dans un schéma simple :

C'est pas compliqué...

L'utilisateur trouve une feuille — où l'arrache discrètement, puis dégaine son portable pour prendre un cliché, et demande à notre serveur de reconnaître la feuille.

En détail, le flow est le suivant :

La page principale permet d'uploader une photo géolocalisée.
La photo est stockée sous un nom unique sur le disque dur du serveur.
L'utilisateur édite la photo en indiquant au doigt (ou à la souris) le haut et le bas de la feuille.
Les informations de positionnement sont envoyées au serveur, qui redimensionne la photo.
La photo est mise à jour et affichée pour que l'utilisateur valide l'édition.
L'algorithme de reconnaissance de feuilles cherche ensuite dans la base les feuilles considérées comme similaires.
Une liste de suggestions d'arbres/plantes est ensuite proposée, et l'utilisateur peut en choisir une.
Enfin, toutes les informations sur la photo sont stockées dans la base de données.

Le va-et-vient entre 3. et 4. est dû au fait que toutes les transformations de l'image de la feuille se font sur le serveur, car à moins d'écrire une application native à chaque périphérique, Javascript est assez limité sur ce genre de fonctionnalités.

Edition de la feuille

D'autres fonctionalitées mineures que nous avons ajoutées au fil de la nuit sont un plantopedia — une page qui liste les plantes et arbres avec les feuilles correspondantes trouvées dans la base ; une page d'accueil qui affiche les dernières photos uploadées et enfin un système d'authentification basé sur Mozilla Persona

Responsive ? ¶

Créer un joli design responsive en 24 heures est impossible sans utiliser un toolkit qui mâche le travail. Le plus souple et le plus puissant est Bootstrap , qui permet très rapidement de créer un design propre et qui s'adaptera tout seul comme un grand à n'importe quel type de périphérique.

L'autre grande qualité de Bootstrap est de permettre à des développeurs comme moi qui n'ont aucune notion de design, de faire une application web à peu près jolie, avec des boîtes qui s'alignent bien, un rendu moderne et standard.

C'est aussi le gros défaut de Bootstrap finalement : rien ne ressemble plus à un site fait avec Bootstrap qu'un autre site fait avec Bootstrap, souvent car les intégrateurs se sont contentés de copier-coller les mises en page fournies en exemple, et aussi parce que il y a un Bootstrap look and feel .

Mais pour notre hackathon, c'est parfait !

Si vous avez envie de tester Bootstrap, je vous conseille de tester Bootswatch qui offre plusieurs thèmes pour Bootstrap. C'est un excellent moyen de démarrer son propre thème.

La killer feature de Bootswatch c'est son Bookmarklet en bas de la page. Un lien à déposer dans Firefox dans la barre des bookmarks et hop ! , un menu déroulant permet d'essayer les thèmes fournis par le projet en live sur n'importe quel site fait avec Bootstrap !

Le bookmarklet de bootswatch en plein action

L'autre outil indispensable pour un design propre en 24 heures, c'est Google Web Fonts .

La police facile.

En quelques minutes, on trouve forcément une police qui nous plait, et il suffit d'ajouter un lien vers la CSS fournie par Google.

En deux heures, les premières pages de What The Feuille étaient affichées sur notre navigateur, et correctement retaillées sur nos téléphones.

Il a quand même fallu par la suite tout le talent de Ronan pour ajouter un logo, une texture de fond de page sympa et tous les petits réglages qui ont donné à notre appli web un vrai look pro.

Du Javascript ¶

Pour toutes les interactions avec l'utilisateur — et les petits effets spéciaux, jQuery est incontournable. De toute façon, il est disponible d'office dans un environnement Bootstrap.

On s'est servi de jQuery pour le positionnement interactif des feuilles par exemple. L'utilisateur clique sur la feuille pour indiquer le haut et le bas, avec son doigt sur un écran tactile ou sa souris. Les coordonnées sur l'image sont envoyées au serveur, qui applique une rotation de l'image.

Tape ta feuille.

On est loin de la barre d'outils de Photoshop, mais l'idée est là : l'utilisateur peaufine son image avant de demander au serveur de faire une reconnaissance de la plante ou l'arbre.

Ce genre de fonctionnalité n'est pas dure à ajouter mais prouve qu'il est possible d'écrire des applications mobiles un minimum interactives basées sur HTML5 et Javascript.

Elastic Search ¶

Les photos uploadées dans l'application sont stockées sur le disque dur, ainsi que les différents thumbnails, générés à la demande.

Elastic Search est le système que nous avons choisi pour stocker toutes les autres informations.

Ce n'est pas une base de données dans le sens strict du terme, mais un moteur de recherche basé sur le très performant Apache Lucene .

Au vu des données que nous stockons, et au vu des requêtes à réaliser — comme par exemple une liste de feuilles correspondant à une plante donnée, en batch — Elastic Search est l'outil idéal.

Elastic Search ajoute au dessus de Lucène un service web qui permet d'indexer et de rechercher en utilisant des messages JSON , ce qui nous permet de ne pas avoir à manipuler du XML , qui est le format d'échange natif de Lucene — et assez laborieux.

Mais Elastic Search c'est bien plus que ça. Les données indexées sont schemaless , c'est-à-dire qu'il n'est pas nécessaire comme la plupart des moteurs de recherche de définir pour chaque type de document les valeurs à indexer. On passe un dictionnaire JSON à Elastic Search et il se débrouille comme un grand pour créer ou mettre à jour le schéma.

L'autre intérêt d'Elastic Search est la possibilité de déployer plusieurs serveurs et de le laisser sharder les données de manière redondante — c'est-à-dire de distribuer les données sur au moins deux serveurs de manière à ne rien perdre si un des serveurs tombe.

Pour le hackathon, on ne déploie qu'une machine avec tous les élements, mais potentiellement, si on prend en photo toutes les feuilles de la planète, le sharding devient indispensable.

Le Cloud ¶

En parlant de déploiement, nous avons choisi de mettre l'application sur un serveur Amazon EC2 de type Spot Instance pour minimiser les coûts au maximum pour ce premier prototype.

Les Spot Instance sont des serveurs chez Amazon qui ne sont pas attribués à des clients fixes et dont le prix de location fluctue en fonction de l'offre et de la demande.

C'est un système malin pour réduire le parc de machines non utilisées : Amazon met à jour en temps réel son prix de location, et pour obtenir une Spot Instance il faut faire une enchère dont le montant est supérieur au prix fixé.

L'avantage est que l'on peut avoir une machine à un prix très avantageux, comme l'explique cet article .

Le gros inconvénient est que si le prix fixé par Amazon dépasse le prix de votre enchère, vous perdez brutalement la machine.

Pour notre démo, ce n'est pas très grave — et même à terme, on peut très bien imaginer une architecture ou des machines Spot Instance sont utilisées comme noeuds pour Elastic Search — du moment que l'ensemble est tolérant à la disparition d'un des noeuds.

Les données sont stockées dans un volume EBS (Elastic Block Store) , qui est complètement indépendant des instances. Un EBS est simplement monté comme volume supplémentaire au démarrage d'une ou plusieurs instances. Les EBS sont hautement disponibles , contrairement aux spot instances, si bien qu'il est possible de déployer des projets dont les bases de données sont stockées sur un EBS et dont toutes les applications exécutées sur des instances plus ou moins fiables.

Il existe d'autres cloud providers comme Rackspace , qui offrent encore d'autres solutions — mais Amazon est probablement le provider qui offre le plus d'options et de souplesse, et permet de s'adapter à tout type de projet.

Bien sûr, toute cette belle technologie déployée sur http://whatthefeuille.com n'avait aucun intérêt pour notre démo — puisque le WiFi était trop mauvais : les manipulations ont été présentées sur une version locale .

La partie web ¶

Pour ce projet la partie web a pour principaux objectifs :

l'authentification des utilisateurs
le requêtage de la base Elastic Search
le calcul et l'affichage de pages HTML

Il existe une pléthore de frameworks qui permettent de fournir ces fonctionalités, et nous avons choisi Pyramid pour pouvoir recycler une petit application existante qui une fois dépouillée de son contenu, nous a fourni un squelette avec tout les outils nécessaires.

Sans cette application de départ, nous aurions probablement choisi un outil plus léger, comme le micro-framework Bottle ou Flask qui permettent de monter une application web en Python en quelques lignes.

La définition de micro-framework est vague, mais dans le monde Python, elle regroupe les outils dont le principal objectif est de simplifier au maximum la création d'une application web, au détriment des fonctionnalités secondaires habituellements fournies dans les frameworks web. Il est rare par exemple de retrouver des fonctionnalités de permissions très avancées, ou des systèmes de schémas de base de donnés.

Bottle par exemple est un framework distribué dans un seul module Python - et il est nécessaire d'intégrer des librairies externes pour la plupart des fonctionnalités avancées.

Pyramid reste malgrès tout un bon choix, même en partant de zéro. Même si démarrer une application avec ce framework est un exerice plus contraignant, c'est en général un choix gagnant à moyen terme. En effet, il est assez fréquent de voir les projets qui grossissent abandonner les micro-frameworks pour passer à des outils qui fournissent plus de fonctionnalités de base.

Voici un exemple de code Pyramid dans notre application :

@view_config(route_name='plants', request_method='GET',
             renderer='plants.mako')
def plants(request):
    """Plants page."""
    query = StringQuery('*')
    plants = request.db.search(query, size=10, indices=['plants'],
                              sort='name')

    data = {'messages': request.session.pop_flash(),
            'user': request.user,
            'gravatar': gravatar_image_url,
            'came_from': request.path_qs,
            'plants': plants,
            'format_date': format_es_date}

    return data

Cette fonction est appelée quand l'utilisateur visite l'URL /plants . request.db.search lance une recherche sur la base Elastic Search pour récuperer les 10 premières plantes. data est un dictionnaire qui contient toutes les données nécessaires à l'affichage. Dans ce cas, la liste des plantes, et quelques données annexes comme l'utilisateur ( user ).

La fonction renvoie à Pyramid le dictionnaire et indique le nom du template a utiliser : plants.mako . Le rendu est automatiquement généré et renvoyé par le framework.

Le reste de l'application est construit sur le même modèle : une fonction par URL.

L'authentification est gérée par Mozilla Persona , l'affichage des pages est obtenue via le moteur de template Mako et les formulaires validés via FormEncode .

Enfin le requêtage d'Elastic Search est fait par la librairie pyes .

La partie intelligente ¶

Scikit-image en action.

La partie la plus intéressante est la reconnaissance des feuilles bien sûr, et pour la mettre en oeuvre, nous avons utilisé la librairie Python scikit-image qui fournit un ensemble d'algorithmes pour la vision artificielle.

Chaque feuille entrée dans l'application subit d'abord une rotation et une normalisation de taille, afin d'avoir un jeu de données le plus homogène possible. La rotation consiste à positionner avec l'aide de l'utilisateur le haut de la feuille en haut au milieu de l'image et le bas de la feuille, sans compter la tige, en bas au milieu.

Ces étapes de normalisation améliorent grandement les résultats puisque l'algorithme de reconnaissance ne sait pas qu'il manipule des feuilles. Il se contente d'essayer de détecter sur chaque photo le maximum de zones d'intérêt , ou features en anglais.

Il existe plusieurs algorithmes d'extractions de features, celui que nous avons choisi d'expérimenter est le HOG (histogramme de gradient orienté).

HOG extrait des histogrammes de gradients sur des blocs carrés de pixels contigus.

Cet algorithme est très efficace pour détecter des personnes sur une photo, et par extension tous types d'objets comme des voitures, des chiens, des chats, etc. Pour que l'algorithme soit efficace sur une classe d'objets donnée, comme les feuilles, il convient de faire varier certains paramètres comme les tailles de blocs.

Nous ne savons pas si les paramètres que nous utilisons sont optimaux pour la détection de feuilles, et nous ne le saurons pas tant que la base de données ne sera pas plus fournie.

Une fois que chaque feuille de la base est transformée en son histogramme, il devient possible de suggérer pour une nouvelle feuille les feuilles qui s'en rapprochent le plus et donc par extension la plante ou l'arbre d'appartenance.

Pour faire cette suggestion, notre application calcule la distance euclidienne entre l'histogramme de la feuille et l'intégralité des histogrammes de la base.

Dans le prototype actuel, tous ces calculs sont faits à la volée. Mais comme cette opération de comparaison est de complexité O(n) , elle ralentira au fur et à mesure que la base de feuilles grossit.

Une solution potentielle consisterait en la construction d'un vocabulaire de taille limitée de 1000 à 10000 images prototypiques qu'ont appelle des mots visuels . Ce vocabulaire peut etre construit par l'utilisation d'un algorithme de clustering sur les features extraites de la base d'images existantes.

Chaque image de la base sera ensuite approximativement encodée dans ce vocabulaire en lui attribuant les 10 ou 100 mots visuels les plus représentatifs pour cette image. On utilise alors ces mots pour indexer les images de la base dans l'index Elastic Search.

On parle de représentation creuse ( sparse en Anglais) car chaque image est encodée en utilisant moins de 10% du vocabulaire possible. Cette technique permet de faire des requetes de suggestion qui fonctionnent mieux sur une base de données très large

En effet quand une nouvelle image normalisée arrive, on extrait ses features, on cherche et on fait une requete de similarité ( "MoreLikeThis" ) dans l'index Elastic Search avec les identifiants des mots visuels les plus représentatif de la nouvelle image.

L'utilisation de l'index Elastic Search permet ainsi de pre-filtrer de manière efficace les 1000 candidats les plus probables.

Pour trouver la suggestion finale on calcule la distance euclidienne sur les features de ces 1000 candidats au lieu de la base complète.

Quoi qu'il en soit, toute la partie intelligente de l'application ne prouvera son efficacité que lorsque la base sera suffisamment riche en plantes et en arbres.

Conclusion ¶

On était pas très jolis à voir le lendemain matin, mais le pari a été tenu — et la démo a fonctionné pendant les 3 minutes sur scène. Les retours étaient assez positifs dans l'ensemble, et l'application va devenir un bon terrain de jeu pour Olivier, qui va pouvoir peaufiner son algorithme de pattern matching.

Des heu-reux gagnants du AngelHack (by Kenneth Reitz)

Ce hackathon m'a fait réaliser la différence majeure entre les moyens que nous avions il y a 5 ans et aujourd'hui — nous autres petits développeurs.

Il n'y a plus besoin d'un budget conséquent et d'une équipe complète pour développer une idée d'application qui peut potentiellement s'adresser à des centaines de milliers d'utilisateurs.

Du platane. C'est du platane je vous dis.

Pour un budget de moins de 50 euros et un petit week-end de travail, nous avons pu mettre en ligne, dans le cloud une application mobile qui ressemble à quelque chose.

Le code source est ici : https://github.com/whatthefeuille/whatthefeuille et l'application en ligne .

Réagissez sur cet article .

Passer un projet sur batterie

2013-05-01T00:00:00Z

Électronique Niveau: Debutant Jonathan Schemoul

Article élaboré en partenariat avec Hackspark.fr. Voir la page partenariats pour plus de détails.

Vous venez de finir votre projet, il est tout beau, tout propre. Oui, mais est-il transportable ? S'il y a une coupure de courant, que se passe-t-il ?

Il existe plusieurs solutions pour mettre un projet sur batterie :

Utiliser de bêtes piles, on a plusieurs réceptacles pour cela... mais la recharge doit être séparée ou les piles changées régulièrement. Pas génial.
Utiliser une pile 12V de voiture ou d'onduleur, lourd et pas forcément efficace.
Notre solution préférée, et c'est celle que nous allons étudier ici, utiliser des batteries lithium polymer (li-poly) protégées avec un module de charge usb.

Dans le cas d'une solution à base de li-poly, il y a plusieurs choses à prendre en compte : la batterie en elle-même (combien allons-nous consommer), le module de charge (combien allons nous consommer en pic) et la recharge (usb ? énergie solaire ? eau qui coule ? roue de vélo ? etc.)

Quelle batterie ? ¶

Batteries 3.7v à 1000, 2000 et 6000 mAh

Supposons que nous ayons un projet avec un Arduino Uno , quelques senseurs, une ou deux leds et une carte SD, ça ne nous fait pas beaucoup d'énergie au final (5V 200mA environ). Si on veut être alimenté tout le temps, sauf de temps en temps, et continuer à marcher lorsque l'on est débranché (continuer en cas de coupure de courant), on pourra prendre une petite batterie 1000mAh . Pour tenir un petit moment une batterie 2000mAh . (en 3.7v, cela équivaut à environ 1500mAh en 5v soit 7h30 environ).

Si l'on veut tenir plus longtemps ou que notre projet consomme plus (utilisant une carte Raspberry Pi par exemple), on peut opter pour une batterie de 6000mAh (donnant environ 22h d'autonomie à notre exemple précédent, 12 à 16h à un RPi modèle A et 7 à 10h à un RPi modèle B, selon l'utilisation du cpu et de l'usb).

Quel module de charge ? ¶

Modules de charge LiPo Rider Pro et LiPo Rider côte à côte

Avoir une batterie, c'est bien, mais autant faut-il pouvoir l'utiliser.

Certaines cartes de prototypage proposent un port permettant d'en raccorder une en direct (la seeeduino mega par exemple), mais autant prendre une solution générique.

Pour cela, on en a choisi deux.

La carte LiPo Rider est un bon choix car elle permet de brancher n'importe quel périphérique en usb et de l'alimenter à partir de la batterie. Dès que vous branchez le lipo rider à l'ordinateur, vous accédez de façon transparente au device alimenté (votre arduino pour l'exemple précédent, et ainsi le programmer pendant que vous le chargez) tout en rechargeant la batterie. L'autre avantage est qu'il supporte l'adjonction d'une source externe comme un panneau solaire, une dynamo ou un générateur hydro. Petit bémol, sa sortie d'énergie en pointe est de 350mA en 5V, donc ce sera suffisant pour un arduino avec quelques capteurs, mais si vous voulez alimenter une matrice de leds, un moteur ou autre chose, passez à la carte suivante.

La carte LiPo Rider Pro a les mêmes fonctionnalités que sa petite soeur, mais permet de sortir 1A en 5V, de quoi alimenter un raspberry pi avec sa clé wifi, un arduino avec des petits moteurs, etc. Vous pourrez même l'utiliser pour charger votre téléphone portable en fait.

Quelle source d'énergie ? ¶

Lorsque l'on peut être branché au secteur ou à un ordinateur, pas de soucis, on se recharge lorsque l'on est branché en USB, et on utilise la batterie lorsqu'on ne l'est pas. Pas besoin d'une source annexe.

En revanche, pour des projets nomades ou devant rester à l'extérieur, nous avons plusieurs sources d'énergie à notre disposition, que ce soit une dynamo sur un vélo, un générateur hydro ou des panneaux solaires .

Pour notre exemple, nous allons nous intéresser plus particulièrement aux panneaux solaires, en particulier les panneaux photo-voltaïques. On les classe selon la puissance restituée, ceux proposés sur HackSpark sont en 3.7v et proposent des puissances allant de 1.5 à 3W.

Panneaux solaires 1.5W, 2W et 3W

Dans le cas de l'Arduino avec des capteurs, le projet consomme 200mA à 5V, soit 1W. Un panneau de 1.5W est donc suffisant en source d'énergie d'appoint, mais devient limité lorsque l'on doit tenir toute une nuit par exemple.

Si l'on utilisait un MSP 430 Launchpad à la place d'un Arduino, on pourrait consommer beaucoup moins, 50 à 100mA environ et encore, uniquement lors des réveils (le msp430 peut entrer en veille quasi-complète pendant de longues périodes); Dans ce cas le 1.5W serait parfait.

Revenons à notre exemple, on prendrait plutôt un panneau solaire 2.5W , laissant 1.5W à la charge d'une batterie lors des périodes ensoleillées.

Dans le cas d'un Raspberry Pi, le Type B consomme environ 350mA en activité moyenne et jusqu'à 700mA lors des pics de cpu.

Prenons la valeur moyenne de 300mA, cela nous fait 0.4x5 => 2W, un panneau de 2.5W sera tout juste suffisant alors qu'un panneau de 3W sera adapté. Un Raspberry Pi type A en revanche, consomme beaucoup moins, et pourra être opéré avec un panneau de 2.5W sans trop de soucis.

Connectons tout ça... ¶

Connexion

Tout d'abord, il faut relier la batterie au LiPo Rider, grâce à la prise prévue à cet effet.

Si vous avez choisi d'utiliser un panneau solaire pour augmenter l'autonomie de votre projet, c'est le moment de le connecter également.

Maintenant, connectez votre dispositif (Arduino, Raspberry-Pi, etc.) avec la prise USB host femelle (comme celle d'un ordinateur).

Pour finir, allumez le dispositif à l'aide du sélecteur on/off sur le Lipo Rider . Et voilà, vous avez un dispositif autonome. Ce n'était pas très compliqué :)

Exemple de montage.

Et ensuite ? ¶

Faire marcher c'est une chose, avoir de l'autonomie c'en est une autre, et vous devrez tôt ou tard penser à optimiser votre projet pour l'économie d'énergie.

Avec un Raspberry Pi la solution facile est de passer au Raspberry Pi modèle A qui est beaucoup moins gourmand en énergie.

Avec un Arduino, une solution est de passer aux MSP430 qui ont un IDE équivalent à Arduino disponible sur internet, vous permettant de continuer à utiliser votre code, l'autre, plus simple et aidant un peu (moins) est de passer à une carte Arduino supportant l'exécution en 3.3v comme la Seeeduino des photos ci-dessus ou l' iTeaduino .

Chacun a ses solutions pour moins consommer, l'essentiel étant d'arriver à équilibrer la consommation électrique avec la vitesse de charge et/ou l'autonomie désirée.

Le coût écologique de vos données

2013-05-01T00:00:00Z

Écologie | Autre Niveau: Decouverte David Larlet

Hangar.

Des photos de vacances non triées aux mails archivés ad vitam aeternam , des films collectionnés aux bibliothèques musicales dont la qualité est devenue obsolète, des livres téléchargés mais jamais ouverts aux projets inachevés, nous disposons tous de poussières numériques plus ou moins évidentes.

À l'heure où le stockage de données domestiques se compte en téra-octets, on pourrait trouver saugrenue l'idée de limiter son impact en terme de stockage numérique. Et pourtant. Songez un instant à cette masse de données accumulées, à ce grenier numérique qui encombre votre disque dur de ses données antédiluviennes, et ces sauvegardes sur d'autres supports, et ces sauvegardes distantes, et ces sauvegardes incrémentales. Autant de duplications et de transferts qui ont un coût écologique non négligeable.

Comment réduire son empreinte numérique ? La première option pourrait être de ne pas faire de sauvegarde du tout, ce qui règlerait le problème en faisant un reset du système à chaque itération de crash/réinstallation. Cette éventualité vous fait peut-être sourire pourtant la plupart des personnes (non-techniciennes) de mon entourage gèrent leur patrimoine numérique de cette manière. En tant que lecteur du magazine, vous êtes probablement dans un cas inverse et vous accordez une certaine importance à la pérennité de vos données , ce qui vous a amené à effectuer des sauvegardes suivant la méthode recommandée des 3 emplacements physiques distincts (ce qui soulève notamment un problème de confidentialité diluée mais ce n'est pas l'objet de cette tribune).

Pour venir à bout de cette poussière qui s'accumule, il faut se prêter à deux exercices : un ménage régulier et une hygiène de vie numérique . Le ménage initial est incroyablement chronophage en fonction de l'état de flemme dont vous avez fait preuve au cours des précédentes années (décennies ?!). La première étape pourra consister à localiser les fichiers qui sont les plus volumineux pour procéder à un premier tri, et ce, dans chacune des catégories possibles (films, livres, emails, etc.) tout en ajustant la qualité des données à votre perception : inutile de conserver des rafales de photos en raw de 30 Mo si vous avez un ordinateur portable de 13" non calibré… Une fois ce premier ménage effectué (je vous conseille le printemps approchant, c'est une excellente période pour ça) il va falloir suivre une certaine méthode de tri des données qui doit devenir à terme une routine. En procédant ainsi, vous allez pouvoir cultiver une base saine et propre à vos besoins.

Outre la satisfaction d'un travail bien fait et la préservation de votre santé mentale, je parlais en introduction du coût écologique de ces données. Il faut bien avoir conscience que, quelle que soit votre approche — traditionnelle et locale ou récente et distante (Cloud) — le stockage de données occasionne une consommation d'électricité non négligeable . Prenons l'exemple d'un film d'1Go que vous conservez sur votre disque dur : celui-ci va être répliqué sur votre sauvegarde locale (sur-consommation au moment du transfert et stockage physique, obsolescence itérative non pas programmée mais matérialisée du périphérique de stockage), puis répliqué sur votre sauvegarde distante (sur-consommation au niveau du routeur/modem durant toute la durée du transfert, des intermédiaires réseaux et du serveur qui est très certainement lui-même redondé — peut-être en plusieurs points du globe) et enfin éventuellement transféré physiquement dans un autre lieu. Que d'énergie dépensée pour un film que vous n'allez en définitive peut-être même pas visionner !

Un archivage raisonné de vos données est le garant d'une empreinte numérique respectueuse des ressources naturelles finies dont nous disposons.

Comment réparer soi-même les Internets

2013-05-01T00:00:00Z

Informatique | Écologie Niveau: Decouverte Damien Nicolas

Ça nous est tous arrivé. Vous regardiez tranquillement des vidéos de chatons sur Youtube après une dure journée de travail, puis PAF, sans prévenir, vous vous êtes rendu compte que quelque chose était cassé sur l’Internet mondial. Non pas que la vidéo ne chargeait plus, encore que selon votre FAI, cela pourrait en être un symptôme. Non, le problème, c’est que vous avez lu la phrase précédente sans relever particulièrement le mot Youtube. Et ça fait beaucoup de mal aux Internets.

Voyez-vous, si on devait, comme certains vendeurs de temps de cerveau aiment à le faire, considérer Internet comme un moyen de diffusion de contenu, alors on penserait qu’il n’y a qu’une seule grande chaîne de télévision que tout le monde regarde. Pas parce qu’il y a un seul contenu imposé à tous, mais parce qu’il n’y a qu’un service. La comparaison atteint très vite sa limite, car, bien sûr, on peut regarder la vidéo de son choix sur Youtube, à tout moment. Du moment que Youtube le veut bien, et c’est là toute l’importance.

En effet, et même si vous êtes l’auteur d’une vidéo que vous choisissez de diffuser sur cette plateforme, si elle contrevenait aux conditions générales d’utilisation, elle serait supprimée sans procès. Et c’est tout à fait normal : il ne s’agit pas d’un service public, mais d’une plateforme privée, appartenant à une grosse société américaine, et pouvant légitimement définir les règles en vigueur en son sein.

Donc, si vous ne voulez pas subir la vilaine censure, parce que par exemple votre vidéo tient des propos critiques vis-à-vis du gouvernement en place, que pouvez-vous faire ? Bien sûr, vous pouvez l’héberger sur Dailymotion, ou un autre service similaire. Le problème se pose toujours : vous dépendez d’une grosse plateforme qui peut à loisir décider que vous n’avez pas le droit de publier ça.

Et c’est un problème, parce que ce fonctionnement est censé être un vestige du passé. Ce passé où Internet n’existait pas encore, où pour porter un message avec plus de force que ce que notre propre voix nous le permettait, il fallait écrire un livre et montrer patte blanche à un éditeur, qui décidait si oui ou non vous méritiez de porter ce message. Ce passé où l’information était essentiellement en lecture seule, car écrite par une poignée — toutes proportions gardées — de privilégiés.

L’Internet d’aujourd’hui est en panne, parce que certains, dont (et c’est tout le problème) ses propres acteurs techniques, tentent d’en faire un outil du passé.

Internet fonctionne en lecture/écriture ¶

Cela vous semble aujourd’hui naturel de pouvoir écrire sur Internet. Qu’il s’agisse de laisser un commentaire sur un article, de publier une vidéo (que ce soit sur Youtube ou pas), de tenir soi-même un blog ou un site d’actualité indépendant, voire même de développer un programme informatique permettant un usage nouveau du réseau, et de le mettre à disposition de tous. Tout cela peut être fait sans demander d’autorisation. Vous ne connaissez pas de nom ou d’adresse d'une administration qui serait chargée de distribuer les autorisations d’ouverture de blog, pour la simple raison qu’il n’existe pas de telle chose. Pour ouvrir un blog, il vous suffit de vous inscrire en quelques secondes sur un hébergeur gratuit, comme http://www.wordpress.com par exemple, ou de louer de l’espace sur un serveur et d’installer un moteur de blog libre. Ou même, installer un serveur web sur votre propre ordinateur, qui, sans plus de formalités, pourra être accessible par tout utilisateur d’Internet.

D’un point de vue idéologique, cette dernière possibilité est idéale. Car tout utilisateur d’Internet, représenté par une adresse IP, peut sans restriction être un serveur aussi bien qu’un client. L’adresse IP qui répond derrière google.com n’est pas structurellement différente de celle que vous fournit votre fournisseur d’accès à Internet (FAI). Il n’y a bien sûr pas le même débit derrière, mais peu de gens ont besoin, pour un blog personnel, du débit alloué à un mastodonte comme Google.

Mais techniquement, les choses sont plus compliquées. Pour commencer, certains FAIs considèrent tout simplement que la possibilité d’héberger des services (comme des sites web) sur une connexion personnelle est marginale, et qu’il n’y a pas lieu de l’encourager. Pire, certains interdisent contractuellement cette pratique. De cette façon, ils transforment Internet en un réseau en lecture seule. Bien sûr, il est toujours possible de poster des commentaires sous une vidéo Youtube, ou de créer son blog ailleurs. Mais vous n’avez plus la possibilité de devenir votre propre fournisseur de votre propre contenu.

L’autre problème est plus sensible, et nettement plus technique. Aujourd’hui en France, la majorité des accès à Internet personnels se fait par technologie ADSL, dont le A signifie « Asymétrique ». En effet, cette technologie, telle que déployée, permet généralement des débits de téléchargement tout à fait corrects (on parle de « 20 mégas », mais il s’agit d’une capacité potentielle maximale, autrement dit un flou bien manipulé par le marketing), mais une capacité d’envoi extrêmement limitée en termes de capacités théoriques potentielles, on parle de « 20 mégas » en trafic descendant (download, téléchargement), mais seulement « 1 méga » en montant (upload, envoi, téléversement) ! La conséquence directe est que, quand vous postez une vidéo du petit dernier de la famille, l’envoi est généralement laborieux, alors que lire une vidéo haute définition sur n’importe quelle plateforme se fait quasiment en temps réel.

Il s’agit d’un problème inhérent à l’ADSL, et pour le résoudre, il faut donc se tourner vers d’autres technologies : la fibre optique, dont le déploiement souffre, en France, d’un retard inquiétant, ou bien du SDSL ou VDSL, qui offrent un débit montant plus important. Mais le peu d’intérêt que portent les FAIs aux usages « en lecture/écriture » d’Internet n’a, lui, pas de réponse technique simple.

Les FAIs, tous salauds ? ¶

Même si on considère que « non », un FAI commercial a, comme toute entreprise commerciale, vocation à générer de l'argent. Partant de ce principe, tout FAI commercial peut, un jour ou l'autre, retourner sa veste et choisir de ne plus garder comme objectif que la satisfaction de ses investisseurs au détriment des principes fondateurs d'internet.

Heureusement, un petit village d’irréductibles barbus résiste encore et toujours à l’envahisseur. Plus exactement, des gens ont décidé de combattre ces pratiques visant à faire d’Internet un outil du passé, tout simplement en faisant eux-mêmes leur Internet équitable. Ces gens, ce sont d’abord les membres de French Data Network (FDN), un fournisseur d'accès Internet associatif, créé en un temps où dans ce secteur l'association était la norme et l'entreprise l'exception, et qui a gardé ce modèle depuis.

À l’époque, ces considérations n’avaient pas lieu d’être. Quand on était FAI, on reliait des gens à Internet, et c’est tout. Aujourd’hui, les gros FAIs ont la fâcheuse tendance à être de grosses sociétés ayant des intérêts de grosses societés, mais pas seulement : Par exemple, SFR, pour ne citer que lui, appartient à Vivendi, spécialisé dans la distribution de contenu. Naturellement, on comprendra qu’ils ont un intérêt particulier à ce que leurs clients consomment leurs propres contenus, et ça pose de gros problèmes de conflit d’intérêt.

À l’inverse de cela, FDN a préféré considérer qu’un FAI avait pour seul rôle d’acheminer les données de son réseau du mieux possible, ce qui est déjà une tâche conséquente. Et le fait de rester une structure associative a naturellement éloigné l’envie de monétiser au maximum cette activité. Et que le seul bénéfice à en tirer était la possibilité d’utiliser soi-même un réseau fonctionnel et indépendant et pouvoir, en cas de dysfonctionnement, intervenir soi-même.

Faire de l’Internet avec ses bits et son couteau ¶

Internet, ce n’est pas une machine géante sur laquelle un milliard d’internautes sont connectés. Internet, c’est « le réseau des réseaux », à proprement parler. Il y a dans le monde quelques dizaines de milliers d’opérateurs, qu’il s’agisse de FAIs grand public, de sociétés suffisamment importantes pour avoir besoin de leur propre accès, ou autres. Chacun de ces opérateurs dispose d’adresses IP à redistribuer à ses clients, ou machines. Tout cela compose son réseau.

Dans le cas d’un FAI commercial, le réseau est l’ensemble des « box » connectées et dotées d’une adresse IP publique. Et Internet, c’est tout simplement le fait que tous ces réseaux sachent discuter entre eux. Il n’y a rien de plus au milieu, aucune boîte noire centrale. Si un opérateur tombe en panne, tout le reste fonctionne encore. C’est ce qui assure la robustesse du réseau mondial, et sa célèbre « résistance à une frappe nucléaire ». Tout ce qu’on a à faire, c’est donc de créer un petit opérateur qui prendra sa place auprès des quelques 400 000 autres. Il s’agit d’une formalité administrative, du même ressort que celle qui permet d’obtenir des adresses IP à distribuer.

Car s’il est vrai qu’Internet n’a pas de centre ou de chef technique, il faut savoir qu’il y a tout de même une entité « à la tête » administrative, ou ce qui s’en approche le plus, d’Internet. C’est L’IANA (Internet Assigned Numbers Authority), qui a pour rôle de s’assurer qu’une même IP ne peut être attribuée plusieurs fois en même temps. Cette autorité (une organisation américaine) distribue de gros blocs d’adresses à des autorités régionales (à l’échelle de continents), les RIR (Regional Internet Registry), qui eux-mêmes distribuent soit aux opérateurs en eux-mêmes, soit à de plus petits revendeurs, les LIR (Local Internet Registry). Pour devenir opérateur, il faut donc demander à l’autorité appropriée (les opérateurs français dépendent du RIPE-NCC, le RIR eurasien) un numéro de Système Autonome (AS), qui sera notre identifiant auprès des 40 000 autres, et des blocs d’adresses IP.

Une fois qu’on a ça, il y a 2 détails à prendre en compte : d’abord, connecter ses utilisateurs (c’est la collecte), et ensuite se connecter aux autres opérateurs (c’est le transit ou le peering).

Connecter ses utilisateurs, ça peut être très simple. Dans sa forme la plus simple, il s’agit de brancher des câbles entre les utilisateurs. S’il y en a plus de 2, on peut utiliser un commutateur réseau (communément appelé switch). Ensuite, on peut attribuer manuellement une adresse à chaque utilisateur.

On peut automatiser ça, dans la même configuration, en ajoutant une machine qui fera office de serveur DHCP (dont le but est d’attribuer automatiquement les adresses). C’est le fonctionnement par défaut d’un réseau local derrière une machin box. Cela a pour intérêt d’être plus facile à administrer, car il ne faut gérer que le serveur, les autres postes se configurant automatiquement. Quand on commence à grimper en échelle, on voudrait être sûr de donner les bonnes adresses aux bonnes machines. Pour cela, on va utiliser un protocole d’authentification, qui assurera également qu’on distribue la même adresse à une personne.

Quand on voit plus grand, et qu’on commence à avoir des machines qui ne peuvent pas être branchées ensemble directement, car trop distantes, on a besoin d’utiliser d’autres méthodes de liaison. C’est là que l’xDSL, ou la fibre, ou d’autres moyens, entrent en jeu. Leur rôle est de connecter les utilisateurs aux serveurs de routage de l’opérateur.

Le problème, quand on est une petite association, c’est qu’on peut difficilement se permettre financièrement de monter de l’ADSL, ou de la fibre, jusqu’à chaque utilisateur. La solution choisie par FDN a été de louer de la collecte à un autre opérateur déjà en place. Ainsi, c’est l’équipement de cet opérateur qui relie l’utilisateur aux serveurs, à coût abordable.

Il y a cependant d’autres possibilités. Selon le contexte géographique, on peut imaginer relier connecter ses utilisateurs en tirant soi-même de la fibre optique sur des poteaux, ou même utiliser des ponts wifi à longue distance. Ces méthodes permettent généralement de s’affranchir de la dépendance envers un opérateur de collecte, et donc d’être plus indépendant.

Maintenant que nos utilisateurs sont connectés sur notre réseau, et qu’on leur a attribué des adresses IP publiques, ils sont capables de discuter entre eux, mais pas avec le reste des utilisateurs d'Internet. Pour cela, il faut se connecter aux autres opérateurs.

Matériellement, cela n’a rien de compliqué : on pose une machine de notre réseau dans un datacenter, et l'on se connecte aux routeurs d’autres opérateurs. Encore faut-il leur demander l’autorisation. Concrètement, ça se traduit en contrats de transit et accords de peering, qui régulent les volumes d’échanges qu’il y aura entre les deux parties. On ne peut pas se connecter physiquement aux 40 000 opérateurs, donc pour pouvoir discuter avec un opérateur lointain, on devra transiter par un ou plusieurs intermédiaires, et ces derniers facturent le débit consommé.

Les rejetons de FDN ¶

La Fédération FDN

Dans la continuité de sa volonté de rester un petit opérateur associatif, FDN a, en 2006, considéré qu’il fallait « forker » l’association, tel un projet logiciel. La Fédération des fournisseurs d'accès à Internet associatifs (communément appelée FFDN, soit « Fédération FDN ») a donc été initiée, dans le but d’accompagner les projets d’opérateurs associatifs poussés par les mêmes valeurs que FDN, c’est à dire la volonté de faire de l’Internet neutre, donc en lecture/écriture.

Depuis lors, 16 autres fournisseurs d’accès à Internet ont rejoint la fédération, et d’autres ont formulé leur demande d’adhésion. Chacun d’entre eux met en avant la portée locale de son projet, pour garantir une gestion humaine.

Au-delà de ça, des projets différents ont émergé : certains se contentent de fournir des abonnements ADSL en marque blanche de FDN (en se focalisant sur le développement du tissu social de l’association), d’autres mettent en place leur propre collecte, par déploiement de fibre optique ou de ponts wifi. Lorsque FDN a appelé à la création de multiples FAIs locaux, on y comptait une centaine d’adhérents. Aujourd’hui, la fédération compte plus de 1200 adhérents parmi ses 17 associations.

Faire partie d’Internet n’est pas un rêve. Mais le faire à plusieurs, c’est mieux.

Faire de la peinture sans support et sans tache, avec de la lumière

2013-05-01T00:00:00Z

Électronique | Informatique | Art Niveau: Facile Fabien Batteix

C'est un fait, tout le monde aime les spectacles de son et lumière, qu'on soit petit ou grand. Alors si comme moi vous aimez bricoler, photographier et programmer, l'article qui suit devrait vous intéresser ;)

Dans cet article je vais vous présenter une méthode de dessin, ou de photographie, c'est une question de point de vue. Cette méthode s'appelle le « light painting », « peinture de lumière » en français.

Qu'est-ce que le « Light Painting » ? ¶

Le light painting , qu'on pourrait traduire par « peinture de lumière » en français est une technique de photographie consistant à réaliser une image avec de la lumière comme seul outil de dessin. D'un point de vue technique cela se résume à utiliser un appareil photo en exposition manuelle .

Traditionnellement on prend une photo en exposition « courte », dans un environnement bien éclairé. Si on manque de lumière la photo sera sombre et le sujet masqué par l'obscurité. En light painting c'est tout le contraire ! On prend une photo … dans l'ombre, voire même dans l'obscurité la plus totale. Comme l'on utilise une exposition manuelle, pouvant aller jusqu'à 30 voire même 60 secondes (cela dépend bien sûr de l'appareil photo utilisé) toute « trace » de lumière vue par l’appareil photo durant ce laps de temps sera reproduite sur la photo finale. Donnant ainsi une image constituée d'un « historique », par couches successives, des traces lumineuses observées.

Exemple de light painting en étant face à l'objectif (source : wikipedia , [Arcade, Light painting photography, 10/05/2009], licence Free Art )

Il existe deux techniques de light painting, celles-ci pouvant être utilisées seules ou en duo. Dans les deux cas une simple lampe de poche ou un pointeur laser peut suffire à donner un résultat impressionnant. La première technique est la plus classique : on pointe une source lumineuse vers l'objectif pour « dessiner » un tracé (en effet miroir) avec la lumière. Une variante de cette technique consiste à pointer un laser de couleur sur un mur et de dessiner avec le faisceau, cette variante à l’avantage de ne pas donner un résultat en « miroir ».

Exemple de light painting basique en étant derrière l’appareil photo avec un pointeur laser

Une seconde technique consiste à éclairer, ou non, des zones d'une pièce ou d'un objet. Le jeu de lumière ainsi obtenu donnant un certain effet « non naturel » à l'image.

Exemple de light painting utilisant des jeux d'ombre et de lumière (source : wikipedia , photo : Thomas Bresson , licence CC BY 2.0 )

Seulement comme vous pouvez le remarquer il n'est pas possible de dessiner quelque chose de précis. Certes il est possible de faire des choses vraiment impressionnantes moyennant un peu d'imagination (et de pratique, chose que je n'ai pas malheureusement) mais il est impossible par exemple de dessiner un texte « propre » ou un pixel-art, du moins à la main.

La technologie au secours du light painting ¶

Dans cet article je ne vais pas vous expliquer comment dessiner, ou comment utiliser un appareil photo, je vous laisse chercher dans le manuel de celui-ci comment utiliser l'exposition manuelle ;)

Ce que je vais vous expliquer c'est comment - au moyen de matériels simples et facilement disponibles - fabriquer une « digital light wand » (« baguette lumineuse numérique » en français, c'est tout de suite moins glamour), l'outil ultime du « light painter ».

L'outil magique du parfait light painter

Le principe est simple : un humain ne peut pas dessiner quelque-chose de précis et encore moins en plusieurs couleurs. Pour cela il faudrait une précision dans les mouvements et une notion de position dans l'espace surhumaine !

Un microcontrôleur par contre n'a pas ce problème. Un microcontrôleur peut sans problème contrôler des leds RGB (leds tri-colores permettant de générer n'importe quelle autre couleur), respecter des timings précis et même utiliser des périphériques de stockage !

C'est justement ce qu'est une « digital light wand » : un microcontrôleur, un ruban de led RGB et (accessoirement) un lecteur de carte SD.

Les leds RGB étant principalement vendues en ruban il suffit de déplacer la ligne de « pixels lumineux » ainsi formée de manière rectiligne devant l'appareil photo pour obtenir une image parfaite. La gestion des pixels et des timings étant laissée à la charge du microcontrôleur, la seule action humaine nécessaire est de déplacer le ruban de manière rectiligne le plus régulièrement possible.

Le matériel nécessaire ¶

Pour un total d'une centaine d'euros environ cela reste un projet relativement abordable

Comme précisé précédemment le matériel nécessaire est très limité et est facilement disponible. Pour fabriquer votre propre « digital light wand » il vous faut :

une carte arduino « classique » (ici une carte Arduino UNO)
une shield possédant un support pour carte SD
une shield lcd avec boutons de DFRobots (ou compatible)
et bien sûr, un ruban de leds RGB

(la shield avec les borniers n'est pas obligatoire mais facilite grandement le câblage)

Pour ce projet il est obligatoire d'utiliser un ruban de leds RGB bien précis : le LPD8806 , vendu par Adafruit . Celui-ci a la particularité de posséder des contrôleurs de led indépendants au sein même du ruban. Il est donc possible de contrôler chaque led indépendamment et d'avoir une profondeur de couleur de 21 bits (7 bits par composante R, G et B).

Assemblage des composants ¶

L'assemblage des composants est l'étape la plus facile du projet, si vous avez choisi d'utiliser une carte arduino classique et des shields du commerce cette étape se résumera à l'empilage des shields sur l'arduino.

Si vous avez choisi de faire votre propre montage avec des composants séparés (arduino pro mini + lecteur de carte SD + écran par exemple) il faudra sortir le fer à souder, les fils et assembler le tout ;)

Mon précieux

Petite modification hardware ¶

Durant le montage de mes composants j'ai remarqué un problème au niveau du câblage de la shield « support pour carte SD » et de la shield lcd de DFRobots. La shield pour carte SD utilisait la broche D4 pour le « chip select » (choix du périphérique actif en communication SPI) de même que la shield lcd pour l'afficheur !

Une simple broche aurait pu tout faire capoter …

Il y avait donc conflit entre ces deux shields, la solution : un fil et un coup de cutter (léger) pour « re-router » la broche « chip select » de la carte SD sur la broche D3 de l'arduino.

Un bon bricoleur ne se laisse pas faire aussi facilement

Derniers détails techniques ¶

Tenir un ruban de leds (flexible) droit, à la main, n'est pas une chose facile … Si en plus il faut manipuler le contrôleur pour choisir quelle image dessiner cela devient impossible... à moins d'avoir trois bras.

Simple mais efficace

Pour résoudre le problème rien ne vaut une bonne baguette de bois rigide et du scotch transparent. Ainsi la prise en main du système devient un jeu d'enfant.

Le logiciel ¶

C'est ici que les choses se corsent.

Pour le logiciel j'ai choisi de découper mon code en 5 parties, chacune ayant une fonctionnalité bien précise :

digital_light_wand.ino : le code principal, gérant le choix du fichier et du délai entre chaque colonne de l'image source
bitmap.ino : gérant l'ouverture de fichiers au format Bitmap et la récupération des couleurs de chaque pixel de l'image
lpd8806.ino : gérant l'affichage sur le ruban de leds des pixels de couleurs et de la communication bas niveau avec les contrôleurs LPD8806 du ruban.
keys.ino : gérant les boutons de la shield lcd
screen.ino : gérant l'affichage sur l'écran lcd

Comme vous pouvez le voir cela fait beaucoup de choses !

Le principe de fonctionnement « haut niveau » lui reste très simple :

Setup() :

Initialisation du matériel
Ouverture du dossier « root » de la carte SD

loop() :

Choix du fichier
Choix du délai entre chaque colonne de pixels
Début du dessin
Arrêt des leds du ruban

La majeure partie du code se trouve en réalité dans les différents codes « de contrôle » du matériel.

L'interface homme / machine elle se résume à de simples messages textuels :

Premier écran de choix du fichier

Le choix du fichier s'effectue au moyen des touches droite, gauche et sélection

Un fichier bitmap a été détecté, les informations de taille s'affichent

Plus de fichier dans le dossier courant, retour au début de la liste des fichiers

Le choix du délai s'effectue au moyen des touches haut, bas et sélection

Le nom du fichier, le pourcentage de progression et une barre de progression permettent de savoir instantanément où en est le dessin de l'image et ainsi d'ajuster la vitesse de déplacement du ruban en conséquence.

Le code source complet est disponible sous licence GPLv3 sur mon compte GitHub : https://github.com/skywodd/digital_light_wand

Je vous invite à regarder les commentaires présents dans le code source pour mieux comprendre le principe de fonctionnement du programme. Détailler ici point par point chaque fonction, algorithme et structure de données demanderait plusieurs jours et des centaines de pages de texte…

Je souhaiterai cependant détailler deux points en particulier concernant la gestion des fichiers bitmap et des couleurs.

→ Contrairement aux idées reçues, un fichier Bitmap peut être compressé !

Gérer la décompression nécessiterait l'implémentation de l'algorithme de codage de Huffman , très coûteux en ressources. C'est pourquoi le programme rejettera tout fichier Bitmap compressé. De même afin de faciliter la gestion des couleurs celui-ci rejettera aussi tout fichier Bitmap dont les couleurs ne seraient pas codées sur 24 bits (3 octets).

→ Le contrôleur LPD8806 travaille avec des couleurs codées sur 21 bits, le fichier Bitmap, lui, travaille avec des couleurs codées sur 24 bits !

Deux solutions sont implémentées dans le programme, le choix se fait au moyen d'un #define dans le fichier principal :

Correction linéaire : chaque couleur (R, G, B) est décalée d'un bit vers la droite, cela a pour effet de diviser la valeur de chaque couleur par deux et ainsi passer de 8 bits par couleur (0 ~ 255) à 7 bits par couleur (0 ~ 127) soit 21 bits au total.
Correction gamma : chaque couleur est passée dans une table de correction prenant en entrée une valeur sur 8 bits et générant en sortie une valeur sur 7 bits suivant la courbe de réponse de l’œil humain. C'est cette deuxième solution qui est appliquée par défaut dans le programme, c'est celle-ci qui permet d'avoir un résultat final au plus proche des couleurs voulues.

Remarque : les fichiers Bitmap doivent être retournés de 90° avant d'être copiés sur la carte SD. De même ils ne devront pas dépasser 64 pixels de largeur sinon la partie droite de l'image sera tronquée.

Le résultat ¶

Après toute cette lecture il est grand temps de prendre un peu de repos devant quelques belles photos vous ne trouvez pas ?

Nyancat en light painting.

Logo de Fait Main en light painting.

Comment ouvrir une puce ?

2013-05-01T00:00:00Z

Électronique | Autre Niveau: Insolite Zeptobars Traduction: Tarek Ziadé

Cet article est une traduction adaptée de l'article de Zeptobars originalement paru en anglais & russe à cette adresse .

Les puces électroniques sont des petites boîtes noires. Si elles fonctionnent, aucune raison d'essayer de regarder dedans. Mais comment faire si l'on a envie de regarder dedans ?

Dans cet article, nous expliquons comment ouvrir des puces électroniques et ce qu'on peut trouver à l'intérieur.

Toutes les manipulations de cet article sont faites avec de l'acide chaud et sont extrêmement dangeureuses. Seules des personnes aguerries et habilitées à faire ce genre de manipulations, avec le materiel de protection adéquat (gants anti-acide, lunettes de protection, combinaison, cheminée d'extraction des fumées etc.) peuvent effectuer ces opérations.

Rappelez-vous que vous n'avez que deux yeux.

Cet article est juste informatif, n'essayez pas ces manipulations à la maison.

Ouvrir une puce ¶

Prenez des puces qui vous intéressent et de l'acide sulfurique concentré. Le récipient à utiliser doit être fermé mais pa hermétique, pour laisser les fumées s'échapper - c'est très important.

Chauffez l'acide jusqu'à sa température d'ébulition (300ºC). La matière blanche au fond est du bicarbonate de soude qui est utilisé pour neutraliser les projections accidentelles d'acide et une partie de la fumée.

Le bain d'acide.

Après 30 à 40 minutes, l'acide brûle le plastique en carbone:

Dépôt de carbone en surface.

Une fois le mélange refroidi, nous pouvons trier les éléments qui sont prêts pour la prochaine étape de ceux qui ont encore besoin d'un bain d'acide. Les composants enrobés d'une grosse couche ont en général besoin de trois bains.

Résultat du premier bain.

Si des morcaux de carbones sont coincés dans la puce et ne peuvent être retirés mécaniquement - ils peuvent en général être retirés dans un bain d'acide concentré maintenue à une température plus basse (~110-120 °C).

Nettoyage de résidus.

Regardons de plus prêt ¶

Les images ci-dessous peuvent être cliquées pour afficher une image haute résolution. Attention, les images en haute résolution pèsent entre 5 et 25Mb.

Les couleurs ont été saturées pour mieux visualiser les circuits.

PL2303HX - convertisseur USB <> RS232 converter. Cette puce est un clone des chips FTDI, présents dans les anciens modèles d'Arduino.

LM1117 — Régulateur ldo.

74HC595 - Shift register 8 bits.

NXP-74AHC00D - porte NAND 2 entrées.

Micron MT4C1024 - 1 mebibit (220 bit) de RAM dynamique Très utilisé dans les ordinateurs de la génération 286 et 386 dans les années 90.

AMD Palce16V8h GAL est un tableau AND de 32 x 64. Les puces GAL (Generic array logic) sont des puces reprogrammables, ancêtres des FPGA et CPLD.

ATtiny13A — un des plus petits micro-contrôleurs. Seulement 1kb de mémoire flash et 32 bytes de SRAM.

ATmega8 — un des micro-contrôleurs 8 bit les plus populaires.

KR580IK80A renommé KR580VM80A par la suite - un des microprocesseurs russe les plus répandus.

STM32F100C4T6B, le plus petit micro-contrôleur fabriqué par STMicroelectronics et basé sur un coeur ARM Cortex-M3.

Altera EPM7032 — une CPLD qui a roulé sa bosse.

Puce MIFARE, utilisée dans les carte RFID du métro de Moscou.

Voila. Les boîtes noires sont ouvertes :-)

Quelques livres

2013-05-01T00:00:00Z

Cuisine | Électronique | Informatique Niveau: Decouverte Tarek Ziadé

Voici une petite sélection de livres qui m'ont paru intéressants à lire pour vous en fournir une petite critique. Ils ne sont pas tous en français mais lorsqu'ils sont en anglais, restent très abordables.

Programming Your Home ¶

Mike Riley / Pragmatic Bookshelf

J'ai acheté ce livre au stand O'Reilly pendant le FOSDEM 2013, pour le lire dans l'avion que je prenais le lendemain. En feuilletant rapidement la table des matières, il m'avait paru très bien.

La liste des projets est variée et intéressante. On y parle par exemple d'un détecteur de colis qui envoie un mail lors de l'arrivé d'un colis ou un courrier, un faux chien de garde qui aboie lorsqu'un intrus essaye de pénétrer la maison ou encore une maison interactive qui répond aux ordres oraux via de la synthèse vocale. Programme alléchant.

Seulement voila: je m'attendais pour un livre consacré à de la domotique à un minimum d'information sur les systèmes et protocoles existants dans le domaine. Il y a moins d'une page sur le sujet: l'auteur parle furtivement du protocole X10 dans l'introduction et puis l'utilise dans un projet de lumière pilotée par le web - mais il y a très peu de détails sur le matériel et les usages existants dans la communauté des domoticiens, ce qui est dommage.

Le livre n'est finalement qu'un regroupement de petits projets Arduino qui ne forment pas un ensemble cohérent.

Par exemple, pourquoi ne pas avoir expliqué comment créer une centrale de domotique, puis developpé les petits projets autour de cette centrale ?

Si j'automatise ma maison, je ne vais pas m'amuser à developper plusieurs petits systèmes indépendants. Je vais vouloir centraliser l'ensemble.

L'autre souci est le choix exclusif de la puce radio X-Bee , pour tous les projets sans fils, qui forment la grande majorité du livre. Même si cette puce et son protocole Zigbee (lire notre dossier Xbee ) sont très intéressants, à 20 euros par puce en moyenne, le prix de chaque projet monte très vite.

Pourquoi ne pas avoir aussi exploré des puces radios low-cost en 433 mhz, comme ce que nous a montré Jonathan au numéro précedent ? A moins de faire un projet point-à-point complexe, elles permettent de faire la même chose que les puces X-Bee, pour quelques euros seulement.

Enfin, le projet phare du livre, un système de verrouillage de porte, est complètement tiré par les cheveux. Il faut carrément installer un téléphone Android pour prendre des photos des personnes qui sonnent, pour envoyer une photo via internet et demander à une autre personne de déverouiller à distance. Cette technique n'est évidemment pas très sûre de l'aveu même de l'auteur, qui suggère des pistes dans la conclusion.

Une solution à base de RFID ou un digicode à mot de passe unique auraient été plus réalistes.

Le prix prohibitif du projet est aussi rédhibitoire: pourquoi ne pas avoir opté pour une simple web cam voir une board de type Raspberry-PI (ou une autre board vu que le livre est sorti la même année que le Raspberry).

A vouloir montrer un maximum de techniques et périphériques différents, l'auteur fini par faire quelques projets un peu bizarres.

Je vais arrêter de critiquer ce projet en particulier, vous l'aurez compris le livre m'a un peu déçu.

Quelques points positifs tout de même: ce livre touche à beaucoup de composants et donne de bonnes idées et j'ai bien aimé le volet éléctrique automatique.

Programming Your Home reste une lecture intéressante pour découvrir des techniques d'interaction avec l'environnement, mais vous ne ne construirez pas la maison du futur avec ce livre là.

Cooking For Geeks ¶

Jeff Potter / O'Reilly Media

La première fois que j'ai entendu parler de ce livre, c'est lorsque j'ai vu la vidéo de Jeff Potter en train de faire de la glace avec de l'azote liquide . Il y a même un glacier à San Francisco - Smitten qui vend des glaces faites devant les clients avec de l'azote. Vu que le processus ne prend que quelques secondes, l'eau n'a pas le temps de cristalliser et les fruits frais et la crème fraîche expriment complètement leurs saveurs.

C'est un peu la même idée pour la cuisine sous vide: les aliments sont emballés dans un sac plastique et cuits à basse température pendant des heures. Un steak sera uniformément cuit et ses cellules ne seront pas éclatées par une chaleur excessive.

Pour en revenir au livre, il est tout bonnement incroyable. Il traite de la cuisine comme on peut traiter de la conception logicielle: l'outillage et la préparation de la cuisine sont passés en revue, puis les principes chimiques et physiques sont expliqués: du goût à l'odeur, en passant par les textures, puis la cuisson, la température et les différentes techniques pour enfermer de l'air dans les mousses, pates et autres soufflés.

Ce livre a deux lectures: on peut lire chaque chapitre et apprendre des techniques de cuisine, appuyées par des explications scientifiques - puis tomber de temps à autre sur des recettes d'applications. Ou simplement se rendre à l'index des recettes et en faire une.

J'aurais plus tendance à regarder la liste des recettes et en faire une qui me plaît, puis lire les explications techniques et scientifiques qui l'entourent.

On oublie par contre les recettes basées sur de l'azote liquide car ce n'est pas vraiment à la portée de tous - les précautions de sécurité sont assez drastiques et le matériel très onéreux.

Pour conclure, j'ai trouvé Cooking For Geeks absolument génial.

Photo Culinaire & Gourmande ¶

Philippe Barret / Eyrolles

L'article du numéro 1 sur la photographie culinaire m'a donné envie de pousser un peu plus dans l'exploration de ce domaine.

Les Éditions Eyrolles proposent deux ouvrages dans la photo culinaire: Photo Culinaire de Philippe Barret et Photo Gourmande de Mouni Abdelli.

Deux ouvrages écrits par deux auteurs différents: Philippe Barret est un photographe culinaire professionel et illustre des recettes dans de nombreux ouvrages. Mouni Addelli est quant à elle bloggueuse et photographe amateure. Elle tient le blog Rdv Aux Mignardises .

Les Éditions Eyrolles m'ont gentiment envoyé les deux livres pour que je puisse les étudier et les présenter ici. (je présenterais le livre de Mouni Addelli dans le prochain numéro).

Le livre Photo Culinaire est une belle édition au format 22x24 - un A4 un peu écrasé en quelque sorte, ce qui laisse la part belle aux clichés.

Au niveau du contenu, on retrouve les principes de base de la photographie et un passage en revue du matériel nécessaire, que ce soit le matériel d'éclairage ou les décors et accessoires.

Rassurez vous, il n'y a pas besoin d'un studio onéreux pour faire des photos culinaires - mais pour une bonne maîtrise de la lumière, quelques spots deviennent vite indispensable si vous ne pouvez pas prendre des photos en extérieur.

Le chapitre 2 sur les rappels techniques est très bien fait et détaille les paramètres à prendre en compte lorsque l'on prend des photos culinaire. Une dizaine de pages bien utiles.

Le reste du livre détaille les techniques propres à chaque domaine de la photographie numérique - de la méthode employée pour prendre les photos à la post-production: les photos d'emballage & de catalogue, les photos pour les livres et la photographie avec les chefs.

Cette dernière catégorie est en fait l'art et la manière de photographier des créations de plat. Autant dire que si vous n'avez pas un Paul Bocuse sous la main vous avez le droit de photographier vos propres créations :)

Ce qui m'a le plus intêressé c'est la réalisation des recettes en mode pas à pas et l'ouvrage donne de bonnes indications

Le clou du livre, page 73 - c'est les carottes qui se jettent dans un plat avec un effet d'animation pour le mouvement.

Un petit détail que j'ai trouvé gênant est l'utilisation du bokeh à outrance sur de nombreux clichés. Sur certaines photos, le bokeh qui est utilisé pour mettre en valeur un sujet, floute une partie du sujet lui même et j'ai trouvé ca génant.

Il existe une technique appelée le Focus Stacking pour maîtriser parfaitement la profondeur de champ sur des sujets où l'on souhaite flouter l'arrière plan.

Mais mis à part ce détail, j'ai trouvé l'ouvrage très bien, même pour les photographe avertis: il donne de bonnes idées.

Interview de Sabine Blanc

2013-05-01T00:00:00Z

Autre Niveau: Interview Tarek Ziadé

Open Bidouille Camp #2 - Photo Ophelia Noor CC-BY-NC-ND

Depuis l'an dernier, le mouvement DIY est en train de prendre de l'ampleur dans l'hexagone, et on voit de plus en plus d'évènements organisés autour de ces sujets, que ce soit dans les locaux de FabLabs ou dans le cadre de conférences, hack days ou petits ateliers.

La tout réçente association Open Bidouille Camp (OBC) organise depuis quelques temps des ateliers de bidouilles et commence à construire un réseau de bidouilleurs partout en France.

Sabine Blanc est l'une des principales porteuses du projet OBC , et aussi l'instiguatrice de Hack The Press , Les hackers dans la cité arabe (en stand-by), et co-auteure de Hackers : Bâtisseurs depuis 1959 .

Les lecteurs de FaitMain lui ont posé quelques questions, sur son parcours, ses projets et pleins d'autres sujets.

Quel est ton parcours/ta formation initiale ?

DEA de littérature comparée puis une école de journalisme, une caricature de l'école française... Passés le collège et la fin des cours d'arts plastiques, que des rédactions d'imagination: "tout est dans la tête rien dans les mains". Bref un assèchement de la créativité.

D'où peut-être ma fascination pour le DIY et les hackers.

Quelques mots sur ton expérience 'OWNI' ?

Erf, il est trop tôt pour faire le bilan, c'est encore trop frais et douloureux, les derniers mois ont été vraiment très durs humainement, en plus de la charge de travail.

Juste une certitude : les idées de sujet ne me manquent pas mais j'ai un sentiment de manque, dans le paysage médiatique français, on occupait un créneau laissé vide, celui d'un traitement magazine, sous l'angle de l'impact sociétale et politique au sens large du terme, du numérique.

"Hack The Press" c'est quoi ?

Il s'agissait de joutes amicales entre équipes pluridisciplinaires journalistes-développeurs-designers, sur le principe de hacks/hackers.

Owni a lancé l'initiative en octobre 2011, il y a eu une deuxième édition en janvier de l'année dernière. Un blog dédié rassemble les archives sur ces événements.

Les deux premiers OBC ont eu l'air de remporter un franc succès, c'est quoi la suite ?

Effectivement, on a été débordé par le succès du premier OBC, fin septembre à Mains d'Oeuvres à Saint-Ouen. Dès ce jour, des gens nous ont demandé "alors c'est quand le prochain ?".

Brest s'est lancé très vite dans la foulée, en Novembre.

Nous avons donc créé une association loi 1901 pour continuer d'organiser des OBC, entre autres, dans le respect des valeurs initiales : gratuité, partage, amusement... Une charte est d'ailleurs en cours d'élaboration et ouverte à tous les commentaires pour la patcher.

La bidouille comme vecteur d'émancipation / quel rapport à l'éducation ?

La bidouille permet une approche par la pratique plutôt que par la théorie de la connaissance, ce qui va à rebours du système éducatif traditionnel. Elle donne aussi sa place à l'erreur, le fameux "learning by failing". Telle qu'elle se développe depuis quelques années grâce à Internet, elle met aussi en avant des pratiques de partage et de collaboration, de pair à pair. C'est bien sûr un levier d'émancipation potentiel dans la mesure où elle nous incite à soulever des capots qui sont de plus en plus fermés, que ce soit celui de la voiture ou de nos iPad.

J'avais écrit un article plus fouillé sur le sujet http://owni.fr/2011/08/26/hackons-lecole/ et c'était l'objet de la table ronde d'OBC 2 qui a été documentée ici : http://unishared.com/notes/1V6acrSNk0dFHcYo-0DHSZd551LG3Dd6-ys4tLZTtn9E

"Les hackers dans la cité arabe" - encore un autre projet qui se lance - peux-tu nous en parler un peu ?

C'est un projet qui est malheureusement en stand by, après avoir déjà visité trois pays, la Tunisie, l'Algérie et l'Egypte.

Avec Ophelia Noor, photoreporter qui travaillait aussi à Owni, nous sommes allées à la rencontre de ces communautés naissantes, nous avons quand même publié une partie de nos recherches sur un blog. https://leshackersdanslacitearabe.wordpress.com/

Sabine Blanc (à gauche) et Anne-Sophie Novel (à droite) - Photo Ophelia Noor CC-BY-NC-ND

Quelle est la place du hacking dans la société ? Quelles évolutions peuvent apporter le hacking à la société?

Je pense que l'apport le plus fort du hacking à la société, par-delà les apports tangibles, c'est une aspiration irréductible à la liberté, qui était déjà dans l'ADN des premiers hackers du MIT quand ils crochetaient les portes des pièces abritant les ordis. C'est la marque des hackers purs et durs, ceux qui considèrent le hacking comme une philosophie de vie, un type comme Mitch Altman .

Au Caire aussi on a rencontré un gars comme ça, Tarek Ahmed le co-fondateur du Cairo hackerspace . Pour lui hacker, c'est trouver sa voie, et il le fait dans tous les sens du terme en allant sauter d'immeuble en immeuble. Du coup, il nous renvoie à notre propre tiédeur, une certaine attirance pour les petites cases plus ou moins préformatées, c'est très subversif, à fortiori dans des régimes autoritaires comme l'Egypte.

Et ça laisse comme un vertige : et si j'avais moi aussi la force de suivre mon chemin...

Le hacking devrait-il être une matière enseignée à l'école pour apprendre à réfléchir, faire des choses soi même, etc. ?

Le système peut-il enseigner la façon de le déconstruire ? Dubito. L'Éducation Nationale reflète grosso modo la société, et les valeurs du hacking vont à l'encontre dans l'ensemble.

Et le hacking ne devrait pas être une matière à part entière mais une démarche guidant les modes d'apprentissage, quelle que soit la matière. Bon après, je ne suis pas sûre qu'elle soit applicable tout le temps : je me suis enquiquinée à apprendre la grammaire allemande, il fallait bien en passer par là, le côté « on apprend uniquement en s'amusant » a des limites.

Le hacking & la bidouille devraient -ils avoir une place centrale dans des décheteries/ressourceries ? Pour faire société, doit-on faire lobby (douille) ?

Je pense qu'il l'a déjà de facto : quand tu récupères une vieille chaise pour la retaper, une carcasse d'ordi pour récupérer des composants, c'est de la bidouille. Après, ça pourrait être utile de faire des ateliers récup' dans les déchetteries municipales. Ca existe d'ailleurs déjà peut-être, je connais de loin cet univers.

Hacker nourrit-il son homme ? Ou comment est-ce qu'on hacke ses finances personnelles pour réussir à hacker et manger ? Quels modèles économiques ?

Hé hé, j'aimerais bien faire un livre sur l'économie du hack. Je suis assez pessimiste : Apple a fini comme on le sait, MakerBot suit le même chemin. En ce qui concerne le logiciel libre/open source (han je vais me faire taper sur les doigts par les puristes), les business models sont connus : développer des programmes sur mesure, faire du support.

Mais l'économie du logiciel libre ne fait pas le poids par rapport au logiciel propriétaire, loin de là. Après, on peut/doit aussi remettre en question la notion d'économie pour ne pas considérer uniquement le CA généré mais l'apport à la société, de même qu'il est important de mesurer celui du tissu associatif par exemple. Quand une personne utilise des outils gratuits au lieu de payer une licence par exemple.

Dans les pays arabes que j'ai visités, qui sont plus pauvres que nous, les logiciels propriétaires sont hors de prix, ils sont donc obligés d'utiliser des versions crackées pleines de virus. Heureusement, la communauté du logiciel libre est en plein développement et constitue une bonne alternative légale et plus sûre.

Et si hacker ne nourrit pas son homme, ça permet de faire des économies en amenant à davantage réparer, récupérer et bidouiller pour le plaisir, au lieu d'aller acheter des saloperies toutes prêtes.

Dates à retenir ¶

Dates des prochains OBC :

Lille 22 et 23 juin à Saint-Sauveur dans le cadre de la Fête de l'Environnement et des Solidarités.
Brest les 17 et 18 mai puis probablement le 12 octobre pendant Brest en Biens Communs et la fête de la science.
Île de France le 6 juillet - Le lieu reste encore à déterminer.

Sérigraphie sur textile

2013-05-01T00:00:00Z

Art Niveau: Decouverte Amina El Kamel

Cet article explique les techniques de base de la sérigraphie, qui vont nous permettre de réaliser une jolie impression monochrome sur un T-shirt.

En France le matériel reste difficile à trouver et cher. Je m'équipe chez a.buisine , et pour ceux qui ne veulent pas de grosse quantité, whe vend des packs pour débutant.

La sérigraphie se passe en trois temps:

Enduction
Insolation
Impression

1. Enduction ¶

L'écran est enduit avec une émulsion photosensible, c'est ce produit qui après séchage et insolation deviendra le pochoir de notre T-shirt.

Nettoyer, l'écran avec un dégraissant ménager, rincer, laisser sécher.

Nettoyage de l'écran

Pour l'enduction, il faut une racle à enduction et de l'émulsion photo-sensible. Mettre le produit dans la racle, ne pas avoir peur d'en mettre trop, on pourra remettre le surplus dans le pot.


Matériel	Étalage de l'enduction.

Tenir l'écran verticalement et faire glisser la racle contre l'écran pour déposer l'émulsion, 2 fois chaque côté : une fois a l'extérieur, une fois à l'intérieur et recommencer, toujours finir par l'intérieur pour pousser l'émulsion sur la partie extérieure. Laisser sécher à plat sur 2 cales, face extérieur vers le bas à l'abri de la lumière, pendant au moins une journée, mais cela peut varier d'une sorte d'émulsion à l'autre. Bien nettoyer les outils juste après, et conserver le pot d'émulsion au frigo, il se gardera plus longtemps.

2. Insolation ¶

Sous l'action de la lumière, l'émulsion durcit, les parties masquées, elles, se disolvent sous l'eau. Et voilà comment on obtient un joli pochoir!

Préparation pochoir.

Imprimer le dessin à l'encre noire sur un transparent ou dessiner directement dessus avec un feutre adéquat, le transparent servira de typon.

Installer une vitre à 1m20 du sol et poser 2 halogènes de chantier.

Poser le typon sur la vitre et caler l'écran dessus, couvrir avec un objet qui coupe la lumière de la taille de l'écran, il faut qu'il soit noir pour éviter les reflets. Poser un poids dessus et allumer les halogènes. Laisser 18 minutes en moyenne.

Flashage.

Rincer à l'eau des deux côtés, l'émulsion part aux endroits où se trouvait le dessin. Laisser sécher à la lumière.

Rinçage.

3. Impression ¶

L'encre pour textile est étalée sur l'écran avec une racle, puis poussée à travers les mailles de l'écran aux endroits où il n'y a pas d'émulsion.

Mis en place du cadre.

Vous pouvez utiliser une presse à sérigraphie pour les T-shirts, j'utilise la presse print box de whe . Mais il est possible de faire sans.

Placement de l'encre.

Coller le T-shirt à la table ou à la jeannette avec de la colle repositionnable. Pour le moment, l'écran ne doit pas être en contact avec le T-shirt. Etaler l'encre à la spatule sur le haut de l'écran. Avec une racle étaler l'encre sur tout le dessin.

Étalage de l'encre.

Poser l'écran sur le T-Shirt, repasser la racle sur tout le dessin pour faire passer l'encre à travers le pochoir.

Séchage de l'encre.

L'encre est maintenant sur le T-Shirt, il faut la faire sécher avec un décapeur thermique, sécher pendant 3 minutes en faisant des petits ronds comme avec un sèche cheveux.

Résultat final.

Et voilà, le beau T-Shirt.

Station météo USB

2013-05-01T00:00:00Z

Électronique | Informatique | Ecologie Niveau: Vulgarisation, moyen Tarek Ziadé

Surveillance de mon Jardin avec Yocto-Meteo & Raspberry-Pi

Article élaboré en partenariat avec Yoctopuce. Voir la page partenariats pour plus de détails.

Après la sortie du premier numéro de FaitMain, j'ai été contacté par Yoctopuce qui m'a proposé de tester son matériel dans un article.

Ca tombait plutôt bien puisque dans la (volumineuse) pile des projets en attente de réalisation il y a la conception d'une station météo.

Publier les courbes de température, pression atmosphérique et humidité de mon jardin en Bourgogne, ne va intéresser que ma mère qui vient de temps en temps jardiner chez moi. Mais d'un point de vue réalisation technique c'est un projet intéressant à conçevoir, surtout du coté logiciel.

Cet article ne va pas trop s'attarder sur le coté hardware et va surtout vous expliquer comment on peut traiter et visualiser un stream continu de données.

Station météo ¶

Une station météo est composée d'une ensemble de senseurs qui relèvent des informations comme la température, la pression atmosphérique ou encore l'humidité, et les transmettent à un afficheur ou à un autre périphérique de traitement.

Les stations météos vendues dans le commerce sont en générale des boîtes noires. Pour les plus basiques, elles affichent sur un écran LCD les informations des senseurs.

Les stations un peu plus haut de gamme conservent un historique des données ou proposent un afficheur sans fil déporté, mais on grimpe très vite dans les prix.

Et il faut compter 2000 euros pour les stations haut de gamme comme la station Capricorn 2000EX qui à défaut de faire le café, possède les senseurs de base ainsi qu'un pluviomètre et un anénomètre.

Station Capricorn 2000EX - Columbia Weather System

Les stations haut de gamme sont par contre communicantes, et donc programmables, que ce soit par USB, Wifi ou tout autre moyen de communication que le fabricant a fourni.

Le gros intérêt de communiquer avec une station est de pouvoir conçevoir sa propre application avec les données collectées ou de les transmettre à une application existante.

Un exemple très intéressant est le projet Wunderground qui centralise toutes les informations envoyées par des particuliers pour fournir une carte météo assez précise.

Wunderground reste un projet commercial, et je n'ai pas trouvé de projet libre basé sur un protocole ouvert (je cherche encore..) c'est dommage

Les stations du commerce de toute façon sont en général basées sur des protocoles et/ou des logiciels propriétaires. Quand on connaît le prix des senseurs seuls, c'est assez rageant.

RHT03 - Senseur humidité + température (Sparkfun, $9.95)

Dans l'idéal, on peut fabriquer soi-même sa station météo complète en achetant les senseurs séparément et en fabriquant une board connectée à un Arduino ou un Raspberry-Pi.

En feuilletant le catalogue Sparkfun, on trouve tous les senseurs nécessaires montés sur des petites breakout boards, comme le MPL3115A2 qui permet une interaction en I2C avec un Arduino. Ou encore la puce RHT03 qui fournit une interface digitale basique.

Ces puces ne sont pas chères mais nécessitent pas mal de travail d'intégration pour construire sa station météo.

Les puces Yoctopuce ¶

Les puces Yoctopuce sont un bon compromis entre les stations clef-en-main et les senseurs de base: ce sont de petites boards USB plug'n'play qui peuvent être pilotées très simplement depuis n'importe quel ordinateur.

Aucun driver n'est nécessaire, et le fabriquant fournit une librairie dans plusieurs languages et une documentation exhaustive des API.

Le code source des librairies est livré sous une license BSD-like avec une restriction sur une utilisation exclusive sur le matériel Yoctopuce. Le firmware est quant à lui propriétaire.

La puce Yocto-Meteo fournit les trois senseurs de base qui nous intéressent, à savoir la température, l'humidité et la pression.

Les puce Yocto-Meteo, Yocto-Light & le mini-hub USB

Les valeurs de pression fournies sont relatives au niveau de la mer. Elles doivent donc être ajustées en fonction de l'altitude à laquelle on se trouve. Il faut donc connaître son altitude, ce qui n'est pas forcément toujours évident.

Une solution élégante consiste à géolocaliser la station météo via internet et retrouver l'altitude via des bases de données de géolocalisation open source. Mais laissons ce problème de côté pour l'instant.

Après quelques échanges avec la sympathique équipe suisse de Yoctopuce, je les ais convaincus en bon Pythonneur qu'il fallait absolument que la librairie soit accessible sur le Python Package Index (PyPI) pour que les projets Python autour de ce matériel puissent très facilement installer la librairie dans l'environnement d'exécution.

C'est chose faite et installer la librairie Python est aussi simple que:

$ pip install yoctopuce

Pip est l'outil standard pour installer des extensions Python.

Une fois la puce branchée, sur le port USB, la lecture des données est très simple.

Voici un script en Python, inspiré de l'exemple fourni par Yoctopuce:

# -* encoding: utf8 -*-
#
import time

from yoctopuce.yocto_api import YAPI, YModule, YRefParam
from yoctopuce.yocto_humidity import YHumidity
from yoctopuce.yocto_temperature import YTemperature
from yoctopuce.yocto_pressure import YPressure

TURCEY = 374.


def convert_pressure(value, altitude=TURCEY):
    return value + 1013.25 * (1 - (((288.15 - 0.0065 * altitude) / 288.15) ** 5.255))


def format_value(sensor):
    value = sensor.get_currentValue()
    name = sensor.get_friendlyName()

    if isinstance(sensor, YHumidity):
        return name, value, u'%.2f %%' % value
    elif isinstance(sensor, YPressure):
        value = convert_pressure(value)
        return name, value, u'%4.0f mb' % value
    else:
        return name, value, u'%2.1f ºC' % value


def get_info():
    errmsg = YRefParam()

    if YAPI.RegisterHub("usb", errmsg) != YAPI.SUCCESS:
        raise IOError("init error" + errmsg.value)

    sensor = YHumidity.FirstHumidity()
    if sensor is None:
        raise IOError('No module connected')

    module = sensor.get_module()
    target = module.get_serialNumber()

    sensors = [YHumidity.FindHumidity(target+'.humidity'),
               YPressure.FindPressure(target+'.pressure'),
               YTemperature.FindTemperature(target+'.temperature')]


    while True:
        if not module.isOnline():
            raise IOError('Device not connected')

        for sensor in sensors:
            name, value, formatted = format_value(sensor)
            print '%s %s' % (name, formatted)

        time.sleep(5.)


if __name__ == '__main__':
    get_info()

Et l'exécution donne:

$ bin/python test.py
METEOMK1-0A918.humidity 47.00 %
METEOMK1-0A918.pressure 1096 mb
METEOMK1-0A918.temperature 15.8 ºC

Le script paraît compliqué à premier abord car j'ai ajouté des fonctionnalités d'affichage dans format_value() et quelques autres automatismes en vue de son intégration dans le projet.

Mais le coeur de la fonctionnalité est simple: une board Yoctopuce est définie par un objet module qui possède un numéro de série correspondant à celui du matériel.

Une fois ce numéro obtenu, METEOMK1-0A918 dans mon cas, les API Yoctopuce fournissent des classes pour récupérer la valeur en cours du senseur:

humidity = YHumidity.FindHumidity('METEOMK1-0A918.humidity')
print humidity.get_currentValue()

pressure = YPressure.FindPressure('METEOMK1-0A918.pressure')
print pressure.get_currentValue()

temperature = YTemperature.FindTemperature('METEOMK1-0A918.temperature')
print temperature.get_currentValue()

Enfin, pour corriger la valeur de la pression, il convient d'appliquer la formule du nivellement barométrique sur la valeur renvoyée par la sonde.

Traduite en Python, la formule donne:

TURCEY = 374.

def convert_pressure(value, altitude=TURCEY):
    return value + 1013.25 * (1 - (((288.15 - 0.0065 * altitude) / 288.15) ** 5.255))

Ma maison est à 374 mètres au dessus du niveau de l'eau.

Le projet Grenouille ¶

Ce n'est pas un nom très original mais je n'ai pas trouvé mieux. Le projet Grenouille utilise la sonde Yocto-Meteo pour remplir une base de données qui sert ensuite à afficher les informations dans des séries temporelles.

Pour la base de données, j'ai choisi Elastic Search .

Elastic Search est un service de recherche au dessus de Apache Lucene qui permet d'indexer des données en continu et qui fournit une interface REST pour faire des recherches,

Les performances d'Elastic Search sont assez bluffantes. Ce système est par exemple utilisé par FourSquare pour son moteur de recherche de lieux qui compte plus de 50 millions d'entrées.

Ce qui est intéressant pour un projet comme Grenouille est qu'Elastic Search permet de faire des recherches par facettes . Les facettes permettent de faire des recherches puis d'aggréger les occurences de résultats en fonction d'un ou plusieurs champs pour avoir par exemple une moyenne. Dans notre cas par minute, heure, jour, semaine, mois ou année. Cette fonctionnalité est un peu équivalente à un SELECT AVG(TEMPERATURE) GROUP BY HOUR en sql.

En stockant continuellement les relevés de température, pression et humidité dans cette base, il devient donc possible de faire des requêtes pour récupérer toute sorte de séries temporelles .

Elastic Search offre aussi le support de CORS (Cross-origin resource sharing) qui permet de construire une application Javascript qui va faire directement des requêtes sur le moteur même si ce dernier n'est pas déployé sur le même nom de domaine.

L'interface web de Grenouille n'est donc pas une application web qui s'exécute coté serveur, mais du code Javascript qui se charge dans le naviguateur et interagit avec ElasticSearch.

Pour l'affichage, Grenouille utilise RickShaw qui est une librairie Javascript spécialisée dans l'affichage de séries temporelles.

RickShaw est elle-même basée sur d3.js un moteur de visualisation de données qui est beaucoup utilisé dans la communauté open source.

Rickshaw en action

Pour résumer, RickShaw permet de faire de jolis diagrammes en temps réel sans difficultés.

Fonctionnement de Grenouille ¶

Grenouille est organisé en deux parties:

un script Python qui interroge la sonde et qui indexe le résultat dans ElastiSearch.
Une application Javascript qui interroge ElasticSearch et affiche les informations.

Organisation de Grenouille

La partie indexation du script Python est basée sur la librairie pyelasticsearch qui permet d'indexer très simplement n'importe quel dictionnaire de données Python.

Le code d'indexation ressemble à cet extrait:

from pyelasticsearch import ElasticSearch
import datetime

data = {'date': datetime.now(),
        'humidity': 45,
        'pressure': 1080,
        'temperature': 17.3}

server = ElasticSearch('http://0.0.0.0:9901')
server.index('weather', 'sensor', data)

Ce code est appelé toute les 15 minutes.

La partie affichage est quant à elle un peu plus complexe, je ne vais pas la détailler ici.

La partie la plus intéressante est la fonction qui envoie une requête au serveur ElasticSearch, En voici un extrait qui permet d'afficher la temperature par heure pour le 1 et 2 mai 2013:

 // construction de la requête
[...]

 var match = {'match_all': {}};
 var query = {"query": match,
     "facets": {
         "facet_histo" : {"date_histogram" : {
             "key_field" : "date",
             "value_field": "temperature",
             "interval": "hour"},
             "facet_filter": {
                       "range": {"date": {"gte": "2013/05/01",
                                          "lte": "2013/05/02"}
                       }
             }
         }
     },
     "sort": [{"date": {"order" : "asc"}}],
     "size": 0
 };

 // appel asynchrone
 query = JSON.stringify(query);
 this._async(query);

[...]
// recuperation des resultats et affichage
_async_receive: function(json, chart, fields) {
   var name;
   var data = [];
   var series = chart.series;

   $.each(json.facets.facet_histo.entries, function(i, item) {
     var date = new Date(item.time);
     var hour = date.getHours();
     var mean = Number((item.mean).toFixed(2));
     var line = {x: item.time / 1000, y: mean, hour: hour};
     data.push(line);
   });

   data.sort(sortbyx);
   console.log(data);
   series[0].data = data;
   chart.render();
 }

Raspberry-PI ¶

Passer tout le système sur le Raspberry-Pi est très simple. Je l'ai configuré comme pour le projet de JukeBox du mois dernier, puis j'ai installé Java.

Oracle fourni une version spéciale embarqué et un guide d'installation.

Un peu refroidi par le besoin de donner mes infos personnelles pour récupérer le logiciel, j'ai décidé d'utiliser le paquet OpenJDK disponible dans les repositories de Raspbian. OpenJDK fait tourner ElasticSearch sans erreurs, mais il est un peu plus lent.

Enfin, j'ai déployé un server NGinx qui se contente d'afficher la page html statique qui contient les diagrammes Javascript.

Pour le reste de l'installation je fournis un Makefile dans le code de Grenouille qui s'occupe d'installer ElasticSearch et toutes les dépendances Python.

Extraits:

build: $(PYTHON) elasticsearch
       $(PYTHON) setup.py develop

elasticsearch:
    curl -C - --progress-bar http://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-$(ES_VERSION).tar.gz | tar -zx
    mv elasticsearch-$(ES_VERSION) elasticsearch
    chmod a+x elasticsearch/bin/elasticsearch
    mv elasticsearch/config/elasticsearch.yml elasticsearch/config/elasticsearch.in.yml
    cp elasticsearch.yml elasticsearch/config/elasticsearch.yml

Une fois ElasticSearch et le script Python lancé sur le Raspberry-Pi, les diagrammes vont commencer à se remplir.

Grenouilles en action

Et voila une première version d'une station météo tournant sur un Raspberry-Pi!

Tout le code source décrit dans cet article est disponible ici: https://github.com/tarekziade/grenouille

La fonctionnalité que je n'ai pas encore ajoutée pour rendre le code plus générique est la récupération automatique de l'altitude en fonction de l'addresse IP , en utilisant une base de données de Géolocalisation.

Il en existe plusieurs, la plus connue étant celle de MaxMind .

Limites & Evolutions ¶

Le principal problème d'une station météo basé sur un Raspberry-PI et la Yocto-Meteo est la consommation d'énergie. L'USB est un port très gourmand en énergie et en branchant mon système complet sur une batterie lithium 3.7v en 6000 mAh et un panneau solaire censé charger la batterie la journée pour qu'elle tienne le coup toute la nuit - je n'ai tenu que quelques heures...

Les puces Yoctopuce peuvent être coupées en deux afin de déporter les sondes du port USB de quelques dizaines, voir centaines de mètre, mais ça n'enlève pas la dépendance à une source d'énergie fixe.

Une évolution possible pour limiter la consommation serait de déporter la base ElasticSearch sur un ordinateur dans la maison ou sur internet, et de suspendre les ports USB pour ne les utiliser que toutes les 15 minutes pour la récupération des valeurs.

Jonathan a écrit un article très intéressant à ce sujet dans ce numéro: Passer un projet sur batterie

Pour ma station météo, je reste quand même sur l'objectif de créér un système autonome en énergie, qui puisse être interrogé sans fil - donc la prochaine version de la station sera peut être réalisée avec du matériel plus low-level. Donc peut être un Arduino, une puce radio 433mhz et une base déportée...

Dans tout les cas, pour une application indoor ou proche de la maison, cette board est très simple à mettre en oeuvre et parfaite pour mettre rapidement en place un projet sans avoir à jouer du fer à souder.

Surveillance de digues

2013-05-01T00:00:00Z

Écologie | Informatique | Électronique Niveau: Découverte Fritz van Deventer Traduction: Tarek Ziadé

Article conçu en Anglais pour Fait Main par Fritz van Deventer, ingénieur chez Nelen & Schuurmans, et traduit librement par Tarek Ziadé.

En Hollande, la sécurité relative au niveau de l'eau est probablement un des problèmes majeurs auquel le pays doit faire face. En effet, 26% du pays est en dessous du niveau de la mer, et cette surface hébèrge 60% de la population.

Ce problème est devenu un problème de sécurité national.

source: http://www.ijkdijk.nl/nl/livedijken/livedijk-utrecht

Les digues sont les principales protections du pays contre l'eau.

En 2013, mon entreprise Nelen & Schuurmans et l'association Ijkdijk (qui signifie Digue de calibration en Hollandais) ont collaboré pour mettre au point un système de surveillance automatisé.

L'objectif est de rendre les digues communicantes.

Description du système ¶

Une digue témoin a été construite par l'association IJkdijk et a été submergée volontairement pour qu'elle cède sous la pression de l'eau.

Cette simulation a permis de récolter des mesures qui ont servi de calibration pour mettre au point un système d'alerte qui est capable de prévenir qu'une digue va céder bien avant que l'incident ne se produise.

source: http://www.ijkdijk.nl/en/experiments/macrostability

L'objectif est d'équiper toutes les digues du pays avec des senseurs et de récolter en continu et en temps réel les informations. Au jour d'aujourd'hui, nous avons quatre digues déployées en production en plus de la digue de test.

IJkdijk a placé dans chaque digue une multitudes de senseurs différents: température, taux d'humidité du sol, acidité du sol, etc. Ces senseurs sont gérés par le le Centre de données des digues ou DDSC et vous trouverez plus de détails techniques sur leur site web: http://www.ijkdijk.nl/en

Fibres de mesure de l'humidité du sol.

Mais ce système pose un défi en terme de passage à l'échelle. Chaque digue produit une quantité astronomique de données à traiter.

A Nelen & Schuurmans nous avons tenté de résoudre partiellement ce problème. Avec le DDSC , nous avons construit un système pour stocker et afficher toutes les données provenants des senseurs.

Nos serveurs de traitement peuvent réceptionner les données par plusieurs moyens: un classique serveur FTP, un serveur TCP avec des connections persistentes, ou encore via des importations de fichiers XML. Pour résumer, nous acceptons toutes formes de transport en fonction des contraintes, du moment que nous recevons des valeurs avec des timestamps .

Récupération des donées

Les données sont réceptionées et traitées via RabbitMQ puis stockées dans un cluster Cassandra et nous utilisons une base de données PostGIS pour mettre en cache les dernières valeurs reçues pour chaque digue.

Nous fournissons ensuite des services web REST que nous avons construit avec Python et Django .

Utiliser Django pour des services web n'est peut être pas le meilleur choix, mais comme ce framework est maîtrisé et apprécié par tout le monde dans ce projet, nous sommes restés avec.

Comme nos API dépendent beaucoup de Django, nous avons aussi opté pour django-haystack combiné avec Apache Solr pour offrir un moteur de recherche.

Interface Web ¶

Notre interface web récupère les données avec les API Rest de l'application Django - et le plus gros travail consistait à trouver une bonne représentation visuelle des données.

Réussir à synthétiser des millions de chiffres pour en faire une information utile et simple n'a pas été une mince affaire, vu que les données sont étalées dans le temps et l'espace.

Nous avons opté pour les visualisations suivantes:

Avertissements en cas de dépassement de seuils
Diagrammes temporels et cartes
Recherche dans les données via Solr.

Les diagrammes temporels avaient le potentiel de devenir très denses, étant donnée la quantité d'information pour chaque fenêtre de temps.

Nous avons utilisé l'algorithme de Douglas-Peucker pour simplifier les courbes sur des écrans basses résolutions. Le code du client envoit sa résolution et la fenêtre de temps souhaitée au serveur, qui lui retourne une liste de point à afficher.

Ramer-Douglas-Peucker (source: Wikipedia)

L'affichage de la carte a été complexe a mettre au point à cause de la concentration de différents senseurs sur chaque digue.

Comment les classifier ? Comment réussir à naviguer sur cette carte en comprenant ce qu'il s'y passe ?

Nous avons décidé de différencier les utilisateurs techniques et non-techniques qui utilisent l'interface. La carte a des modes d'affichages prédéfinis en fonction de l'utilisateur connecté.

Certains modes prédéfinis offrent même un affichage carte/diagramme qui permet de faciliter certaines lectures et interprétations.

Le client web a été écrit avec Backbone.js et l'extension Marionette.js

Ces outils ont été une découverte pour notre équipe puisque nous avions l'habitude de faire tout le templating et le rendu des pages coté serveur jusqu'ici.

Mais ce projet était l'occasion d'apprendre et de capitaliser sur ces nouvelles techniques. Les appels asynchrones en JSON et l'architecture MVC de Backbone.js nous ont vraiment beaucoup aidé, en particulier sur toutes les vues d'affichage de séries temporelles.

Malgré tout, le débat sur ce qui appartient au coté client et ce qui doit rester coté serveur fait encore rage dans notre équipe et est loin d'être terminé. Surtout que Backbone est un framework très verbeux.

Peut être qu' Angular.js aurait été un choix plus judicieux.

Conclusion ¶

Nous sommes toujours en train de chercher la solution la plus simple pour l'affichage de données temps réel dans une application web - que ce soit pour nos utilisateurs techniques ou non techniques.

Mais nous avons déjà fait de grandes avancées:

l'introduction de diagrammes prédéfinis au lieu du chaos que peut représenter un "Nous voulons un Excel dans notre navigateur" ;
l'introduction de Douglas-Peucker qui nous a permis de limiter le nombre de points à afficher au nombre de pixels disponibles sur l'écran;
n'afficher que l'information nécessaire.

Retrouvez des informations sur ces projets à http://github.com/ddsc et http://dijkdata.nl Tout notre code est sous la licence MIT .

Vous pouvez aussi regarder une vidéo qui montre la digue de tests en action .

Table basse pliante

2013-05-01T00:00:00Z

Bricolage Niveau: Vulgarisation Christophe Seyve

Introduction : une table basse escamotable ¶

J'avais pour idée de faire une petite table basse pliante, en table d'appoint pour prendre l'apéro, faire manger les enfants, ... le tout avec des matériaux de récupération, glanés dans les rues le mardi soir, veille du ramassage des encombrants dans mon quartier.

Dans mon idée, une fois pliée, la table devait pouvoir être glissée derrière le canapé, donc avoir un plateau désolidarisable des pieds, et les pieds "compactables". De fait, le casse-tête était comment avoir des pieds à la fois stables, une structure pliable et qu'elle soit un minimum design.

Les matériaux et le matériel ¶

En mode "DIY" (Do-It-Yourself, Fais-Le-Toi-Même pour les non anglophones) donc, de A à Z, de la conception à la réalisation. Avec une contrainte importante : je n'avais comme "outils électroportatifs" qu'une perceuse et une scie-sauteuse. J'ai complété par une ponceuse excentrique quand j'ai découvert l'ampleur du travail de ponçage à faire sur le plateau trouvé dans la rue...

L'idée était d'utiliser des grosses lattes de sommier pour lit simple, trouvées dans la rue. Chacune mesurait 800 x 69 x 18 mm.

Et un plateau trouvé dans la rue, de dimensions 75x60 cm.

A compléter par des petites fournitures : vis, équerres, ... vernis.

Le concept ¶

C'est en feuilletant un magazine de mobilier design que le déclic est venu : faire rejoindre les pieds au centre, formant la grande barre d'un "y", la petite assurant le support du plateau. Un arc-boutant en bois.

De l'idée au schéma initial

Ce qui avec une configuration à 4 pieds donnera ça :

Résultat final

Et du coup, on peut avoir un axe diagonal avec deux pieds opposés fixés entre eux, et les deux autres qui se rabattent vers les deux fixes pour les ranger.

Deux pieds formant l'axe central + 2 pieds pivotants

Vu que le plateau est amovible, et et que deux pieds pivotent, il faut solidariser le tout quand la table est en place, sinon le plateau peut glisser et les pieds se refermer. Et c'est la cata.

La solution consiste à faire des trous dans les pieds : un sur chaque pied pivotant, et deux sur les pieds fixes, au centre, puis à mettre des têtes de vis dépassant sous le plateau. Les têtes viennent s'encastrer dans les trous des pieds : le plateau ne peut plus glisser, et les pieds ne peuvent plus pivoter.

Les têtes de vis à aligner avec les trous des pieds

Pas la peine d'en mettre sur les contre-forts, cela ne ferait qu'ajouter des contraintes à l'ensemble.

Y'a plus qu'à remonter ses manches...

La réalisation ¶

Matériel et matériaux ¶

Donc au final, on a besoin de :

Matériel : une scie (-sauteuse pour ma part, mais manuelle ou circulaire doivent marcher de même, voire mieux), une perceuse et des mèches de 3, 8 et 10mm, une ponceuse, papier de verre, paille de fer, et pinceau pour vernir.
Matériaux : 4 lattes de sommier de 80cm, 4 petites équerres, des vis (auto-taraudeuses pour éviter de prépercer) de 20mm, 40mm et 75mm, et en fonction du plateau : vernis, huile ou vitrificateur.

Séparer les planches ¶

Les planches étaient fixées à deux rubans de tissus par des agrafes, donc à enlever avec un tournevis plat, et de la patience. Les agrafes et l'opération ont tendance à marquer le bois, donc il faut faire attention.

Les découpes ¶

La coupe en 'y' permet de réutiliser le bout coupé, quel que soit l'angle de coupe. Après quelques mesures, il fallait que j'utilise un angle de près de 45 degrés pour avoir une table suffisamment haute pour l'usage. 45°, ça tombe bien, c'est plus facile à mesurer !

Et donc voici les découpes :

Découpe pour les 2 pieds fixes

Découpe pour les 2 pieds pivotants

Assemblage ¶

Fixation des contre-forts

Difficile de percer droit sans perceuse à colonne, donc pour fixer le petit bras du 'y' sur le grand, un pré-trou petit (3mm) puis un plus large (diamètre de la tête de vis) qui le rejoint depuis l'autre côté. Puis des chevilles pour l'empêcher de pivoter. Au final, je n'ai pas trouvé de cheville de récup', mais ça tient bien quand même comme ça !

Pré-trous.

Assemblage.

Axe diagonal = pieds fixes

Pour fixer les deux pieds de l'axe fixe diagonal, j'ai réutilisé une chute, en découpant un petit morceau triangulaire, dans lequel j'ai mis deux vis de part et d'autre (traits noirs) pour figer le bas. Elles sont complétées par une troisième vis plus longue passée par le côté.

Bidouille mais assez esthétique finalement.

Pivots des pieds mobiles

Pour le pliage des deux pieds mobiles, je n'ai pas trouvé de charnière adéquate au magasin de bricolage du coin, du coup j'ai utilisé des petites équerres (encore moins cher !) :

Du coup, c'est pas très symétrique, elle ne sera pas parfaite une fois pliée !

Equerres

Sur le pied, il faut faire deux fentes à la scie-sauteuse, puis les élargir (salement, à la scie sauteuse aussi), puis un pré-trou et une grande vis pour passer dans les trous des équerres. C'est pas très beau dans le principe, mais ça marche !

Pieds sur l'axe des équerres

Plateau

Le plateau est aussi de récupération, poncé (il en avait bien besoin !!) puis vitrifié.

Commencer par faire les trous sur les pieds : 2 au centre de l'axe fixe, de part et d'autre de la séparation, puis un sur chaque contre-fort des pieds pivotants.

Pieds sur l'axe des équerres

Pour positionner les vis, dessiner au crayon les deux diagonales sous le plateau, puis le centre. Placer les pieds à l'envers sur la table, positionner les vis en face des trous.

Astuce : faire dépasser les vis au centre du plateau plus que celles sur les bords, cela permet de soulever un coin du plateau sans déboîter le centre.

On peut ajouter des petites cales au besoin, comme des patins de chaise en feutre, pour éviter les jeux dûs aux usinages et assemblages approximatifs.

Pour monter la table, il n'y a plus qu'à aligner vis et trous, et ainsi le plateau ne glisse plus, et les pieds ne se referment pas.

Très peu de chutes à la fin : il ne reste que les coins et les morceaux rognés sur les pieds mobiles. Optimisation maximale.

Même pas de quoi faire un Tangram !

Et voilà le résultat final :

Avant/après montage

Il n'y a plus qu'à prendre l'apéro ou un petit café !

XBee & Arduino

2013-05-01T00:00:00Z

Électronique | Informatique Niveau: Vulgarisation,moyen Jérôme Abel

"Bee" pour abeille

Quand il s'agit de concevoir des systèmes embarqués, interactifs ou bien quand des objets doivent communiquer entre eux, plusieurs techniques de communication sont envisageables. Nous explorerons ici le protocole Zigbee qui permet de communiquer par ondes radio, c'est-à-dire sans fil. Je m'efforcerai dans un premier temps de présenter les caractéristiques de ce protocole et d'éviter certaines confusions. Ensuite, je présenterais des cas pratiques, avec et sans la carte Arduino. Pour en savoir plus sur la carte Arduino, vous pouvez consulter ma page Arduino . À noter que ces cas pratiques ne concernent pour l'instant (01/2013) que la série 1 du module XBee. Nous aborderons des domaines variés faisant appel à des notions plus ou moins avancées en réseaux informatiques. Loin d'être un obstacle, ce sera l'occasion d'apporter quelques éléments de compréhension dans l'apprentissage classique des systèmes informatiques. N'hésitez pas à me contacter pour me faire part de vos remarques, améliorer ce document, rectifier certaines erreurs.

Cet article est une version un peu réduite de celui-ci : http://jeromeabel.net/ressources/xbee-arduino . La partie 2 notamment, concernant les réseaux informatiques, ne sera pas retranscrite ici pour alléger l'article.

Le module XBee

Présentation du XBee ¶

Les produits MaxStream XBee™ sont des modules de communication sans fil très populaires, fabriqués par l'entreprise Digi International . Ils ont été certifiés par la communauté industrielle ZigBee Alliance en 2006 après le rachat de MaxStream par Digi International. La certification Zigbee se base sur le standard IEEE 802.15.4 qui définit les fonctionnalités et spécifications des réseaux sans fil à dimension personnelle (Wireless Personal Area Networks : WPANs). Nous verrons plus loin chacun des termes qui peuvent poser problème.

Les principales caractéristiques du XBee :

fréquence porteuse : 2.4Ghz
portées variées : assez faible pour les XBee 1 et 2 (10 - 100m), grande pour le XBee Pro (1000m)
faible débit : 250kbps
faible consommation : 3.3V @ 50mA
entrées/sorties : 6 10-bit ADC input pins, 8 digital IO pins
sécurité : communication fiable avec une clé de chiffrement de 128-bits
faible coût : ~ 25€
simplicité d'utilisation : communication via le port série
ensemble de commandes AT et API
flexibilité du réseau : sa capacité à faire face à un nœud hors service ou à intégrer de nouveaux nœuds rapidement
grand nombre de nœuds dans le réseau : 65000
topologies de réseaux variées : maillé, point à point, point à multipoint

Applications ¶

Le ZigBee semble avoir été conçu pour réaliser ce qu'on appelle l' Internet des objets : un ensemble d'objets communiquants voire "autonomes", une extension d'Internet aux objets physiques. La domotique est l'exemple le plus parlant.

Exemple d'une maison utilisant la domotique

Sans entrer dans les détails, car ce n'est pas le propos ici, la vision d'un monde où tout doit être connecté, du frigo aux enfants, se rapproche pour ma part plus du cauchemar que du rêve. Les technologies de communication peuvent être utilisées par des groupes mercantiles et cyniques qui font reculer les principes démocratiques. Heureusement, des artistes s'approprient ces technologies et les utilisent à des fins plus poétiques.


Jie Qi messenger	Robotics Drums

Ici un couple d'oiseaux de papier communiquent ensemble. Quand l'un est manipulé, l'autre s'allume ( Jie Qi messenger ).

Dans Robotics drums , des servo-moteurs contrôlés à distance tapent sur 18 percussions Darbukas pour créer des rythmes inédits dans la ville.

Une autre application peut s'avérer très utile : programmer à distance une carte Arduino. D'habitude on relie sa carte par câble USB, mais comment faire quand la carte est située à trois mètres de hauteur comme c'est le cas dans mon projet Chimères Orchestra ? La programmation à distance est donc la solution : programming Arduino Wirelessly .

Programmer une Arduino à distance

Pourquoi choisir le sans fil ? ¶

À première vue, le sans-fil présente bien des avantages. Il permet d'éviter d'encombrer un espace de travail, d'équiper des appareils mobiles, de communiquer dans des endroits inacessibles. Cependant, il faut aussi prendre en considération d'autres paramètres :

La communication sans fil ne sera jamais aussi fiable qu'une communication filaire. Le signal peut être déformé par d'autres ondes et par des obstacles.
Par conséquent, commencez toujours à tester votre système avec une communication filaire.
À moins de récupérer l'énergie des ondes électromagnétiques ambiantes ( Free Energy ), vous aurez toujours besoin d'un fil pour alimenter votre module.
L'environnement semble aujourd'hui saturé d'ondes électromagnétiques, on parle de pollution électromagnétique . Le XBee génère des radiations électromagnétiques, alors pourquoi en rajouter ?
La communication n'est pas 1-1 entre l'émetteur et le récepteur. En effet les ondes radio rayonnent en cercle autour de l'émetteur. Seuls les appareils décryptant le bon protocole peuvent différencier les informations provenant d'un module Zigbee, d'un module Bluetooth ou de routeurs Wi-Fi, pourtant tous modulés par la même fréquence de 2,4Ghz.

Projet 2.4Ghz de Banjamin Gaulon

Par exemple, l'artiste Benjamin Gaulon démontre dans son projet 2.4Ghz qu'il est possible de recevoir dans l'espace public le signal des vidéos de surveillance sensé rester privé…

//Note : certains éléments de cette rubrique s'inspirent de la page 178 du livre Making Things Talk de Tom Igoe.//

Wi-Fi / Bluetooth / ZigBee ¶

Comparaisons des principaux protocoles de communication sans fils

XBee ou Zigbee ? ¶

Bee signifiant "abeille", le choix du nom donne l'image qu'il peut y avoir plusieurs petits modules connectés ensemble comme une colonie d'abeilles. Au début, on peut confondre les termes XBee et ZigBee. En fait, comme expliqué au début de l'article, le ZigBee est un protocole de communication qui s'appuie sur le travail du groupe IEEE 802.15.4 et est défini par le groupe de professionnels ZigBee Alliance . Le XBee est une marque, un produit qui utilise le protocole ZigBee. Do you bien compris ?

Exemple d'un module Bluetooth utilisant la même forme que les modules XBee

Le XBee est devenu si populaire que sa forme si particulière est aujourd'hui reprise par des fabricants de puces Bluetooth. Comme il existe beaucoup de shields Arduinos et d'adaptateurs XBee, cela sera sans doute compatible avec les puces Bluetooth.

ZigBee et 802.15 ¶

Architecture du XBee

Dans cette image, on voit bien la répartition des rôles entre le standard 802.15 et le protocole ZigBee. Tout cela est expliqué dans la partie qui traite des réseaux, des protocoles et des couches du modèle OSI, sur mon site .

Séries 1 et 2 ? ¶

Plusieurs produits XBee existent, ce qui peut créer quelques confusions. Il faut retenir qu'il y a deux catégories de XBee : la série 1 et la série 2 . Les modules de la série 1 ont souvent un "802.15.4" qui s'adossent à leurs noms. Les modules de la série 2 sont disponibles en plusieurs versions : XBee ZNet 2.5 (obsolète), le ZB (l'actuel) et le 2B (le plus récent). Vous avez aussi des XBee Pro , qui font la même chose, mais avec de plus grandes capacités, notamment la portée qui semble pouvoir aller jusqu'à 1000 mètres ! Pour en savoir plus, télécharger le tableau de comparaison des modules XBee : http://www.digi.com/pdf/chart_XBee_rf_features.pdf .

Tableau de comparaison des séries 1 et 2

Ce qu'il faut retenir :

les modules des séries 1 et 2 ne sont pas compatibles entre eux ;
la portée et la consommation sont sensiblement les mêmes ;
le nombre d'entrées et sorties est différent et surtout la série 2 ne possède pas de sorties analogiques PWM ;
les topologies de réseaux possibles ne sont pas les mêmes. Avec la série 1, l'architecture est simple : point à point (//pair//) ou multipoint (//star//). La série 2 permet en plus de créer des réseaux plus complexes : maillés (//mesh//) ou en "arbre" (//cluster tree//).

Topologies des réseaux XBee

Antennes ¶

Vous aurez aussi à choisir le type d'antennes du module. En effet, les ondes radios ont besoin d'antennes pour émettre et recevoir les signaux.

Les différents types d'antennes

Ce qu'il faut retenir :

wire : simple, radiations omnidirectionnelles ;
chip : puce plate en céramique, petite, transportable (pas de risques de casser l'antenne), radiations cardioïdes (le signal est atténué dans certaines directions) ;
U.FL : une antenne externe n'est pas toujours nécessaire;
RPSMA : plus gros que le connecteur U.FL , permet de placer son antenne à l'extérieur d'un boîtier.

Communication avec l'ordinateur ¶

Connecter le XBee à l'ordinateur

Pour établir une communication avec l'ordinateur, il y a deux options : l'assemblage de différents éléments comme sur l'image ou le XBee USB Explorer. J'ai choisi la première option car cela était un peu moins cher et plus flexible. L'inconvénient est que ça nécessite un peu de soudure (3 minutes) et un petit montage sur plaque à essais. Bref, cela revient au même.

La communication en direct sans passer par une Arduino vous permet de configurer rapidement votre XBee. On verra plus loin dans les cas pratiques qu'on peut aussi configurer le module en le branchant à l'Arduino. Donc se procurer un explorateur n'est pas indispensable, mais c'est à conseiller pour débuter car c'est tout de même plus simple.

La communication entre l'ordinateur et le XBee se fait via une liaison série, que je détaille dans la partie 2 .

Alimentation ¶

Alimentation du XBee

L'alimentation doit être comprise entre 2,8V et 3,4V. Dans mes montages j'utilise l'alimentation stabilisée 3.3V. Dans d'autres exemples , il semblerait qu'assembler deux piles 1,5V ensemble soit suffisant.

Pour être plus autonome, on peut trouver des montages sur le Web avec le régulateur de tension LM7833 qui sort directement une tension de 3,3V ou bien avec le LM317 qui permettrait avec des valeurs de résistances adaptées d'obtenir ce que l'on souhaite, mais je ne l'ai pas testé.


Régulateur LM7833	Régulateur LM317

Matériel nécessaire ¶

Vous trouverez une liste intéressante de magasins en ligne sur codelab.fr/177 . Je vous conseille de prendre tout dans le même magasin pour limiter les frais de transports et en France ou en Europe pour éviter les taxes (TVA) qui ne sont pas incluses dans certains pays, je pense surtout aux magasins situés aux États-Unis. En gros, essayez d'éviter Sparkfun.

Synthèse de ce dont nous aurons besoin :

Modules XBee x 2 (au moins 2 pour créer une connection !) : série 1 ou 2, antennes filaires ou à puce
XBee Explorer USB (Platine d'interface USB pour modules "XBee") : en option si vous choisissez la carte FT232
Breakout Board for FT232RL USB to Serial (Module "FTDI Basic Breakout" - 3,3V)
Câble mini-USB/USB
Breakout board XBee x 2 (Platine d'interface pour modules "XBee")
2mm XBee socket x 2
Break away headers x 1
Fils pré-découpés de prototypages x 1
Plaques à essais x 2 (solderless boards)
Potentiomètres 10K
LEDs x 4 (n'importe lesquelles)
Bouton poussoir x 1
Résistances : 10K, 330 Ohms
Coupleurs deux piles 1.5V x 2
Breadboard Power Supply 5V/3.3V (si besoin)
Connecteur embase jack/T pour pile 9V
Pile 9V
Piles 1.5V x 2
Cartes Arduino x 2
XBee Shield (si besoin)

Exemple de réalisation pour voir comment tout cela s'articule

Configuration ¶

Une fois le matériel acheté, il ne reste plus qu'à assembler notre premier montage, à établir une connexion avec l'ordinateur et à connaître la syntaxe pour configurer le module XBee.

Montage ¶

Montage XBee et FTDI

Soudez l'adaptateur XBee, il permet juste d'avoir des contacteurs avec le bon espacement pour pouvoir enfoncer le module dans une platine d'essais. Placez la carte FTDI. Connectez l'ensemble suivant le schéma.

Connaître son matériel ¶

Sous Linux et Mac OSX, en ouvrant un Terminal, on peut taper quelques commandes pour savoir si le module est bien reconnu par votre ordinateur : dmesg | tail , lsusb, ls /dev/tty

Commandes utiles

Les réponses du terminal à ces commandes indiquent que l'adaptateur série est bien connecté à l'ordinateur, vous voyez FTDI USB Serial Device ou FT232 USB-Serial , son identifiant est ttyUSB0 .

Terminal ¶

Le but maintenant est de pouvoir envoyer des commandes au module et recevoir ses retours. Pour cela il faut utiliser un programme, appelé Terminal ou plus précisément émulateur de terminal . On l'utilise dans notre cas pour communiquer en série avec le port ouvert par le contrôleur USB. Des spécifités existent entre les différents systèmes d'exploitation que je ne peux répertorier (par exemple pour Windows : programme Putty et Xctu à télécharger).

Trois possibilités :

dans le logiciel Arduino, il y a un moniteur série
sur Linux, installer le logiciel
```
 screen 
```
pour avoir un utilitaire ultra simple (
```
 sudo apt-get install screen 
```
). Ensuite, vous avez accès au port série avec la commande : screen /dev/ttyUSB0 9600 . Le logiciel
```
 screen 
```
se connecte au port série de notre adaptateur FTDI. Si vous avez lu la partie concernant la communication en série, vous ne serez pas surpris de voir le chiffre 9600. En effet, étant donné qu'il s'agit d'une communication asynchrone, il faut se mettre d'accord sur le débit en binaire (bits/seconde). Commandes utiles de screen : Ctl-A ? : help et Ctl-A : quit (en tapant "y" pour "yes")
Une autre solution, sans doute la meilleure, car très agréable à utiliser et multi-plateforme : télécharger le programme de Tom Igoe

Exemple de communication avec le programme de Tom Igoe.

Modes ¶

Le XBee possède trois modes : TRANSPARENT , COMMAND et API . Le mode TRANSPARENT est le mode sélectionné par défaut à la mise en marche du module, celui qui reçoit et envoie les données. Le mode COMMAND permet de configurer le module : ses entrées, ses sorties, son adresse, l'adresse de destination de ses messages, etc.

Le mode API est un peu plus compliqué, et, pour dire vrai, je n'ai pas encore pu l'expérimenter avec succès. Une API (//Application programming interface//) est un terme bien connu en informatique. Il désigne une interface fournie par un programme informatique, c'est-à-dire un ensemble de fonctions qui facilitent la programmation d'un côté et qui de l'autre communiquent en langage binaire pour le XBee, sous forme de paquets. Je crois comprendre que ce mode devient utile quand il s'agit de construire des messages au format XBee à partir d'un ordinateur ou d'un microcontrôleur comme Arduino. Le mode API n'est possible qu'avec une connexion locale en série et filaire avec l'ordinateur ou la Arduino, pas entre modules XBee.

Commandes AT ¶

MODE COMMAND

Ouvrez le terminal choisi. Avant tout, il faut signaler au XBee que l'on veut quitter le mode TRANSPARENT pour entrer dans le mode COMMAND. Pour cela il faut prendre le coup de main, suivez bien ces instructions à la lettre :

Taper +++ et attendre 1 seconde sans appuyer sur aucune autre touche, le message OK devrait alors s'afficher comme sur l'image du terminal juste en haut. Par ce OK, le XBee nous signale qu'il passe en mode COMMAND et qu'il est prêt à recevoir les messages de configuration.
Si vous attendez plus de 10 secondes sans appuyer sur une touche, le XBee revient en mode TRANSPARENT. Vous devez alors retaper +++ pour revenir en mode COMMAND.

COMMAND AT

Dans les télécommunications, l'ensemble de commandes Hayes est un langage de commandes spécifiques développé pour le modem Hayes SmartModem 300 en 1981. Les commandes sont une série de mots courts qui permettent de contrôler le modem avec un langage simple : composer un numéro de téléphone, connaître l'état de la ligne, régler le volume sonore, etc. Ce jeu de commandes s'est ensuite retrouvé dans tous les modems produits (sources : http://fr.wikipedia.org/wiki/Commandes_Hayes , http://en.wikipedia.org/wiki/Hayes_command_set ).

Pour avoir un aperçu rapide des commandes disponibles pour le XBee, télécharger le guide de référence des commandes AT de Sparkfun .

TEST

La syntaxe est simple, il faut taper AT , puis le nom de la commande, les options si besoin et appuyer sur la touche . Essayez donc ces commandes pour faire vos premiers tests :

+++ (attendre OK)
> OK
ATMY1234
> OK
ATMY
> 1234

Vous avez défini ici l'adresse du module à 1234 (ATMY 1234) puis demandé quelle était votre adresse (ATMY).

Adressage ¶

Les différents types d'adresses

Pour tout XBee, il faut impérativement définir l'adresse du réseau ATID , son adresse personnelle ATMY et si besoin, l'adresse de destination des paquets ATDL .

Entrées / sorties ¶

Entrées et sorties

Le XBee series 1 possède un certain nombre d'entrées et sorties. Les sorties analogiques sont PWM0 et PWM1. Les entrées et sorties numériques sont DIO1, DIO2, DIO3, DIO4, DIO5, DIO6, DIO7 ("DIO" pour Digital Input Output). Les entrées analogiques sont : AD1, AD2, AD3, AD4, AD5 ("AD" pour Analog Digital, l'échantillonnage des tensions analogiques converties en numérique). Pour trouver la bonne commande AT, on peut se référer aux pages 12, 31, 39 et 43 du manuel (.pdf) ou à l'image ci-dessous.

Configuration des entrées et sorties

Par exemple, si l'on veut configurer le XBee pour qu'il capte un bouton poussoir sur l'entrée numérique 1, il faudrait écrire ATD1 3 . D1 pour pin19 (DIO1, AD1) et 3 pour Digital Input.

Explications concernant le line passing

Il faut savoir que les entrées fonctionnent par paire, c'est la notion de " line passing ". L'entrée 0 du XBee#2 correspond à la sortie 0 du XBee#1. Puisqu'il y a deux sorties 0 (PWM0, DIO0), si on veut avoir deux sorties différentes il faut choisir une autre sortie DIO1 pour l'autre LED.

Mode API ¶

En mode API, on peut reconstituer la trame ZigBee pour communiquer directement en binaire avec le module.

Trame ZigBee

Voilà, ce que cela pourrait donner en langage Arduino, pris sur http://www.faludi.com/classes/sociableobjects/code/XBee_Analog_Duplex_Sender.pde .

void setRemoteState(int value) { // pass either a 0x4 or and 0x5 to turn the pin on or off
    Serial.print(0x7E, BYTE);
    Serial.print(0x0, BYTE); // high part of length (always zero)
    Serial.print(0x10, BYTE); // low part of length (the number of bytes that follow, not including checksum)
    Serial.print(0x17, BYTE); // 0x17 is a remote AT command
    Serial.print(0x0, BYTE); // frame id set to zero for no reply

    // ID of recipient, or use 0xFFFF for broadcast
    Serial.print(00, BYTE);
    Serial.print(00, BYTE);
    Serial.print(00, BYTE);
    Serial.print(00, BYTE);
    Serial.print(00, BYTE);
    Serial.print(00, BYTE);
    Serial.print(0xFF, BYTE); // 0xFF for broadcast
    Serial.print(0xFF, BYTE); // 0xFF for broadcast

    // 16 bit of recipient or 0xFFFE if unknown
    Serial.print(0xFF, BYTE);
    Serial.print(0xFE, BYTE);
    Serial.print(0x02, BYTE); // 0x02 to apply changes immediately on remote

    // command name in ASCII characters
    Serial.print('D', BYTE);
    Serial.print('1', BYTE);

    // command data in as many bytes as needed
    Serial.print(value, BYTE);

    // checksum
    long sum = 0x17 + 0xFF + 0xFF + 0xFF + 0xFE + 0x02 + 'D' + '1' + value;
    Serial.print( 0xFF - ( sum & 0xFF) , BYTE );
    delay(10);
}

Une autre solution, au lieu de reconstituer la trame, est d'utiliser une bibliothèque spéciale :

D'autres infos :

Montages ¶

XBee > XBee ¶

Montage en direct

On peut faire un montage très simple, le montage direct entre deux modules XBee. On met deux capteurs sur le XBee#2, un bouton poussoir et un potentiomètre et deux actionneurs sur le XBee#1, deux LEDs. Le bouton allume et éteint une LED en on/off (//digital//), le potentiomètre allume et éteint l'autre LED de façon progressive (en PWM).

XBee#2 : émetteur (INPUT)

Montage émetteur

XBee#1 : receveur (OUTPUT)

Montage récepteur

Configuration

COMMAND	INPUT	OUTPUT	DESCRIPTION
Unexpected possible title overline or transition. Treating it as ordinary text because it's so short.			Entrer dans le mode COMMAND
ATRE			Restaure les paramètres par défaut
ATID	1111	1111	Adresse du réseau
ATMY	1	0	Adresse du module dans le réseau
ATDL	0	1	Adresse du destinataire dans le réseau
ATIR	14		Taux d'échantillonnage 20ms (14 en hexadecimal) (p.43 du manuel)
ATIT	5		Nombre d'échantillons à effectuer avant l'envoi des données
ATIU	1		I/O output enabled : autoriser émission des I/O sans passer par l'UART
ATIA		1	I/O input from address 1
ATD0	2		POTENTIOMETRE : D0 pour pin20 (DIO0, AD0) et 2 pour ADC (p.12, p.39)
ATP0		2	LED : P0 pour PWM 0 et 2 pour PWM mode (p.31)
ATD1	3		BOUTON : D1 pour pin19 (DIO1, AD1) et 3 pour Digital Input
ATD1		4	LED : D1 pour pin19 (DIO1, AD1) et 4 pour Digital Out Low Support
ATWR			Écrit la nouvelle configuration dans la mémoire flash du module
ATCN			Sort du mode configuration

XBee > XBee/ordinateur ¶

Communication XBee vers un ordinateur

Avec le même montage, on peut visualiser dans le terminal, les informations reçues par le XBee#1 avec le convertisseur relié à l'ordinateur. Ces informations ne sont cependant pas tout à fait compréhensibles dans le terminal. On ne voit pas de chiffres par exemple car il s'agit de paquets ZigBee.

XBee/Arduino > XBee/ordinateur ¶

Communication entre l'Arduino et l'ordinateur

L'Arduino capte un bouton poussoir et envoie un message tout ou rien au XBee#1 pour allumer la LED. Cette fois, on peut lire dans le terminal les informations de façon compréhensible.

Montage émetteur

Montage émetteur

Code émetteur

Téléchargement : http://jeromeabel.net/files/ressources/xbee-arduino/code/arduino_xbee_bouton/arduino_xbee_bouton.ino .
Simplification du code de Robert Faludi : http://www.faludi.com/classes/sociableobjects/code/XBee_Analog_Duplex_Sender.pde .

// Xbee configuration
void setDestination() {
    Serial.print("+++");
    char thisByte = 0;
    while (thisByte != '\r') { // wait for xbee response
        if (Serial.available() > 0) {
        thisByte = Serial.read();
        }
    }
    Serial.print("ATRE\r");
    Serial.print("ATDL0\r"); // sent to xbee 0
    Serial.print("ATMY1\r"); // this xbee is 1
    Serial.print("ATID1111\r");
    Serial.print("ATCN\r");
}

Le code n'a rien de compliqué. Tout d'abord on configure le module XBee connecté avec RX et TX comme indiqué ci-dessus. On écrit "+++" en communication série, puis on attend la réponse du XBee avec le caractère 'r' qui marque la fin d'une ligne et ensuite on écrit seulement cinq commandes pour configurer uniquement l'adressage du module comme vu dans la partie précédente. On récupère ensuite les informations numériques de l'entrée numérique de l'Arduino et on envoie le chiffre reçu en série, donc au module XBee.

XBee/Arduino > XBee/Arduino ¶

Communication Arduino vers Arduino

L'émetteur est le même que précédemment, une Arduino avec un bouton poussoir et le XBee#2.

Montage récepteur

Montage récepteur

Code récepteur

Téléchargement : http://jeromeabel.net/files/ressources/xbee-arduino/code/arduino_xbee_led/arduino_xbee_led.ino
Simplification du code de Robert Faludi http://www.faludi.com/classes/sociableobjects/code/XBee_Analog_Duplex_Sender.pde .

// Xbee configuration
void setDestination() {
    Serial.print("+++");
    char thisByte = 0;
    while (thisByte != '\r') { // wait for xbee response
        if (Serial.available() > 0) {
        thisByte = Serial.read();
        }
    }
    Serial.print("ATRE\r");
    Serial.print("ATMY0\r");
    Serial.print("ATID1111\r");
    Serial.print("ATCN\r");
}

On configure tout d'abord le module XBee#1 pour qu'il reçoive les données de l'autre XBee.

void handleSerial() {
    char inByte = Serial.read();

    // save only ASCII numeric characters (ASCII 0 - 9):
    if (isDigit(inByte)){
        inputString = inputString + inByte;
    }

    // if you get an ASCII newline:
    if (inByte == '\n') {
        // convert the string to a number:
        receiveValue = inputString.toInt();

        // set the analog output LED:
        digitalWrite(led, receiveValue);

        // clear the input string for the
        // next value:
        inputString = "";
    }
}

Et on récupère les données du port Série. Ce bout de code est un peu plus compliqué. Pour l'instant il ne permet de recevoir qu'une donnée à la fois .

Limites

En pratique, on voudrait avoir la possibilité d'envoyer plusieurs données différentes provenant de plusieurs capteurs et d'actionner plusieurs sorties. Les méthodes présentées ici ne le font pas. Pour cela, deux options semblent envisageables : construire des messages série plus compliqués avec un identifiant (comme ici ) ou bien utiliser l'API XBee pour Arduino.

Ressources ¶

Livres ¶

Building Wireless Sensor Networks , de Robert Faludi. Cet ouvrage se consacre uniquement au XBee de la série 2 pour la mise en place de réseaux maillés.
Duplicate explicit target name: "making things talk".

Manuels et références ¶

Le manuel du XBee 802.15.4 (Series 1) : http://ftp1.digi.com/support/documentation/90000982_B.pdf
Series 1 : http://www.sparkfun.com/datasheets/Wireless/Zigbee/xbee-Datasheet.pdf
XBee Znet 2.5 (old Series 2) : http://www.sparkfun.com/datasheets/Wireless/Zigbee/xbee-2.5-Manual.pdf
ZB (current Series 2) : http://ftp1.digi.com/support/documentation/90000976_G.pdf
Guide de référence des commandes AT : http://www.sparkfun.com/datasheets/Cellular%20Modules/AT_Commands_Reference_Guide_r0.pdf
Comparaisons des modules : http://www.digi.com/pdf/chart_XBee_rf_features.pdf

Téléchargements ¶

XBee Serial Terminal (processing) : http://www.itp.nyu.edu/physcomp/uploads/XBeeSerialTerminal.zip
Code Arduino : http://www.faludi.com/classes/sociableobjects/code/XBee_Analog_Duplex_Sender.pde
Codes Arduino de mes exemples : http://jeromeabel.net/files/ressources/xbee-arduino/code/
Schémas électroniques - Fritzing : http://fritzing.org/
Schémas électroniques - Eagle : http://www.cadsoftusa.com/download-eagle/?language=en

Sites ¶

En savoir plus sur les réseaux :