Hackathon Snootlab

Nous avons commencé à travailler à la prochaine édition du Hackathon Snootlab.

Le prochain hackathon aura pourrait avoir lieu courant janvier avril 2012 sur Toulouse pour bien commencer continuer poursuivre l’année !

Disons que l’on est un peu très à la bourre …

Il sera plus largement annoncé, ouvert à tous quelque soit votre niveau.

Si vous êtes intéressé, contactez nous : hackathon_at_snootlab.com pour que l’on puisse vous tenir au courant.

D’ici là, hackez vos shields et publiez vos manip’ sur notre forum : forum.snootlab.com

Edit en  mars août 2012.

Ambiance : Un week-end entier à exercer notre passion avec des gens, du matin au soir, des enceintes diffusants du son en continu, bref, un week-end plaisant.

Un seul risque : Que tôt ou tard quelqu’un bloque la playlist sur un obscur groupe d’apprentis chanteurs grégoriens sur fond de musique new wave, ou bien que quelqu’un (dénommé alex, pour respecter son anonymat…), cherche à savoir combien de temps il peut passer du nyancat en boucle avant que les gens craquent… Pour palier à tout cet éventail d’horreurs, pourquoi ne pas se faire un montage lecteur MP3/WMA/OGG/AAC/MIDI ?

Et comme le disait Germaine, sculpteuse de riz à la retraite dans le Var : « Avec du son, c’est mieux! »

Donc, après avoir fait l’inventaire des composants nécessaires : un Arduino UNO, un shield Deuligne pour l’affichage, un shield mémoire pour la SD card, un shield audio pour le décodage des flux, on s’y met !

Première étape

Faire la qualification du cubi shield. Le sketch merlot tient ses promesses et supporte bien la montée en charge. Paré !

Deuxième étape

S’assurer que le listage des fichiers présents sur la SD card à l’aide du joystick, et l’affichage de leurs noms sur l’écran LCD est fonctionnel. Pas de réels problèmes rencontrés ici, les exemples fournis avec les librairies de ces deux shields sont bien parlants, et permettent une compréhension aisée des fonctions à mettre en oeuvre. Attention toute fois à ne pas utiliser des noms de fichiers de plus de 8 caractères. La librairie de gestion de la SD n’est pas faite pour ça, et ça se sent (que c’est toi… ).

Troisième étape

: Se faire la main sur les fonctions de manipulations du shield MP3. En effet, il n’existe pas de bibliothèques pour le gérer, il a fallu donc tout faire à la main à partir d’exemples glanés sur le web. Une fois que l’on comprend comment le manipuler, essayer de le coupler à la SD card, et vérifier qu’il n’y ait pas de parasitage, les deux se trouvant sur le même bus de communication.

Quatrième étape

Décoder un flux mp3 en provenance de la flash interne de l’Arduino (d’abord) puis en allant le chercher en « live » sur la SD card (ensuite). Une fois que cela est fonctionnel, rajouter les fonctions permettant d’ajuster le volume.

Cinquième étape

Essayer de faire une interface texte la plus simple et intuitive qu’il soit (excusez moi par avance, je suis pas très doué pour ça, ni pour rien de graphique d’ailleurs…)

Sixième étape

Célébrer la réussite des étapes précédentes, et écouter tranquillement votre musique favorite !

Septième étape

Ne pas oublier d’aller dormir…

Et le code correspondant :

Télécharger punk_audio_player.pde

Visualiser le code sur Gist

Les barbus aiment les leds et je le prouve avec ce lustre à 16 leds RGB (d’ou bi-octopus, les polypophiles auront suivi) commandé à l’aide d’une webcam (ça, c’est le coté Jean Michel Jarre).

RGB Bi Octopus mood lamp

Matériel mis en oeuvre :

• Un arduino duemilanove
• Un protoshield I²C
• 6 barettes 42
• 3 drivers de led I²C PWM driver
• Un PC
• Un sketch Arduino
• Un sketch Processing
• Nappe 20 brins
• Nappe 10 brins
• 3 Connecteurs 20 points
• 10 Connecteurs 10 points
• 16 leds RGB grand angle anode commune (bientôt dans les bacs)
• 12m de câble téléphonique de récupération (4 fils)
• 16 bombes à eau

Câblage de l’installation :

Câblage Pieuvre RGB

Les sketches

• Arduino

Le sketch arduino est un classique issu d’un brainstorming tetalabien, on l’appelle le « Z protocol »

Il consiste à attendre de recevoir un message sur le port série au format qui commence par Z suivi par 16 caractères (octets) en hexadécimal qui donnent la valeur de PWM (de puissance) à appliquer sur chacune des 16 leds.

Avec un seule carte PWM I²C driver, un message série de type Z000F000000000000 allumerait la 4ème led a fond, les autres sont éteintes

Je continue, dans la même config, le message Z000F000000800000 allumerait la 4ème led a fond, la 11ème led a 50%,  les autres sont éteintes

Dans la configuration à 3 cartes driver, le message sera de la forme Z suivi de 3 x 16 = 48 caractères

Les 16 premiers seront la composante rouge de chaque led, les 16 suivants la composante verte, les 16 derniers la composante bleue

Donc, je veux par exemple :

Note : Le soft arduino se charge d’envoyer successivement aux cartes drivers la valeur au format I²C

Il répartit les 16 premiers octets sur la carte dont l’adresse (obtenue à l’aide des jumpers) est déclarée par

byte address[] = {0×11,0×12,0×13};

Alors maintenant qu’on a compris, voici le code :

• Processing (Big up to Fabrice !!)

Télécharger zprotocolarduino.pde

Visualiser le code sur Gist

Et ça donne çà !!!

Jean michel is back on earth

« The Loooooove Booooooot »… Désolé, la fatigue…

Je voulais donc vous présenter le fail du WE : le LoveBot (aussi connu sous le nom de « Pussy Tracker »). Le principe est assez simple puisqu’il s’agit d’un robot se dirigeant vers les sources de chaleurs les plus importantes. Partant du principe que la température varie d’une personne à l’autre et d’un moment à l’autre pour une même personne, nous pouvons utiliser des thermomètres infra rouge pour nous diriger vers les personnes les plus chaudes (et là vous comprenez le surnom dont est affublé ce pauvre robot).

Le robot devrait être équipé de deux capteurs de température de type MLX90614 qui peut mesurer à distance avec un pas de 0,02°C. Le robot suivra la source de chaleur la plus intense qu’il croisera. En toute logique une personne plus chaude traversant son champ le détournera de la personne suivie initialement et il changera de « cible ». Toute similitude avec un certain comportement sentimental des êtres humains ne serait que purement pas fortuit du tout

La partie moteur est assurée par un kit moteurs + réducteurs de chez Tamiya pilotés par un rotoshield de chez Snootlab. Ce shield a quelques évolutions sympa par rapport à celui que j’avais prévu initialement (le MotorShield d’Adafruit).

Le fail vient du fait que pour communiquer avec les capteurs, il est conseillé d’utiliser la librairie I2Cmaster qui malheureusement bugge sur mon ordi. J’ai le même symptôme que certains sur le forum arduino qui est que dès que j’ajoute le #include le Serial.print ne fonctionne plus. Étrange… Bref, ça demandera plus d’investigations un peu plus tard.

Affaire à suivre…

Les puristes sauront apprécier la compacité du code, l’art du commentaire pertinent, le choix judicieux des noms de variables, le découpage fin des fonctions… bref, c’est du code à l’arrach…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

 
#include  
 
Servo myservo;              // crée un objet servo
int pos = 0;                // la variable globale qui contiendra la position du servo en degré, de 0 à 180  
 
int count = 0;              // un compteur utilisé dans la partie suivie du tracker afin d'éliminer le "bruit"
const int differencereg = 5;// la différence de mesure des deux photorésistances sous
                            //laquelle on considère que le tracker est en position
int difference=2;           // la différence courante de mesure entre les deux photorésistances
 
void setup() 
{
  pinMode(A0,INPUT);        // l'entrée analogique correspondant à la première photorésistance 
  pinMode(A1,INPUT);        // ... celle de la seconde
 
  Serial.begin(9600);       // la liaison série sert à débugger 
  Serial.println("mesure photoresistor");
  myservo.attach(11);
  pos= recherchePosition(); // On appelle la fonction de recherche initiale de la position optimale
  myservo.write(pos);       // le résultat renvoyé sert à positionner le servo sur cette valeur de départ avant d'enclencher le suivi
}
 
int recherchePosition()
{
 
  int valeur1;
  int valeur2;
 
  int diffreg=1024;
  int moyreg=750;
  int posreg;
  int diff;
 
  myservo.write(0);             // On commence à la position 0° 
  delay(1000);
  for(pos=0;posmoyreg)          // On vérifie que la moyenne des mesures est supérieure 
    {                           // à celle du meilleur angle enregistré jusqu'à présent
    Serial.println("moyenne supérieure");   
    if (abs(diff)abs(differencereg)) 
    {count+=1;}
  else 
    {count=0;}
}
 
void loop () 
{
delay(100);  
suiviPosition();   
  if (count>5)                   // Au bout de 5 résultats de suite pire que la différence optimale
 {                                  // il est temps de chercher une meilleure position
  if (difference<0) { pos-=2;}   // suivant le signe de la différence, on fait partir le moteur dans un 
  else {pos+=2;}                    // dans un sens ou un autre
  myservo.write(pos);
  count=0;  
  }
 
}

Une petite video pour illustrer le fonctionnement : au démarrage, la fonction recherchePosition du sketch scanne les 180° du servo avec un pas de 5° et sélectionne la meilleure position sur la base du maximum de lumière et avec la différence la plus petite entre les mesures des deux photorésistances.

Parfois, ça ne marche pas exactement comme prévu … mais ça marche. Ce matin sous conditions de haute lumière (le soleil brille fort à Rieux-volvestre !), la position la meilleure est fausse. Toutefois, la fonction de suivi du Soleil prend le relais et corrige ce défaut. Le plus probable est que les résistances choisies ne sont pas adaptées aux conditions de lumière forte. Il faudrait sans doute des résistances plus petites pour avoir une plus grande plage de valeurs en hautes lumières.

Tracking initial

Voici un petit tracker solaire (1 axe) comme il en existe des centaines sur internet.

Grosso-modo, les trackers se divisent en deux catégories : ceux qui se basent sur des éphémérides pré-enregistrés et ceux qui utilisent des capteurs. Celui-ci fait partie de la deuxième catégorie. Il est destiné à terme à contrôler la course d’un four solaire pour en améliorer le rendement.

Le principe : deux photorésistances montées chacune en pont de résistances permettent de récupérer sur les entrées analogiques de l’arduino la luminosité de chacune. Les photorésistances sont accolées à des plaques verticales, des sortes d’oeillères qui créent une ombre portée dés que le tracker n’est pas parfaitement orienté face au soleil.

Le matériel :

• un arduino
• un servo-moteur type RS-2
• deux photorésistances
• deux résistances
• une plaque d’essai
• du scotch, de la colle, du carton, etc.
• on peut ajouter un rotoshield pour être tranquille avec les connections …

La doc technique de la photorésistance (http://shop.snootlab.com/attachment.php?id_attachment=49) précise que la résistance équivalente varie de 5KOhms à pleine lumière jusquà 100KOhm à 10 lux. J’avais une paire de résistances de 39K sous la main qui semblaient ok pour faire un pont diviseur dans ces conditions.

Ci-dessous deux photos qui montrent le prototype une fois fini avec ses trois parties :

• la partie capteur
• le contrôle avec l’Arduino
• le servo qui entraîne la pièce mobile sur laquelle on positionne le capteur

Playlist « Hackathon Snootlab – Sunday » sur Grooveshark

Sur le blog, pour intégrer du code dans un article, mettre via l’onglet HTML, le code entre les balises :

1

où « source.pde » est le nom du fichier directement téléchargeable et refermer avec : </pre>

Exemple ci-dessous :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include "wire.h"
#include "snootor.h"
 
// Declaration des moteurs
SnootorDC M1;
SnootorDC M2;
 
// initialisation
void setup(){
  Wire.begin();
  M1.init(1);
  M2.init(2);
}
 
// boucle programme principal
void loop(){
  M1.setSpeed(255); // réglage vitesse Moteur 1
  M1.run(FORWARD); // mise en marche moteur 1 en avant
 
  M2.setSpeed(255); // réglage vitesse Moteur 2
  M2.run(FORWARD); // mise en marche moteur 2 en avant
 
  delay(2000); // pause de deux secondes
 
  M1.setSpeed(255); // réglage vitesse Moteur 1
  M1.run(BACKWARD);// mise en marche moteur 1 en arrière
 
  M2.setSpeed(255);// réglage vitesse Moteur 2
  M2.run(BACKWARD);// mise en marche moteur 2 en arrière
 
  delay(2000); // pause de deux secondes
}

Ce petit montage a pour but de monitorer le débit sur réseau en utilisant le protocole SNMP depuis un Arduino ethernet (en cadeau bonus, il est PoE et le Switch aussi ).

L’arduino se charge de demander au switch le nombre de paquets unicasts reçus sur un port que nous souhaitons surveiller. En fonction du trafic on allume plus ou moins de « buchettes » sur le bargraphe.

Prochaine étape utiliser a la place du bargraphe , l’I2C PWM driver pour utiliser beaucoup moins de PIN et controler beaucoup beaucoup plus de LED pour meme faire de multiples bargraphes autonomes.

Il est possible que nous soyons tentes de modifier un peu la librairie Agentuino afin de permettre a l’arduino de faire des requêtes plus facilement sur tout plein d’equipements actifs sur le reseau… Un jour… Peut-être…

La video : IBC en action

On a publié « Souder c’est facile » en version longue, il y a quelques semaines; Jérôme hésite entre une nappe fine et une colonie de bombes à eau …

Soudeur de bombes à eau

Video: Jazz for the Cowboy riding a Rex

Objectif : Faire une lumière d’ambiance dont on choisit la couleur par un simple déplacement de la main.

La base est une diode RGB MegaBrite, un capteur de distance sharp 2Y0A21 et d’un arduino bien évidemment.

La MegaBrite a été choisie à cause de sa luminosité. Puisqu’elle est destinée à mettre une ambiance dans le salon, autant que ça ait de la pêche.

Le capteur permet une détection de 5 à 80cm. Ce qui est parfait pour pouvoir piloter la couleur d’un mouvement de bras. À terme, le capteur sera placé à l’horizontale et un piezo sera ajouté pour changer de mode de fonctionnement de façon assez « funky ». On passera d’une couleur fixe à un mode variant sur toutes les couleurs de l’arc-en-ciel en boucle.

Ce projet est une sous partie d’un projet un peu plus ambitieux mais on verra ça la prochaine fois. Soyons raisonnables pour une fois.

Le code bientôt…

La dernière version du « 42 Calculator » est maintenant disponible:

Tester le 42 Calculator

Objectif : Les tireuses à bière à base de fût Beertender n’ont pas tous de capteurs de température ou encores mieux de capteur qui donne le niveau de bières restant.

Le but est de rajouter les capteurs et un écran deux lignes LCD pour savoir s’il y a de la bière et si elle est bonne a température.

Pour la mesure de la température un LM35  a été utilisé, pour la mesure du niveau de bière j’ai tenté de la faire avec capteur Force Sensor Resistor.

La mesure de température n’a pas posé de réel problème par contre, le FSR est trop sensible et ne permet de mesurer correctement quand le fût est plein et que l’on tire quelque verres.

ceci est une revolution
ceci est cubi shield
avec un sketch merlot

Expérience web à partir de backbone.js

Démo

Hier soir, arrivée sur le site, déballage des jouets, positionnement du cubi.

Ce matin, 14h, réveil tout en douceur.

Réveil en douceur

Le hackathon est un week-end durant lequel on se rassemble pour imaginer et réaliser des montages, bricolages, tests autour de l’Arduino, de shields de Snootlab ou d’autres sur des thèmes qui nous intéressent.

Ce rassemblement a lieu dans un lieu convivial où on dispose de matériel pour réaliser les projets et publier dans la foulée sur un site prévu à cet effet.

Les participants sont des personnes qui s’investissent dans le développement de Snootlab, des personnes invitées, des clients, des connaissances, etc. toutes imprégnées de la culture du Do It Yourself, de la bricole, de l’informatique, sans aucune considération de niveau ou de connaissance.

C’est quand ?

Le premier hackathon de Snootlab a lieu du vendredi 30 septembre 20h au dimanche 2 octobre 17h.

C’est où ?

Ca se passe à La maison de Pardailhan (11, rue de la Bastide, 31310 RIEUX)

Agrandir le plan

Ça coûte combien ?

Nous demandons une participation individuelle de 50 € pour le week-end.

Sont prévus et se reconnaîtront :

• Lionel
• Stéphane D
• Frédéric
• Marc
• Sylvain
• Laurent
• Gilles
• Alex
• Jérôme
• Michaël
• Boris
• Mathieu
• Stéphane J

Apportez vos jouets, outils, montages, matériaux utiles à vos projets, etc.

Il y aura toutefois le matériel de Snootlab (station de soudure, outils, etc.), des cartes électroniques (Arduino, Snootlab, Sparkfun, etc.), un switch Cisco 48 ports POE pour tester les montages avec équipements POE.

Sur place, vous êtes en pension complète (gîte et couvert). Pas besoin d’apporter de draps, de duvet, etc.

Accès internet wifi.

Contactez nous :

Général

contact@snootlab.com

05 82 95 02 26