Les pré-requis étant validés, on va pouvoir s’attaquer à l’installation du système sur l’écran. Pour commencer, j’ai dessiné un boitier qui se fixera derrière l’écran (sur les fixations VESA standards disponibles sur la plupart des écrans) et qui contiendra tout l’électronique :
Le couvercle se clipsera simplement sur le boitier. L’imprimante 3D va pouvoir reprendre du service. Quelques heures plus tard :
Vue de l’intérieur, on peut voir des espaces prévus pour y faire glisser les écrous qui permettront de fixer la carte électronique.
Après installation de l’électronique :
Un connecteur de façade est prévu pour l’alimentation :
Le boitier fermé, et en fonctionnement, tout est prêt pour l’installation sur l’écran.
On installe les rubans de LEDs (autocollants) en faisait bien attention au sens et on fixe le boitier.
Après avoir validé la faisabilité de piloter un ruban de 6 LEDs avec le PC depuis une application Windows (C#) en passant par un Arduino Nano, l’étape suivante consiste en un test « grandeur nature ».
Mon système Ambilight contiendra environ 60-70 leds, 2 points essentiels sont à vérifier :
La consommation maximale de courant, pour prévoir une alimentation suffisante
La réactivité de l’ensemble
J’en ai aussi profité pour monter l’ensemble des composants sur une seule plaque électronique pour en faciliter l’intégration :
En plus du câble USB, j’ai ajouté un connecteur pour le ruban de LEDs et un autre pour l’alimentation (dont l’entrée sera fixée sur le boitier) :
De la même façon, un connecteur a été soudé sur le ruban de LEDs :
Et voici le tout en action, ça marche, c’est déjà ça 😉
Première vérification : mesurer l’intensité. J’ai volontairement utilisé l’ensemble du ruban de LEDs (85 Leds) pour ces tests. Il suffit d’intercaler (en série) un multimètre pour faire les mesures.
Les LEDs de type WS2801 sont données pour une puissance de 0.3W, donc, à 5V, à puissance maximale, on ne devrait pas dépasser les 60 mA par LED.
Tout d’abord en utilisation classique (couleurs de l’arc en ciel), on tourne en moyenne à moins de 1.5A. La consommation semble faible, mais comme ici les LEDs ont toutes une couleur, elles ne sont pas à fond.
Pour tester la consommation maximale, il faut les mettre à la puissance maximale, et en blanc. Ici on passe à 2.5A. Ce qui reste très raisonnable comparé aux 5A théoriques auxquels je m’attendais (mais je vérifierai quand même qu’elles sont bien à luminosité maximale).
Dans tous les cas, l’alimentation de 5V/4A que j’ai prévue fera parfaitement l’affaire pour 60-70 LEDs.
Le dernier point concerne la réactivité. Ici, rien à redire, ça dépote ! La démonstration en vidéo :
Après une petite trêve, il est temps de se remettre au boulot : réalisation d’un système Ambilight maison. Philips intègre cette technologie à certains de ses écrans depuis plusieurs années. Le principe est de diffuser un halo lumineux autour de la télé, en fonction des couleurs affichées sur les bords, pour une meilleure immersion.
Je voudrais intégrer un système similaire, mais pour mon PC et aller plus loin : en profiter pour les films, mais aussi les jeux, la musique, pouvoir définir des ambiances, gérer des notifications etc.
Il y a une ou deux semaines, j’ai trouvé ça dans ma boite aux lettres :
C’est l’élément clé : il s’agit d’un ruban de LEDs adressables. Comparés aux rubans de LEDs classique, l’avantage énorme de ces rubans, est qu’ils ne nécessitent que 3 ou 4 fils pour être contrôlés, grâce à des petits contrôleurs embarqués (chaque LEDs ayant une adresse). Il en existe différents types, j’ai opté (peut-être un peu rapidement) pour un modèle basé sur chipset SPI : WS2801. Ce n’est pas trop cher (15€ le mètre) et ça devrait faire l’affaire.
Le chipset de LEDs qui a le vent en poupe en ce moment semble être le WS2811 (ou 2812 / 2812B / Neopixel). Il s’agit d’un chipset 3 câbles, contrairement au SPI.
La chose importante à s’assurer lors du choix du chipset, est qu’il soit géré par la librairie FastLED pour Arduino. La liste des chispsets supportés est disponible sur le Wiki du projet.
Mon ruban sera donc piloté par un Arduino Nano. Parce que j’en avais un qui traînait, que ça ne coûte pas cher (2-3€) et que ça ne prend pas trop de place 🙂
Pour le WS2801, nous aurons besoin de 4 cables : +5V (IN/OUT), 0V (GND), SPI Clock (CK) et SPI Data (SD).
Remarque importante, qui m’a fait perdre un peu de temps : les rubans ne sont utilisables que dans un seul sens. Sur certains modèles, une flèche indique le sens. Ce n’était pas le cas sur le mien. J’aurais dû m’apercevoir plus tôt que d’un côté il était marqué « IN 5V » et de l’autre « OUT 5V » pour déterminer le sens.
La connexion sur le Arduino est très simple, il suffit d’utiliser les pins SPI CLOCK et SPI MOSI (pin digitaux 13 et 11 sur le Nano).
Après un premier loupé, j’ai fini par souder un connecteur sur mon ruban de LEDs pour avoir quelque chose de propre, solide et facilement raccordable à la platine de tests.
Pour mes premiers tests, j’ai travaillé avec un ruban de 6 LEDs. Ce n’est pas obligatoire, mais pratique pour la phase de calibrage. De plus, cela évite les problèmes liés à une alimentation insuffisante.
Après cette première partie concernant le matériel utilisé, passons au logiciel et au calibrage. Tout d’abord, il faudra se procurer la libraire FastLED (hyper optimisée et très complète).
Je copie/coller une remarque importante issue du site de FastLED :
IMPORTANT NOTE: If you are building for AVR based systems, please do not use any version of the arduino IDE 1.5.7 or later yet. It messes with some of the asm output which will cause you problems.
En clair, pour Arduino, s’assurer de ne pas avoir une version trop récente de l’IDE (j’utilise la 1.0.5-r2).
Une fois FastLED installé dans les librairies de l’IDE Arduino, nous pouvons ouvrir l’exemple « RGBCalibrate ».
Indiquer le nombre de LEDs utilisées : #define NUM_LEDS 6
Ajouter les LEDS qui correspondent au chipset utilisé (WS2801 dans mon cas) : FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, RGB>(leds, NUM_LEDS);
Le code est prêt à être chargé, et testé ! Normalement, les LEDs devraient s’allumer. Si on constate de que la première LED est rouge, les 2 suivantes vertes et les 3 dernières bleues, alors tout est bon, les couleurs sont envoyées dans le bon ordre : Rouge, Vert, Bleu. Si ce n’est pas le cas, il faudra modifier la ligne d’ajout des LEDs pour identifier l’ordre des couleurs à utiliser pour votre ruban. Dans mon cas, RGB ne correspondait pas, je suis passé en BGR, en modifiant la ligne (ne pas hésiter à tester toutes les combinaisons jusqu’à tomber sur la bonne) : FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, BGR>(leds, NUM_LEDS);
L’étape suivante a consisté à tester la communication entre le PC et la carte Arduino pour piloter le ruban. J’ai écrit 2 petits programmes:
un pour le Arduino Nano, qui écoute les ordres du PC et contrôle les LEDs en fonctions des messages reçus
un pour le PC (en .NET C#), qui permet d’envoyer des ordres au Arduino pour piloter les LEDs.
Le programme pour le Arduino Nano est dispo ici. Le principe est très simple : on écoute sur le port série. Si des données arrivent, on lit le premier octet, qui contiendra un caractère. Si ce caractère est un A, alors on lit les octets qui suivent (3 octets pour chaque led, correspondant au code couleur RGB). Si le premier octet est un B, C ou D, on passe en mode « amibiance » (le Arduino génère en boucle une animation pour les leds).
Côté PC, il s’agit d’un petit programme écrit en C# (application WPF). Les sources sont dispos ici. Attention, c’est pas un chef d’oeuvre, juste une bricole de test, pas de MVVM etc. Mais ça reste simple.
Rien de particulier à ajouter, si ce n’est que la communication avec le Arduino se fait grâce à la classe System.IO.Ports.SerialPort du Framework .NET et le composant graphique ColorPicker provient du Extended WPF Toolkit.
Toutes les actions depuis cette fenêtre, à part les « Ambiances », envoient explicitement à l’Arduino l’état RGB de chaque LED. L’Arduino ne servant qu’à les faire suivre aux LEDs. Ainsi, les scénarios sont intégralement pilotés par le PC, contrairement aux ambiances qui sont calculées par l’Arduino.
Voici une vidéo qui illustre le fonctionnement de l’ensemble :
Pas d’articles depuis un moment, mais je n’ai pas chômé pour autant !
Après avoir imprimé un peu tout et n’importe quoi, il était temps d’utiliser la bête pour imprimer un châssis de robot. C’était quand même le but initial 🙂
J’ai fait joujou avec des microcontrôleurs Picaxe, je voulais passer sur du Arduino (hardware Open Source), techno beaucoup plus répandue et avec une très grosse communauté.
Pour découvrir l’Arduino, un objectif simple : fabriquer un petit robot roulant, capable de se déplacer de façon autonome mais également d’être contrôlé à distance via un périphérique mobile (téléphone Lumia 920 sous Windows Phone 8 dans mon cas). Il utilise un télémètre à ultra-sons pour détecter les obstacles et une photorésistance pour détecter les variations de lumières.
Finalement, la prise en main de l’Arduino est un jeu d’enfant. On n’est pas dépaysé après avoir utilisé du Picaxe (qui au passage restent des petits microcontrôleurs super, je n’ai pas vraiment de reproche à leur faire !).
Le prototypage de la partie électronique a été très rapide.
Voici à quoi le robot devrait ressembler (modélisation Sketchup).
Ci-dessous, la vue « explosée » du robot où l’on voit bien les différentes pièces imprimées qui le composent.
Quelques heures plus tard, tout est imprimé 🙂
J’en profite pour préciser quelques astuces. J’ai remarqué que les pièces imprimées, bien que très solides, présentent une faiblesse entre les couches. Quand une pièce « casse », ce n’est jamais une vraie cassure, mais un décollage de 2 couches superposées. Par exemple, quand les parois d’une boîte sont fines, elles se décollent du socle assez facilement.
Pour pallier ce problème, j’ai pris l’habitude de systématiquement consolider les jonctions de plans avec une petite « pente ».
Quelques bandes en relief (3 mm d’épaisseur) sur le fond renforcent aussi la structure. Des emplacements sont prévus pour glisser des écrous. Cela permettra d’assembler les différentes parties avec des vis. Nophead utilise cette astuce pour les pièces de la Mendel90. C’est parfait pour avoir un beau rendu, une bonne solidité et un assemblage facilité.
Même principe de renforcement pour le pare-chocs. Ici, on voit bien que les contraintes appliquées sur les zones où la paroi est la plus fine, sont fortement absorbées par la « pente ».
Un traitement d’enduit en bombe, suivi d’un léger ponçage et d’une couche de peinture en bombe permet de lisser convenablement les pièces et d’avoir un rendu plus « pro ».
Avant/Après lissage, ponçage et peinture.
Fixation de la roulette sur son support imprimé, toujours avec le système des écrous glissés dans la pièce.
Pour que l’électronique soit bien fixée à l’intérieur, j’ai réalisé un petit socle aux dimensions intérieures du robot. 3 écrous viennent assurer que le tout sera bien bloqué grâce à des vis sur la paroi extérieure du robot.
L’ensemble de l’électronique sur son support.
1er étage : la carte Arduino
2ème étage : carte de contrôle des moteurs
3ème étage : carte custom pour connecter avec un minimum de fils l’électronique au reste du robot (piles, LEDs, module Bluetooth, moteurs, etc.)
Toutes les pièces sont peintes, une couche de vernis en bombe a été appliquée pour protéger la peinture.
On peut passer à l’assemblage !
Supports des moteurs et des piles.
Tout est maintenant raccordé ! Les écrous sont en place dans les 4 coins… on peut refermer le petit gars 🙂
Tadaaaammm !
Des ouvertures ont été prévues pour le port USB et l’extrémité du module Bluetooth, histoire de ne pas affaiblir le signal. Des aérations permettent d’évacuer la chaleur (en particulier celle venant de la carte des moteurs).
Sous tous les angles :
A côté de ça j’ai développé une appli Windows Phone 8 pour contrôler le robot. Depuis cette version, Microsoft a laissé un peu plus de liberté aux développeurs pour manipuler le Bluetooth du téléphone. Voici donc la réplique d’une magnifique manette de Nintendo 😀 Le pavé directionnel dérive d’une librairie Open Source.
Fonction de chaque bouton :
Start : connexion au robot
Select : bascule du mode autonome au mode piloté via Bluetooth
Le bon fonctionnement des interrupteurs fin de course et des moteurs étant validé, on va maintenant vérifier que les résistances de chauffe et les thermistances se comportent correctement.
Pour nos mesures, nous auront besoin d’un thermomètre thermocouple (pour 35€ sur Ebay, j’en ai trouvé un qui fait infrarouge et sonde classique).
Cette phase est recommandée. Si normalement il ne devrait pas y avoir de problème, on n’est jamais à l’abri. Ce fut d’ailleurs mon cas, je n’aurais pas repéré l’écart de température de 20-30°C dû aux mauvaises résistances de tirage de ma carte Melzi.
Pour vérifier la buse chauffante, il faut dévisser le dispositif de serrage de l’extrudeur et glisser la sonde jusque dans la buse.
Dans Pronterface, on demande à l’imprimante de monter la température de la buse à 220°C.
Une fois la température atteinte on vérifie avec la sonde que la température mesurée correspond à celle indiquée dans le logiciel. Attention à ce que la gaine de la sonde ne fonde pas dans la buse de l’extrudeur.
On répète la même opération avec le plateau chauffant (à 60°). (Nophead recommande de pousser le plateau une première fois à 90° et laisser reposer 2 heures pour que l’eau présente dans la colle qui entoure la thermistance s’évapore).
Cette fois, je mesure en infrarouge, c’est plus pratique. La température n’est pas tout a fait à 60°C, mais je pense que c’est dû à la plaque de verre.
Dernier point, penser à bien resserrer les vis de l’extrudeur après avoir fait ces vérifications ! J’ai oublié, et les vis empêchaient l’interrupteur de fin de course de l’axe X de s’enclencher. Bref, le moteur s’est bloqué, ça a fait un bruit du tonnerre, j’ai heureusement pu débrancher l’imprimante avant que ça casse ! Il est donc bon d’avoir un interrupteur d’arrêt d’urgence plus accessible que celui de l’alimentation !
La bête est enfin prête pour ses premiers mouvements… si tout se passe bien !
Quand on est bien sûr de tous nos branchements, on peut mettre l’imprimante sous tension (penser à bouger le cavalier pour indiquer que la carte a une alimentation externe et non plus l’USB).
Rien n’a explosé, c’est un bon début 🙂
Nous allons maintenant avoir besoin d’installer Pronterface, qui est le logiciel hôté chargé de la communication avec l’imprimante. Une version pré-compilée pour Windows est disponible ici : http://koti.kapsi.fi/~kliment/printrun/
Je ne savais pas quelle version choisir, alors j’ai pris la dernière (Printrun-Win-Slic3r-10Mar2014.zip).
Au premier lancement, le logiciel crée un fichier de config (printrunconf.ini) dans le répertoire système de l’utilisateur. Il faudra remplacer ce fichier par celui fourni par Nophead pour la Mendel90.
On pourra ensuite brancher l’imprimante sur le PC et redémarrer Pronterface. Nophead décrit très bien dans son manuel les différentes étapes : d’abord tester les interrupteurs fin de course etc.
Le logiciel est assez intuitif, mais il est indispensablede suivre le manuel de Nophead :
Pour terminer, une petite vidéo des premiers mouvements de ma Reprap ! 🙂 (je la pilote en mode manuel via l’interface du logiciel).
Remarque concernant le raccordement au PC : j’ai eu des problèmes de perte de connexion entre l’imprimante et le PC. J’avais 3-4 rallonges USB entre les 2. J’ai remplacé le câble USB et mes problèmes semblent réglés (je croise les doigts).
Pour commencer, il faut vérifier que les petits potentiomètres sont bien réglés. Le plus simple pour cela est d’alimenter la carte avec le port USB (positionner le cavalier si nécessaire) et de mesurer la tension entre le rond (sur la photo) et les 2 broches, on doit être proche de 0.5V sur les 2. Ce qui donnera 1.2A pour les moteurs. L’opération est répétée sur les 4 potentiomètres.
C’est ici que ça se corse, après avoir terminé le montage et commencé les tests, je me suis aperçu que mes sondes de température avaient entre 20°C et 35°C d’erreur.
Le problème venait en fait des résistances de tirage sur la carte Melzi au niveau des 2 connecteurs pour les thermistances de la buse chauffante et du lit chauffant. En fait, les schémas officiels de la Melzi contiennent une erreur, ils indiquent d’utiliser des résistances de tirage de 10KOhms, au lieu de 4.7KOhms. Les schémas n’ont malheureusement jamais été corrigés et certains fabricants de carte Melzi ne font pas la correction, et on se retrouve donc avec un certain nombre de carte Melzi équipées de mauvaises résistances. Ce qui a été mon cas évidemment. Sur la photo suivante, les résistances incriminées sont entourées de rouge (la référence 1002 signifie 10KOhms).
Plusieurs solutions sont envisageables pour contourner le problème :
Dessouder les résistances et les remplacer par de nouvelles. C’est normalement faisable sans station à air chaud, elles sont assez grosses.
Calculer une nouvelle table de référence à intégrer dans le firmware. Pas forcément évident, de plus la précision ne sera pas top à cause de l’utilisation d’une résistance de 10K.
Souder une résistance de 10K (idéalement 9.1K) en parallèle sur les 2 résistances de tirage.
J’ai opté pour la 3ème solution, c’est moche, mais ça marche, et pas besoin de matériel supplémentaire. J’ai cherché dans mon tas de résistances 10K celles qui avaient la résistance la plus faible, j’en ai trouvé 2 à 9.4K, et c’est parfait.
La photo suivante illustre l’immonde bidouillage 🙂
Pour terminer la préparation de la carte, nous allons la recharger après avoir fait quelques modifications dans le firmware. Les modifications se font dans le fichier « Configuration.h » du projet Arduino Marlin. Je précise que j’utilise la version modifiée par Nophead. Le chargement se fait via l’IDE Arduino.
Première modification pour indiquer au firmware quelles thermistances j’utilise (Epcos B57560G104F 100K pour les 2) :
Il faut remplacer le « 1 » par « 1.25 ». Cette valeur correspond au pas des tiges filetées. La version Sturdy utilisant des tiges M8 (au lieu des M6 des autres versions), le pas n’est pas le même.
On peut fixer la carte sur le châssis. Au passage, la liste de matériel de la Sturdy pour la carte Melzi n’est pas la bonne, j’ai utilisé des vis à bois pour la fixer. De plus, les cales plastiques sont adaptées à des vis M3, je les ai donc un peu élargies.
Au menu ce soir : préparation de l’alimentation de l’imprimante.
On part d’une alimentation PC classique (une quinzaine d’euros sur Ebay) et on suit avec attention le manuel de Nophead pour la Mendel90 Dibond. Rien de bien compliqué.
On commence par sectionner tous les fils au niveau des connecteurs normalement destinés à une carte mère.
On soude (+gaine) les résistances.
Les fils non utilisés sont coupés assez courts et gainés. J’ai laissé un peu de longueur pour les fils rouges (5V), des fois que je sois tenté de les réutiliser plus tard pour alimenter… au hasard… un Raspberry Pi 😉
On fait 2 beaux paquets avec les fils 12v et la masse. Il faut essayer de ne pas faire de gros pâtés, ces fils devront rentrer dans les borniers de la carte contrôleur Melzi !
Je me suis aperçu que j’allais avoir des problèmes de longueur de fils, notamment pour les moteurs, mais j’avais également prévu trop court pour les interrupteurs de fin de course.
Tous les fils seront torsadés pour limiter les interférences radio et avoir un câblage plus propre. La longueur finale des fils est donc réduite. Bref, pour faire court : prévoir une bonne marge de longueur de fils, on coupera à la fin au moment de raccorder à la carte contrôleur.
