Maker-Faire Saint-Malo 2015 !
L’accueil de la Maker Faire St-Malo
Les 11 et 12 avril dernier, les Fabriques du Ponant et le Telefab ont été présentes lors de la Mini Maker -Faire Saint-Malo 2015. Cet événement a été l’occasion pour la communauté des Makers de se (re)rencontrer et de (re)voir les projets des uns et des autres… Si le Telefab et les Fabriques ont pu exposer leurs projets, cela a aussi été l’opportunité de découvrir de nouvelles idées, de nouvelles méthodes, et surtout, de nouveaux makers !
Le programme de cette Maker-Faire est désormais figé dans le marbre d’Internet et est toujours disponible ici !
Parmi les nombreux projets vus et qui ont attiré l’attention, on retrouve… (suite…)
Les Fabriques du Ponant à la Maker-Faire Saint-Malo
En ce WE du 11-12 avril 2015, les Fabriques du Ponant, représentée par le Téléfab, les Petits Hackers et OpenPathView de la Maison du Libre, sont sur un évènement grand public à Saint-Malo, la Maker-Faire, un lieu d’exposition où plein de fablabs, makerspace, particuliers, entreprises viennent montrer des projets divers et variés.
Sur les stands brestois avec
Horacio de Citizen Data,
Benjamin et Arnaud pour OpenPath View,
Les Petits Hackers de la Maison du Libre et les outils App makers de Mozilla,
Pierre-Henri & Tristan et les globes à persistance rétinienne, Melvin et Loic et le teaser du projet Ty-Bee,
l’ambiance est au beau fixe et la bidouille est présente.
Samedi matin, un défi est lancé aux Petits Hackers : une interface pour dessiner en direct sur la sphère. C’est Tristan G. qui se lance dans l’écriture d’une interface en python et dimanche en début d’après-midi après l’intégration par Pierre-Henri de l’interface avec le logiciel de la sphère : ça marche !
Toutes les infos sur cette sphère à suivre bientôt sur le site du Téléfab.
Scanner 3D à taille humaine
Nous avons un nouveau projet (de plus) au Téléfab : construire un scanner 3D à taille humaine pour obtenir des modèles 3D de personnes ou d’objets de taille similaire. Contrairement à la plupart des scanners 3D, nous voulons que le notre puisse capturer un modèle en moins de 5 secondes, de manière à pouvoir rester immobile facilement.
Nous voulons aussi diminuer les coûts au maximum : nous nous sommes fixés un maximum de 1000 € de matériel, même si nous risquons de dépasser cette somme pour le premier prototype.
Ressources existantes
Pour la structure du scanner, nous nous inspirons du scanner Pi3DScan fait de 100 caméras et de 100 raspberry pi, mais nous voulons fortement diminuer les coûts (indiqués à 8450€ pour ce projet).
Pour la reconstruction logicielle, nous pensons nous servir du logiciel VisualSFM qui est libre, semble très puissant, mais n’est pas facile à prendre en main.
Originalité du projet
Pour diminuer les coûts, nous pensons acheter des webcams pas chères (on en trouve 100 à 350€, frais de ports express compris, sur AliExpress). Nous n’allons pas utiliser un ordinateur par caméra comme Pi3DScan, l’idéal serait d’arriver à connecter toutes les webcams sur le même PC. Ceci causera évidemment des problèmes de débit pour communiquer avec les caméras, mais nous espérons prendre les photos les unes après les autres dans un délai suffisamment court.
Avancement
L’objectif actuel est de présenter et d’utiliser le scanner pour l’Open Bidouille Camp de Brest les 23 et 24 mai.
25 mars 2015
Nous avons récupéré un ordinateur avec une carte graphique Nvidia pour faire des tests avec VisualSFM. Nous avons aussi commandé chez Conrad (malgré des prix bien trop élevés) 50 webcams, 12 hubs USB 4 ports non alimentés, 4 hubs USB 10 ports alimentés, et 16 rallonges USB. Ceci devrait nous permettre de construire 12 poteaux verticaux de 4 caméras et de tout connecter au PC.
Construction
Voici un petit point d’avancement sur la construction du scanner 3D à taille humaine. Nous avons reçu tout le matériel nécessaire, ce qui nous a permis de faire 2 choses :
- tester la capture de photos sur les 48 webcams depuis un seul PC : cette partie est encore en cours, j’en parlerai donc dans un futur article (spoiler : ça marche mais c’est un peu lent) ;
- construire la structure qui supporte les webcams : c’est de cette partie que je vais parler ici.
Objectifs
Il nous faut une structure solide, et simple à monter et démonter pour pouvoir la déplacer selon les évènements. Le coût doit être le plus réduit possible puisque le scanner complet doit rester en dessous de 1000€.
Nous sommes partis sur une structure circulaire, en supposant que la personne à scanner est à peu près contenue dans un cylindre de 70cm de diamètre. Nous avons pris une distance de 70cm entre les webcams et la personne pour avoir suffisamment de recul. Les caméras sont donc montées sur un cylindre de de 210cm de diamètre. Il y a 12 poteaux disposés autour de ce cylindre, et 4 caméras sur chaque poteau. Les poteaux font 2m10 pour permettre aux caméras du haut de voir au-dessus de la tête de la personne scannée.
Voici à quoi ça ressemble :
Réalisation mécanique
Le matériel que nous avons utilisé se trouve dans tous les magasins de bricolage :
- 20 tubes IRL (pour passer des fils électriques) diamètre 20mm pour les poteaux et les liens horizontaux en haut ;
- 30 clips pour IRL à visser pour les fixations ;
- 2 panneaux OSB3 de 9mm d’épaisseur de 2440x1220mm pour découper l’anneau qui sert de support ;
- 10 tasseaux de 2m de 20mmx30mm pour placer sour le socle et solidifier la fixation des poteaux ;
- 8 grandes équerres pour fixer les poteaux au support.
L’anneau de support est découpé à la scie sauteuse en quatre quarts, ce qui permettra de déplacer le scanner plus simplement. Les équerres sont fixées au support grâce à des vis qui se fixent dans des bouts de tasseaux sous le socle, car les panneaux OSB3 sont trop fragiles pour la fixation.
La fixation des poteaux se fait uniquement par des clips à visser. 3 clips sont vissés sur chaque équerre pour la fixation au support. Un clip est aussi vissé à l’extrémité de chaque bout de tube utilisé comme lien vertical. Ceci permet de monter ou démonter le scanner facilement, sans outils.
Nous avons ajouté deux bouts de tasseaux sous le support entre chaque poteau pour solidifier le panneau d’OSB. Sinon une personne montant sur la structure risquerait de la casser. Les bouts de tasseaux sont collés à la colle à bois sour le support.
Connexion des webcams
Les webcams sont simplement fixées grâce à la pince avec lesquelles elles ont été fournies. Elles sont orientées à la verticale car le sujet à capturer est plutôt vertical, et il y a 12 caméras pour capturer tout le tour du sujet, et seulement 4 pour la hauteur.
Les webcams sont des caméras USB bas de gamme capturant du 640×480 pixels. Ce genre de caméras se trouvent à 3€ en commandant en grande quantité directement en Chine.
Les 4 caméras d’un poteau sont connectées ensemble par un petit hub 4 ports non alimenté. Ensuite, les poteaux sont regroupés par 3 et connectées à un hub 10 ports avec une alimentation 4A. Cette alimentation est indispensable pour pouvoir faire fonctionner les 12 caméras. Tous les poteaux ne sont pas connectés sur le même hub pour ne pas surcharger l’alimentation. On se retrouve ainsi avec 4 ports USB, que l’on peut connecter directement au PC, ou chaîner sur l’un des hubs pour n’obtenir qu’une seule prise pour toutes les caméras. Des rallonges USB sont utilisées au niveau de chaque poteau car les fils des hubs sont trop courts.
À améliorer
Il existe différents points qui pourraient être améliorés :
- il aurait été préférable d’utiliser un support plus épais, pour pouvoir visser directement les équerres dedans, et éviter d’utiliser des tasseaux en dessous ;
- la fixation des webcams par leur pince n’est pas très fiable. Il sera peut-être préférable de refaire cette fixation.
Il y a aussi des choses qui restent à faire :
- la luminosité doit être maîtrisée pour obtenir de bonnes images. J’ai des rubans à LEDs blancs à fixer sur les poteaux ;
- la partie logicielle est commencée mais pas terminée, mais ça sera pour un prochain article.
Résultat actuel
Voici à quoi ressemble le scanner actuellement :
Les explications sont disponibles ici :
Aidez nous
Si vous avez des idées pour améliorer ou simplifier le projet, ou si vous voulez vous impliquer, contactez nous ! C’est le moment.
Bildung
Ce projet a été réalisé pendant la première semaine d’intersemestre 2015 au Téléfab par Louis Frehring, Fady George Remila, Alizée Gerard, Anas Ihrboula, Julie Kelberine et Jean-Baptiste Rebuffi.
Résumé
Bildung est un système permettant de produire de la musique à l’aide de la détection du mouvement et de la position des mains.
Matériel utilisé
- un capteur à ultrasons (http://www.seeedstudio.com/wiki/Ultra_Sonic_range_measurement_module#Resources)
- un breadboard
- une carte Arduino
- des fils
- le Leap Motion (https://www.leapmotion.com/)
- une boîte en bois pour contenir le tout
Le système est relié à un Mac sur lequel fonctionne le logiciel Max.
Le lien suivant renvoie vers les sept fichiers de son de base et vers les deux fichiers Max, correspondant à deux versions différentes de Bildung: la première étant orientée vers la modulation du son et la deuxième étant plus musicale (https://github.com/BildungBox/Fichiers-Max).
Carte Arduino et capteur à ultrasons
Bildung replié
Bildung déployé
Test de Bildung
Fonctionnement
L’utilisateur utilise ses mains pour produire de la musique. Une première main permet de déclencher la musique ou de l’arrêter selon qu’elle se trouve ou non devant le capteur d’ultrasons. La deuxième main permet de moduler cette musique. Ainsi, en décalant cette main vers la gauche, on produit un son plus aigu tandis qu’il sera plus grave si on déplace sa main vers la droite. On peut de même contrôler le volume en levant sa main ou en la descendant. La pureté fréquentielle du son est gérée en avançant plus ou moins sa main (modification du facteur de qualité).
Capture d’écran du logiciel Max
Interface de réglage des paramètres de Bildung
Interface destinée à l’utilisateur
Code Arduino du capteur ultrason
#include "Arduino.h"
class Ultrasonic
{
public:
Ultrasonic(int pin);
void DistanceMeasure(void);
long microsecondsToCentimeters(void);
long microsecondsToInches(void);
private:
int _pin;//pin number of Arduino that is connected with SIG pin of Ultrasonic Ranger.
long duration;// the Pulse time received;
};
Ultrasonic::Ultrasonic(int pin)
{
_pin = pin;
}
/*Begin the detection and get the pulse back signal*/
void Ultrasonic:istanceMeasure(void)
{
pinMode(_pin, OUTPUT);
digitalWrite(_pin, LOW);
delayMicroseconds(2);
digitalWrite(_pin, HIGH);
delayMicroseconds(5);
digitalWrite(_pin,LOW);
pinMode(_pin,INPUT);
duration = pulseIn(_pin,HIGH);
}
/*The measured distance from the range 0 to 400 Centimeters*/
long Ultrasonic::microsecondsToCentimeters(void)
{
return duration/29/2;
}
/*The measured distance from the range 0 to 157 Inches*/
long Ultrasonic::microsecondsToInches(void)
{
return duration/74/2;
}
Ultrasonic ultrasonic(7);
void setup()
{
Serial.begin(9600);
}
void loop()
{
long RangeInInches;
long RangeInCentimeters;
ultrasonic.DistanceMeasure();// get the current signal time;
RangeInInches = ultrasonic.microsecondsToInches();//convert the time to inches;
RangeInCentimeters = ultrasonic.microsecondsToCentimeters();//convert the time to centimeters
// Serial.println("The distance to obstacles in front is: ");
// Serial.print(RangeInInches);//0~157 inches
// Serial.println(" inch");
// Serial.print(RangeInCentimeters);//0~400cm
// Serial.println(" cm");
if(RangeInCentimeters <= 15 && RangeInCentimeters>=0 ){
Serial.println(1);
Serial.println("\r") ;
}
else {
Serial.println(0);
Serial.println("\r") ;
}
delay(100);
}
Améliorations possibles
Les valeurs des positions des doigts ou de la paume de la main renvoyées par Max ne sont pas très fiables, elles varient tout le temps, ce qui est assez restreignant lorsque l’on essaie d’assigner par exemple à un intervalle une fréquence donnée.
On pourrait rajouter des paramètres pour prendre en considération la capacité du Leap Motion à détecter le mouvement des doigts. Hélas, on se heurte là aussi à des problèmes de précision et de sensibilité.
Outre les défauts de conception et les imprécisions musicales, nous pouvons tenter d’améliorer notre maîtrise de cet instrument de musique assez particulier. Il est par exemple assez difficile de gérer à la fois l’activation et la désactivation de la musique grâce à une main et la modulation du son par l’autre main.
Music Air Play
Air Play Music
Auteurs :
– YANG Likuang
– El harem Hicham
– Idlimam Marwan
– KANTE Souleymane Cheick
I- Idée :
Vous vous êtes déjà demandés s’il serait intéressant de jouer de la musique juste avec le mouvement de la main ? Le projet Air Play Music vous apporte la réponse. Avec une grande simplicité, notre solution vous donne la possibilité de faire de musique un peu comme avec piano mais cette fois-ci selon le mouvement de votre main (dans l’air) dans un certain nombre d’endroits de l’espace entourant le dispositif.
II- Principe de fonctionnement :
Le principe de l’appareil repose sur la détection de la main de l’utilisateur et la détermination de la distance à laquelle elle se trouve, après quoi l’appareil joue une note correspondante à cette configuration.
III-Matériel utilisé :
– Des capteurs de proximité (Voir https://www.sparkfun.com/products/8959 ) : Pour pouvoir détecter un présence de même que la distance à la quelle elle se trouve avec un assez bonne précision. Les valeurs récoltées de ce capteur serviront à la prise de décision plus tard ;
– Un Controller Arduino (Voir http://arduino.cc/en/ ) : Pour pouvoir décider du type d’interaction pour tout le système afin de le rendre interactif. Là résidera l’action à proposer en fonction de chaque cas d’utilisation (en fonction des données du capteur) ;
- Un MP3 Shield relié à un haut parleur : Avec une carte mémoire sur la quelle chaque son dont nous auront besoin pour mener à bien le projet sera stocké sous forme de fichier mp3 d’un débit de 32 kbps. Ensuite il servira de support (de bonne qualité) pour émettre un son en particulier.La programmation de cette carte exige l’import de la bibliothèque Sparkfun MP3 Player Shield Arduino Library .
– D’autres matériaux secondaires : tels que des fils de connexion, des BreadBords, une planche pour supporter et stabiliser le dispositif et des leds pour montrer l’activation de l’un des capteurs.
III- Description détaillée du fonctionnement :
Comme expliqué précédemment le produit fonctionnera en trois étapes : récolte d’informations de proximité (par l’un des capteurs), détermination du cas d’utilisation et par conséquent de la note (Au niveau du Controller Arduino) et émission d’une note audible à la demande du Controller par le lecteur MP3.
Le produit développé est composé de 4 détecteurs ayant chacun deux zones de détection : 250 à 300 pour la zone lointaine et au-delà de 300 pour la zone proche.
A l’aide du Controller qui répète une serie d’actions à chaque 100 ms, on déterminera la position du capteur le plus proche de la main de l’utilisateur pour ensuite l’activer au besoin.
IV- Améliorations Possibles :
– Maîtrise du niveau sonore : possibilité d’ajuster le niveau du son (dans le programme Arduino puisque la fonctionnalité existe déjà dans les librairies qui permettent de manipuler le la carte MP3 Shield);
– Proposer plusieurs types d’instrument : proposer d’autres instruments de musique à l’instar du piano ;
– Ajouter une interface : des images qui changent en fonction de l’interaction et donnent un peu plus d’animation ;
LUMIDUINO
Constat et concept
Aujourd’hui, il existe de multiples effets de sons et lumières, pour agrémenter toutes les soirées. Le système réalisé porte le nom de lumiduino, c’est un système très visuel. Il permet d’afficher une luminosité, définie selon l’utilisateur, lors de la présence de sonorités aux alentours du capteur.
Il est composé d’un capteur et d’un néon. Le tout fonctionne par l’utilisation d’un Arduino et d’un code.
Technique
Pour réaliser ce système, j’ai utilisé une carte Aduino, un capteur et enfin un « ring neo-pixel ». J’ai élaboré le code pour me changement de luminosité selon la sonorité.
Perspectives d’améliorations
La synchronisation du changement de couleur peut être améliorée par l’amélioration du code existant. Enfin la création d’un boitier pour contenir le système sera intéressant pour pourvoir transporter le système.
Le code
#include <Adafruit_NeoPixel.h>
#define SOUND_SENSOR A0
#define PIN 6
#define NUMPIXELS 16
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
pixels.begin(); // This initializes the NeoPixel library.
Serial.begin(9600);
}
void loop()
{int sensorValue = analogRead(SOUND_SENSOR);//use A0 to read the electrical signal
Serial.print(« sensorValue « );
Serial.println(sensorValue);
If (250 >sensorValue )
{
for(int i=0;i<NUMPIXELS;i++){ // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels.setPixelColor(i, pixels.Color(0,150,150)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(50); // Delay for a period of time (in milliseconds).
}
}
else if ( sensorValue > 250 && sensorValue < 500)
{
for(int i=0;i<NUMPIXELS;i++){ // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels.setPixelColor(i, pixels.Color(250,100,0)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(1); // Delay for a period of time (in milliseconds).
}
}
else if ( sensorValue > 500 && sensorValue < 700)
{
for(int i=0;i<NUMPIXELS;i++){ // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels.setPixelColor(i, pixels.Color(0,200,0)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay (5); // Delay for a period of time (in milliseconds).
}
}
else
{
for(int i=0;i<NUMPIXELS;i++) { // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels.setPixelColor(i, pixels.Color(250,250,250)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(1); // Delay for a period of time (in milliseconds).
}
}
delay (100);
}
Photo du système en cours de fonctionnement
Synesthésia
Dans le cadre d’un intersemestre ayant pour thème la « musique ». Nous avons décidé de travailler sur la production de son à partir de la couleur de notre environnement. Bref de réaliser une impression de synesthésie.
Le groupe est composé de membre venant de l’EESAB et de TELECOM Bretagne ( Mathieu BARON , Mélinda BOUKHANA , Sisi CHEN , Xing LI , François NÉRON , Chloé TROUSSIER , Gabriel VAUDOUR ).
Nous avons créé à l’aide de MAX/MSP un programme permettant de déterminer la couleur d’une image et de jouer des notes en fonction de celle-ci. Nous avons aussi créer un tableau présentant une grande palette de couleur. Ainsi chacun pourra se placer devant la caméra et modifier les sons produit en obstruant certaines couleurs et en ajoutant les siennes.
Pour rendre l’ensemble plus visuel, on ajoute des lumières montrants les couleurs majoritaires dans les images qui sont jouées. A la fois sur l’écran de l’ordinateur et sur un ruban de LEDs
Partie Technique
I- Matériel
– logiciel Max/MSP
-une caméra (ici webcam intégrée à un ordinateur portable)
-un arduino
-un ruban à LED
-un câble USB (arduino)
-une capacité 220 μF
-une alimentation extérieur par câble
-fer à souder
-fils
II- Code
Nous nous sommes organisés en plusieurs modules :
-Détermination des couleurs présentes
-Traduction des données couleur en son
-Contrôle des LEDs
a. Détermination des couleurs présentes
Nous avons décidé de découper l’image filmée par la caméra en plusieurs bloc (ici 8) et de faire une moyenne sur ces blocs des coefficient de la coloration RVB (Rouge Vert Bleu). Afin de simplifier et de rendre plus rapide le traitement du flux continu d’image ainsi que d’éviter de nombreux sons trop proche entre eux.
Ensuite nous lisons les blocs de l’image dans un sens prédéterminé et produisons le son associé à chaque coefficient selon un traitement défini ci-dessus.
b. Traduction couleur son
Le mode de traitement des données est tout-à-fait subjectif et arbitraire. On a choisit d’associer chaque couleurs à un instrument puis chaque instrument à une note. Les instruments sont changés de façon aléatoire afin de nous préserver de la monotonie.
c. Contrôle des LEDs
On contrôle le ruban de LEDs avec Arduino
#include <Adafruit_NeoPixel.h>
#define PIN 6
char incomingByte[10];// for incoming serial data
int i = 0;
int red;
int green;
int blue;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(50, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
strip.begin();
strip.show();
Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
}
void loop() {
// send data only when you receive data:
if (Serial.available() > 0) {
// read the incoming byte:
incomingByte[i] = Serial.read();
i ++;
if (i==9){
for (int j = 0; j <9; j++){
Serial.println(incomingByte[j]);
if (j==8){
i=0;
}
}
red = (incomingByte[0]-48)*100+(incomingByte[1]-48)*10+(incomingByte[2]-48);
green = (incomingByte[3]-48)*100+(incomingByte[4]-48)*10+(incomingByte[5]-48);
blue = (incomingByte[6]-48)*100+(incomingByte[7]-48)*10+(incomingByte[8]-48);
Serial.println(« rouge »);
Serial.println(red);
Serial.println(« bleu »);
Serial.println(blue);
Serial.println(« vert »);
Serial.println(green);
colorWipe(strip.Color(red,green, blue), 20);
}
}
}
void colorWipe(uint32_t c, uint8_t wait) {
for(uint16_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, c);
strip.show();
delay(wait);
}
}
on utilise en parallèle l’écran de l’ordinateur qui affiche la couleur dominante sur chaque blocs.
III- Fabrication
a.Schéma de montage
Montage
branchement ruban/ arduino
On soude ensemble les fils le condensateur et l’alimentation du ruban de LEDs.
Les informations transmises par le logiciel MAX sont celles des 3 coefficients de couleur.
b. Décoration
Pour créer le tableau que nous utiliserons comme support de son, nous avons décider de créer un tableau qui présentera des zones de couleurs différentes. Nous nous sommes inspirés du haut parleur : de sa forme et de sa texture.
La sculpture est composée de carton et d’un grand papier. Elle a été peinte à la bombe. Les photos présentent plusieurs « tapes de sa construction.
Arduino sur FutureMag
Vous voulez découvrir arduino : son origine en Italie, son utilisation en collège ou au sein des fablabs, n’hésitez pas à regarder le reportage proposé par Arte.
Vous y verrez en particulier les activités des petits hackers proposées par la Maison du Libre au sein des Fabriques du Ponant.
Étoiles de Noël
C’est bientôt Noël ! Le moment parfait pour réaliser soi-même une guirlande électrique à mettre dans le sapin. Pour changer un peu des guirlandes électriques que l’on trouve dans le commerce, j’ai décidé de faire un guirlande de grands étoiles translucides, contenant chacune une LED multicolore par branche. Voici un aperçu du résultat en vidéo (en vertical désolé, mais sinon on n’aurait pas vu tout le sapin) :
Dans la vidéo, il n’y a qu’onze étoiles dans le sapin. L’objectif final est une guirlande de vingt étoiles mais le rendu est déjà sympa. Différents modes sont proposés : fixe blanc, changement de couleurs, clignotant blanc, fixe multicolore, scintillement blanc, rotation colorée des branches des étoiles, et flammes rouges et jaunes. Ce ne sont que des exemples, je n’ai pas encore eu beaucoup de temps pour programmer les effets.
Voici quelques photos détaillant la guirlande :
Si vous voulez construire une guirlande du même genre pour Noël, ce n’est pas très compliqué. Il suffit d’un peu de matériel, d’une imprimante 3D et de patience. Je détaille dans la suite comment j’ai fait ma guirlande, et ce que je compte améliorer.
Le matériel
Voici le matériel que j’ai utilisé pour construire cette guirlande :
- du plastique ABS transparent 1,5 mm (environ 500g) ;
- un ruban à LEDs Neopixel d’Adafruit de 2m avec 120 LEDs RGB (multicolores) contrôlables individuellement, PCB blanc ;
- 5m de câble 3G0,75mm noir pour la base de la guirlande ;
- 20m de câble RJ11 noir pour les branches vers les étoiles ;
- un Arduino Nano pour contrôler les LEDs ;
- une alimentation 5V 4A pour alimenter l’Arduino et les LEDs ;
- un gros condensateur pour protéger le ruban et l’Arduino.
Au niveau des outils, il faut une imprimante 3D et un poste de soudure.
L’étoile en plastique
L’étoile est entièrement réalisée à l’imprimante 3D. Le modèle a été dessiné sous OpenSCAD. Il est disponible sur Github, avec les fichiers STL exportés pour l’impression. Le fichier est paramétrable. Il est possible de modifier le nombre de branches ou la taille de l’étoile par exemple.
La pièce à imprimer se décompose en 3 parties, dont 2 identiques. Voici à quoi ça ressemble une fois imprimé :
L’étoile est faite de deux moitiés, qui s’emboitent sur un anneau central. Ceci permet de fermer simplement l’étoile en force. Je n’ai pas mis de colle, même s’il pourrait être utile d’en ajouter pour solidifier le tout. Il y a une encoche en bas de chaque demi-étoile pour laisser passer le fil électrique. Il y a aussi un petit trou en haut de chaque demi-étoile pour accrocher du fil de pêche qui servira à accrocher l’étoile au sapin. La partie circulaire au centre de l’étoile servira de support au ruban à LEDs.
J’ai imprimé toutes les pièces avec un remplissage de 100%. Le rendu visuel est différent avec un remplissage de 0%, plus transparent. Vous pouvez faire des tests.
Pour faire une guirlande complète, il faut imprimer 40 demi-étoiles et 20 anneaux, ce qui peut prendre du temps selon la rapidité de votre imprimante 3D…
Les LEDs et le câblage
La partie électronique dans chaque étoile est extrêmement simple et se compose uniquement d’un bout de ruban à LEDs contenant 5 LEDs. Les dimensions de l’étoile sont faites pour que les LEDs s’alignent toutes seules face à chaque branche de l’étoile. Voici à quoi ressemble l’intérieur d’une étoile : 
La seule chose à faire pour construire l’étoile est de souder sur le ruban le fil qui servira à faire une branche de la guirlande. Ce fil est du fil RJ11. J’ai découpé des morceaux de 70cm pour chaque étoile. L’intérêt du câble RJ11 est qu’il a 4 conducteurs : le noir est la masse, le rouge me sert de 5V, le vert me sert de « data in » et le jaune de « data out ». Le fil de données fait ainsi un aller retour : il arrive par le vert, traverse le ruban, et repart par le jaune. C’est ce qui permettra de contrôler indépendamment toutes les LEDs. Voici le circuit global de la guirlande :
La câble horizontal en bas est le câble 3G0,75mm et les câbles verticaux sont les câbles RJ11. Avec 20 étoiles, il y a 3 mètres de guirlande, avec une branche de 70cm qui part tous les 15 cm. Il est aussi possible d’ajouter 1 mètre de câble en début de guirlande pour éloigner le contrôleur et faciliter la mise en place dans le sapin.
La longueur et la section du câble sont importantes. Plus le câble est long, plus il doit avoir une large section (une faible résistivité) pour que la tension dans l’étoile la plus éloignée reste suffisante. De même, plus il y a d’étoiles, plus l’intensité qui traverse le fil est importante. C’est pourquoi j’utilise des fils très fins pour les branches et un gros câble pour le « tronc » de la guirlande. J’utilise cet outil en ligne pour estimer les sections à utiliser.
Pour souder le câble RJ11 au câble 3G0,75mm tous les 15cm, il suffit de dénuder un petit tronçon (2cm) du cable 3G0,75mm au cutter, puis de dénuder à des endroits différents le fil 5V et le fil de masse. On soude ensuite directement sur les parties dénudées. Il faut ensuite couper le troisième fil (données) et souder le fil vert du câble RJ11 du côté du contrôleur et le fil jaune de l’autre côté. Pour éviter des court-circuits, j’ai mis de la gaine thermo-rétractable sur les fils de données. J’ai ensuite enrobé le tout dans du scotch d’électricien noir pour isoler et cacher les fils.
Une précaution importante à prendre lors de la construction de la guirlande est que l’étoile la plus proche du contrôleur doit être faite d’un bout de ruban pris à un début de ruban. Tous les 50cm sur le ruban, il y a une soudure et une première LED avec une résistance de protection devant le « data in ». C’est une de ces LEDs qui doit être la première connectée au contrôleur.
Le contrôleur
Le contrôleur est simplement un Arduino Nano qui se situe en bout de guirlande (côté « data in »). Il envoie les commandes par le fil bleu vers les LEDs et peut contrôler chaque LED indépendemment.
Le circuit électronique est composé de l’Arduino Nano, d’un condensateur (2 en parallèle en fait) pour protéger l’alimentation, et d’une résistance d’1 MΩ servant de « pull-up » pour un bouton qui fonctionne au toucher. Le bouton sert à changer de mode d’affichage. J’ai soudé les composants sous forme d’un « shield » pour l’Arduino Nano, ce qui m’évite de le souder. Je n’ai pas encore fait de boitier pour le circuit, ni décidé comment je vais faire le bouton, ce qui explique les fils dans le vide :
Le programme est fait sous la forme d’une librairie pour contrôler les étoiles (Stars.h et Stars.cpp) et d’un sketch avec plusieurs modes d’affichage. Il est disponible sur Github et utilise la librairie NeoPixel d’Adafruit (à installer sur votre ordinateur). Les modes actuels sont assez basiques. Je compte les améliorer.
Améliorations
Plusieurs améliorations sont possibles à partir de ce premier jet :
- Faire un joli boitier pour le contrôleur.
- Coller les étoiles pour qu’elles tiennent mieux, ou concevoir un meilleur système de fixation.
- Améliorer les animations de la guirlande. L’Arduino Nano peut être utilisé pour faire des millions d’effets différents. je n’ai pas encore passé assez de temps là-dessus.
- Ajouter des capteurs pour faire réagir la guirlande à son environnement : le bruit, la lumière, la date ou l’heure pourraient faire changer les animations. Tout est possible !
- Ajouter une LED au centre de l’étoile. Je ne suis pas sûr de vouloir faire ça, mais certaines personnes me l’ont suggéré.
À vous !
Cette guirlande n’est pas très compliquée à construire. Il faut juste un peu de patience. Si vous en manquez, vous pouvez aussi construire une seule étoile, qui illuminera votre sapin. Même sans la partie électronique, l’étoile seule peut faire joli dans le sapin, et vous pouvez mettre n’importe quelle sorte de choses dedans.
Si vous faites évoluer l’idée, tenez-moi au courant !
Réorganisation du matériel mercredi 3/12
Ce mercredi 3 décembre, nous allons réorganiser le matériel du Téléfab (classement, recensement, étiquetage) pour le rendre plus facile à trouver et à ranger pour tous les utilisateurs. Ce sera aussi l’occasion d’intégrer le nouveau matériel que nous avons reçu récemment.
Pour que cette opération soit rapide et agréable pour tout le monde, nous avons besoin de main d’œuvre. Participer au rangement vous permettra d’être au courant de tout le matériel disponible, et de montrer votre implication dans le Téléfab. N’hésitez pas à venir !
Nous commencerons à 9h00 et continuerons probablement toute la journée. Même si vous avez des empêchements pendant une partie de la journée, venez quand vous pouvez.
