Il faut savoir que le PLA (et davantage encore le TPU) sont très sensibles aux conditions de stockage, et en particulier à l’humidité. C’est pour cela qu’elles sont en général livrées sous vide et avec un sachet d’absorbeur d’humidité. J’ai même lu des articles où il était recommandé de laisser « sécher » au four des bobines n’ayant pas été utilisées depuis un moment, pour évacuer le surplus d’humidité et limiter les dégâts. Dans la mesure du possible, on évitera également de les stocker à la lumière.
Au total je dois avoir en 10 et 15 bobines de filament : couleurs différentes, opaques/translucides, PLA, TPU, bois… Mais je n’imprime pas en permanence et je garde ces stocks très longtemps avant de les écouler.
Dans le précédent article j’ai décrit comment j’avais remplacé tout l’électronique de ma petite CNC pour régler des problèmes de fiabilité/stabilité.
Cette fois-ci, on va s’attacher à régler 4 autres problèmes :
La machine vibre quand même beaucoup (elle est posée directement sur mon plan de travail en chêne). Ca peut avoir un impact sur la précision, mais c’est surtout le bruit qui me gène.
Le plan de travail de la machine en aluminium n’est pas tout à fait plan, j’ai constaté 1 mm d’écart entre le bord gauche et le bord droit. Lors de gravure déco sur bois, ce n’est pas très gênant, mais pour graver des PCB, où la couche de cuivre à retirer est très fine, ce n’est pas acceptable.
La machine ne peux pas percer ou fraiser complètement la matière sous risque d’endommager la fraise et le plan de travail en aluminium.
Le système de fixation vendu avec la machine est simplement une horreur à utiliser.
J’y pensais depuis quelques temps, j’ai franchis le pas et j’ai commandé une petite CNC !
CNC signifie Computer Numerical Control, ce qui, en français, donnerait machine-outil à commande numérique, ou plus littéralement « commande numérique par calculateur ».
Alors qu’une imprimante 3D dépose de la matière en partant du bas de l’objet, la fraiseuse CNC va retirer de la matière en partant du haut de l’objet. Mais si souvent on y fixe une fraise pour faire de l’usinage, on peut aussi y attacher un foret pour réaliser des perçages très précis, ou encore un laser pour « dessiner » sur du bois ou du liège, voir découper certains matériaux.
On peut aussi l’utiliser comme graveuse (sur bois, plexi, alu…). Et l’un des usages qui m’intéresse le plus : la gravure de PCB ! Je ne réalise pas souvent des PCB, mais à chaque fois, avec la gravure chimique, c’est tout un chantier dans la salle de bains, les produits perdent leur efficacité avec le temps, on ne peux pas s’en débarrasser simplement, bref, la gravure m’ira très bien pour mes besoins 🙂
Après quelques mois passés à bosser sur un gros projet, je m’offre une petite pause de fun pour un petit BB-8 fait maison, parce qu’il est vraiment trop mignon 😉 (vidéo disponible à la fin de l’article).
A la base, je voulais juste faire une une figurine et puis je me suis dit que ça serait sympa de l’animer un peu. Alors il ne se déplace pas, mais il tourne la tête, émet des sons et détecte les obstacles devant lui : un simple passage de la main devant lui déclenchera différentes animations.
Ci-dessous, l’ensemble des éléments utilisés (électronique, pièces imprimées, capteur ultrasons, servomoteur…). Le modèle 3D n’est pas de moi, il vient d’ici. J’ai fait des trous dans le corps pour pouvoir passer l’axe de la tête et imprimé des joints pour assembler le tout (+ le support).
Après ponçage, enduit, peinture et vernis, il ne reste plus qu’à assembler le tout.
L’image suivante représente le « cerveau » de BB-8 : un simple Arduino Nano, un buzzer et 3 borniers à visser (alimentation et capteur ultrasons).
Le code est disponible ici. C’est pas super propre mais bon, ça fait l’affaire. J’ai eu de petits soucis d’incompatibilité entre différentes librairies car elles utilisaient les mêmes interrupts : Servo, NewPing, Tone (ou même NewTone pour éviter le conflit avec NewPing). Au final, je n’utilise aucune librairie pour piloter le buzzer).
Vue du boitier une fois tous les composants en place :
Le servomoteur est fixé au centre du boitier :
Pour prolonger l’axe du servomoteur, j’ai utilisé un tube (qui remontera jusqu’à la tête) et imprimé 2 joints qui s’emboîtent dans le tube de PVC : le premier a un emplacement prévu pour intégrer le connecteur à la tête du servomoteur (en noir, que j’ai découpé d’un support vendu avec le servo) et le second qui permet de faire la jonction avec la tête).
Au passage, le socle au dessus du servo est constitué de 2 pièces : la première permet de surélever le support au dessus des vis du servo et le second est un cône qui donnera l’illusion d’une dune (le sable a été saupoudré sur une couche de colle à bois) parce qu’on rencontre BB-8 dans le désert ;).
Aperçu du système de rotation de la tête :
A l’arrière : un interrupteur et un connecteur USB (le robot peut fonctionner sur USB ou sur pile, au choix) :
Et voilà !
Pour finir, une démonstration de notre petit BB-8 en vidéo 🙂
Tous les fichiers sont disponibles ici (modèles Sketchup, fichiers STL et code pour le Arduino Nano). Les fichiers STL du robot en lui-même sont à récupérer sur Thingiverse comme indiqué plus haut.
Dans un précédent article, je testais le fonctionnement d’une boussole électronique avec un Arduino.
Si elle marchait très bien dans des conditions optimales, il était apparu que la proximité d’un champ magnétique suffisamment puissant la rendait complètement inopérationnelle. On observe ce phénomène lorsqu’on approche un aimant d’une boussole : l’aiguille perd le nord, le champ magnétique de l’aimant prenant le dessus sur le champ magnétique terrestre.
Dans le cas d’un robot, c’est problématique parce que les moteurs et haut-parleurs contiennent de puissants aimants. J’avais constaté qu’à partir d’une distance de 15 cm environ, mes moteurs ne gênaient plus trop la boussole, mais ça reste assez contraignant.
Il existent des matériaux qui permettent de dévier les champs magnétiques, notamment le Mu-Metal. Il est essentiellement constitué de fer et de nickel et a subit des traitements spécifiques qui lui confèrent une forte perméabilité magnétique. Le Mu-Metal est très utilisé pour le blindage magnétique (câbles, disques durs…).
C’est plus compliqué à se procurer que la plupart des autres composants d’un robot, mais on en trouve sous forme de ruban adhésif ou de plaque. J’ai commandé une petite plaque autocollante de 10cmx10cm (0.01mm d’épaisseur) pour une quinzaine d’euros sur ebay (on doit pouvoir trouver moins cher, mais en petite quantité, c’est plus difficile).
Pour aller droit au but, ça marche vraiment très bien ! La preuve en vidéo :
Je l’ai commandé chez RobotShop, mais il est aussi disponible chez Gotronic.
Il permet de piloter 2 moteurs à courant continu de 6 à 18V et peut délivrer jusqu’à 5A par moteur. Je compte utiliser une batterie type modélisme de 7.2V, les specs sont donc parfaites pour le châssis et la source d’énergie.
Je ne vais pas reprendre la fiche produit ici, mais ce petit module offre quelques fonctions bien sympa, notamment au niveau de la consommation d’énergie (au freinage, à l’inversion du sens, récupération d’énergie cinétique…). Il propose aussi plusieurs modes de fonctionnement. Le mode série standard me permet de contrôler très facilement le moteur avec un seul pin de l’Arduino !
La transition de la vitesse maximale en avant à la vitesse maximale en arrière se fait sans prendre de précaution particulière (pas besoin d’arrêter les moteurs). Le contrôleur peut assurer que la transition soit fluide en toutes circonstances.
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 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 :
Pour terminer l’imprimante, il manquait encore 2 choses : un (vrai) support pour les bobines de filament et le boitier.
Jusque là, j’utilisais un manche d’aspirateur pour tenir les bobines de plastic. La rotation de la bobine n’était pas vraiment fluide, le filament frottait contre le haut de l’imprimante, et il n’y avait pas de filtre à poussière. J’ai donc conçu un support mieux adapté.
Tout d’abord, 2 pièces qui se fixeront des 2 côtés de la bobine et qui contiennent un roulement à billes.
Le reste du support est constitué de plaques de MDF 12 mm, de pièces imprimées et quelques roulements à billes.
De l’espace est prévu pour insérer un filtre (morceau d’éponge) autour du filament.
Le tuyau de sortie pour le filament sera serré grâce à ce système de vis/écrou.
Voici le support une fois en place à cheval sur les 2 montants arrière. On voit également le filtre (2 morceaux d’éponge qui prennent le filament en sandwich).
J’ai prévu aussi un petit système pour maintenir l’entrée du filament au centre et empêcher le filtre de sortir quand ça rembobine.
Une fois la pièce en place…
Une vidéo est dispo à la fin de ce billet.
La 2ème étape concerne le boitier. Ca me paraissait assez utile pour plusieurs raisons :
Protection contre la poussière
Légère réduction du bruit
Effet « chambre chaude »
Esthétiquement, c’est plus clean
Le boitier peut-être retiré sans problème, il n’est pas du tout fixé, simplement posé au-dessus de l’imprimante et ne couvre pas l’arrière de l’imprimante, pour éviter une surchauffe de l’électronique.
Des vitres en plexiglas permettent de surveiller l’impression.
Et de nuit, c’est joli 😉
Pour terminer, voici une vidéo de la machine en action, en particulier sur le support de bobine.
Nous allons maintenant installer l’alimentation dans l’imprimante. Deux pièces plastiques permettent de bien la caler.
Mais juste avant, j’en profite pour une bidouille : extraire une ligne 12V, si j’ai besoin de connecter quoique ce soit de plus en 12V (comme le ruban de LEDs). J’ai enroulé un fil juste après la gaine, ça évite de faire grossir la partie qui s’insérera dans le bornier de la Melzi. Idem pour la masse.
On prépare tous les fils qui devront passer derrière l’alimentation et on installe les 2 supports de l’alim.
Il ne reste plus qu’à fixer l’alim ainsi que les 2 résistances.
