Contrôleur RGB, troisième version

La version 3 n’est qu’une mise au propre de la version 2 dont je n’ai d’ailleurs jamais parlé ici. Pour résumer, il ne s’agit ici que d’une réduction de format, et la partie logicielle ne change pas.

Contrôleur version 1

Le contrôleur, version 1

Cette première mouture pleinement fonctionnelle a été réalisée sur une plaquette de type stripboard, où il « suffit » de souder les composants, barrettes de connections, sockets, etc, de couper les pistes aux bons endroits, et d’ajouter les ponts nécessaires.

Le soucis est que l’ensemble prend beaucoup de place, et que trouver un boîtier à la bonne taille et à bon prix n’est pas très évident. J’aurais bien sûr pu en imprimer un à façon, je trouve qu’imprimer du « plat » – oui, un boîtier est un ensemble de plats – est un peu un gâchis de ressources. Avec une découpeuse – laser ou CNC – je veux bien, mais qu’une machine passe une heure ou deux à déposer du plastique pour faire une boîte…

Bref, le résultat prenait beaucoup trop de place à mon goût.

L’alimentation

Alimentation pour breadboard à gauche, sa remplaçante compact à droite

L’alimentation utilisée pour la version 1 est en réalité destinée à être utilisée sur une plaquette d’essais, ou breadboard. Elle permet d’alimenter deux rails en 5 ou 3.3 Volts, mais elle ne dispose pas de sortie en 12 Volts, et j’ai dû souder un fil supplémentaire directement sur le connecteur d’entrée. Fonctionnel, mais pas très propre.

Pour la version 2, j’utilise une alimentation plus compacte, permettant de se connecter en 3.3, 5 et 12 Volts. Cette nouvelle alimentation ne dispose malheureusement pas d’un des condensateurs visible près de la LED de sa grande sœur. A ce jour ça n’a jamais posé problème.

Contrôleur version 2

L’objectif principal, le gain de place est atteint en utilisant une plaquette pastillé de cinq par sept centimètres. Je n’aime pas trop les plaquettes pastillées, ou perfboards. Les pistes nécessaires sont remplacées par des fils soudés en place. Ça fait beaucoup de soudures, bien plus que nécessaire, mais je me suis plié à l’exercice.

Contrôleur version 2 non câblé.
Seuls les connecteurs et le réception infra-rouge sont en place

De gauche à droite et de haut en bas :

• Connecteur d’alimentation 12 Volts
• Connecteur d’alimentation 5 Volts
• Connecteur Reset
• Connecteur pour le clone d’Arduino (je n’ai pas de socket aux bonnes dimensions)
• Le récepteur Infra-Rouge
• Le socket pour l’UNL, contitué d’un socket 2×8 broches et d’un 2×4
• Deux connecteurs pour bandes de leds RGB

Contrôleur V2 complet.

J’ai soudé les fils côté composants. C’est brouillon, les fils se croisent un peu partout, bref, un travail de sagouin, même si tout fonctionne correctement.

Contrôleur version 3

J’ai câblé les fils de signaux côté composants, et les fils d’alimentation de l’autre côté. L’implantation des connecteurs est strictement identique à celle de la version 2.

Le résultat est plus propre, même si j’ai encore des progrès à faire.

En haut, la version 1 dépouillée de ses composants
En bas à gauche, la version 2, également dépouillée
En bas à droite, la version 3

Deux connecteurs pour bandes de leds sont connectés au circuit UNL, mais pour le moment, seul celui du haut est piloté par l’Arduino. Un cavalier permet pour chacun d’en déconnecter l’alimentation.

Un petit bilan ?

L’objectif de réduction de taille est atteint. Même en comptant l’alimentation, je suis parvenu à diviser l’encombrement par deux.

Je me suis également amélioré sur la soudure, en m’appliquant et en m’aidant d’un éclairage suffisant et d’une bonne loupe.

Enfin, je devrais utiliser du fil plus fin, forcément moins encombrant et plus facile à placer.

Je préfère toujours les stripboards aux perfboards. Les deux formats ont leurs qualités et leurs défauts, et en respectant quelques principes simples, je sais m’accommoder des seconds. Ça tombe bien, car j’en ai un petit stocks, alors qu’il ne me reste qu’une seule stripboard. Je referai le plein quand les conditions seront meilleures.

La prochaine étape

Loger le contrôleur dans un boîtier, évidemment, et enrichir la partie logicielle.

Eclairage à Leds : le code

Lors des « épisodes » précédents , j’ai assemblé un prototype, puis réalisé sur stripboard un montage plus ou moins définitif.

Le code, écrit dans l’IDE Arduino, est fonctionnel. Plutôt que d’appliquer la dichotomie habituelle, en séparant le programme source entre fichiers d’entête (.h) et fichiers de code (.cpp), j’ai préféré coder chaque classe dans son propre fichier, un peu comme le langage Eiffel.

Découpage du programme

Le programme principal (rgb_strip_controler.ino) demande au récepteur infrarouge (IrKeyPad.h) quelle commande a été envoyée par la télécommande et la    fait appliquer au contrôleur (controler.h). Ce dernier règle alors les niveaux rouge, vert et bleu de la bande de leds (RgbLed.h).

J’ai créé une classe pour chaque partie du programme :

• debug.h : affichage de messages d’information sur le moniteur série de l’Arduino
• RgbLed.h : réglage de l’intensité des trois couleurs de base d’une bande de leds RGB
• IrKeyPad.h :  traduction des codes envoyés par la télécommande infrarouge en commandes (On, Off, etc)
• Controler.h : envoie une liste d’actions à effectuer à la classe RgbLed, en fonction de ce qui est fourni par la télécommande infrarouge
• rgb_strip_controler.ino : initialise le bousin, lit les commandes reçues et les fait appliquer par le contrôleur.

Quelques avertissements

• Le code n’est pas commenté ou pas assez commenté (honte à moi). C’est sur ma « to do list »
• Une seule bande de leds pour le moment. J’en ajouterai une seconde une fois le code commenté
• Le débug n’est pas désactivable. C’est également sur ma « to do list »
• Le code n’est pas optimisé, mais il est relativement lisible, même si j’ai quelques moments « WTF! » en le relisant
• Je n’ai pas respecté tous les canons de l’orientation objet

Pour conclure

Ce code est fonctionnel, même si il peut et doit être amélioré.

Les prochaines actions de ce côté :

• Ajouter des commentaires
• Gérer une seconde bande de leds
• Gérer l’activation et la desactivation des messages de debug

En attendant, j’ai déposé le code sur Framagit

Éclairage à leds : Réalisation

Mon contrôleur de leds RGB en est resté à… l’état de prototype. Un prototype fonctionnel et presque autonome avec son alimentation euh… intégrée. Il fait appel à des composants pour ainsi dire standard :

• Bloc d’alimentation secteur, 12V en sortie, et assez d’ampères.
• Convertisseur 12 volts vers 5 et 3.3 volts
• Un clône d’Arduino Mini (5V, 16 MHz)
• Un circuit UNL pour contrôler de petits moteurs ou des leds en PWM

Le circuit final est réalisé sur une plaquette type stripboard, et comprend plusieurs parties.

De gauche à droite :

• Connecteur pour le convertisseur 12V vers 5V (je n’utilise pas le 3.3V sur ce projet)
• Connecteur pour l’Arduino Mini
• Connecteur pour le circuit UNL
• Trois connecteurs pour trois bandes de leds …

En haut, un « rail » d’alimentation en 12 volts pour les bandes de leds.

En bas, une ligne de masse (0V) et une ligne d’alimentation en 5V

Chaque zone est reliée soit par les bandes conductrices du stripboard, soit par des fils en point à point.

Les connecteurs

Il s’agit essentiellement de barettes HE10 femelles. Le circuit UNL a, lui, droit à un connecteur du commerce, et trois barettes HE10 mâle serviront à connecteur des bandes de LEDs RGB. L’interrupteur (en bleu) n’a finalement pas été soudé sur la plaquette.

Les fils de jonction

La majeure partie des bandes conductrices du stripboard ont été « coupées » pour isoler les différentes zones, et surtout isoler pour l’Arduino et l’UNL les pins droites et gauches.

Par convenance, les alimentations – 12 et 5V – sont câblées en rouge, et les masses en noir. Les signaux entre l’arduino et l’UNL et entre l’Arduino et le récepteur infra-rouge utilisent d’autres couleurs.

Esthétiquement, j’ai déjà fait mieux, mais les connections sont correctes… à part un défaut que je ne verrai que plus tard.

Le résultat

Les différents circuits sont fixés sur leurs connecteurs :

• L’alimentation à gauche. Son fil 12 volts, en rouge, est connecté sur le rail 12 volts en haut de la carte.
• L’Arduino mini au centre à gauche.
• L’UNL au centre à droite
• Le récepteur infra-rouge sous l’UNL
• La bande de leds sur le premier connecteur en haut à droite.

Un pont à peine visible entre les pins 2 et 15 de l’UNL m’a donné une suée. Même en forçant les niveaux à 0, le bleu des RGB restait allumé. Après avoir identifié le pont avec un testeur de continuité, j’ai dû utiliser une loupe pour l’avoir en visuel. Un coup de mèche plus tard, tout rentrait dans l’ordre

Les prochaines étapes

Plusieurs choses sont à voir, ou à revoir sur ce circuit.

• Esthétiquement, on peut faire mieux, mais cette carte doit prendre place dans un boîtier. On ne verra à terme que l’interrupteur et la LED de l’alimentation, celles de l’Arduino, le récepteur infra-rouge et les trois connecteurs pour les bandes de LEDs.
• Une fois l’alimentation branchée, le rail 12 volts est alimenté. Apparemment, c’est sans conséquence, mais par acquis de conscience, je vais lui ajouter un interrupteur.
• Sur le dernier connecteur, seules deux couleurs pourront être utilisées, car la pin 9 du circuit UNL sert pour l’anti-retour nécessaire si on contrôle des moteurs à courant continu. Plutôt que d’utiliser une bande RGB sur ce connecteur, je pourrais me contenter de deux bandes de leds blanches. A étudier…
• La programmation actuelle ne prévoit que l’utilisation d’une seule bande RGB. L’évolution du code est prévue, mais reste à valider.
• Le contrôleur à l’origine de ce projet était sensé produire des animations, comme des effets de « pulse », des flashes, etc. Les sous programmes correspondants sont en place, mais sont vides pour le moment et restent à coder.
• En cas de panne de la télécommande – pile épuisée ou autre – le contrôleur devient inutilisable. Une interface physique (boutons, variateurs, etc) pourrait prendre le relai, mais cela fera l’objet d’un autre projet.

En attendant la suite…

Novembre, c’est Nanovembre, et le NaNoWriMo prend tout mon temps libre. Ca laisse un bon mois pour laisser percoler de nouvelles idées pour améliorer ce qui peut l’être.

Éclairage à leds : le prototype

Une impression 3D ne se passe pas toujours bien. La buse peut se boucher, le filament casser avant d’entrer dans le tube d’alimentation, le spool peut jammer, et il arrive même que ça flambe.

Je n’ai jamais eu à affronter le troisième cas, mais si cela arrivait, je préférerais m’en rendre compte dès le début du problème. Il vaut mieux avoir à changer quelques pièces que toute l’imprimante, ou même de maison pour cause d’incendie. Du coup, je garde un oeil sur l’impression en cours. Les petites impressions prennent vingt ou trente minutes, mais se déplacer pour vérifier la progression et l’absence de problème toutes les quelques minutes devient vite gênant, pour ne pas dire plus, parfois au point de ne pas pouvoir rester concentré sur autre-chose.

L’ajout d’une webcam a été une première avancée, mais sa résolution ainsi que son débit sont tous deux limités, et elle ne dispose pas d’un éclairage intégré. Sans demander du 4K, je préférerais avoir de bonnes images et pour obtenir de bonnes images, il faut un bon éclairage. En attendant de récupérer une meilleure webcam, commençons par l’éclairage du plateau.

Fiat lux !

Un ruban de leds RGB acheté pour quelques pièces dans un marché aux puces fera l’affaire.

Ce ne sont pas des NeoPixels pilotables individuellement, mais de « simples » leds RGB montées en parallèle, avec tout de même leurs résistances protection. Le boîtier de commande et sa télécommande infra-rouge, sans oublier le bloc d’alimentation 12V sont un bonus bienvenu. Pourtant…

Et lux non fit.

La connexion du ruban de LEDs au boîtier de commande se fait par un connecteur qui ne fonctionne pas, malgré une apparence plus que convenable. Le boîtier ouvert, un test de continuité montre que le fil d’alimentation est rompu. On coupe, on remplace, on strappe, on teste et… toujours rien.

Sans alimentation, pas de lumière. Il existe d’autres points d’alimentation utilisables sur la carte électronique du boîtier. Tant qu’à faire, j’ai décidé de remplacer le connecteur « fancy » du boîtier par un bornier à vis. Mon multimètre a rendu l’âme, et son remplaçant n’a pas encore été livré, mais j’ai tout de même pu vérifier que le courant passe en pointant directement depuis le bornier vers le ruban de leds.

L’intensité est malheureusement insuffisante, malgré les tests et réglages à l’aide de la télécommande. Au lieu d’avoir des couleurs éclatantes, je n’ai qu’une très légère activation des leds. Apparemment le boîtier de commande hors service. Heureusement que le reste fonctionne !

Une solution, vite ! Un petit projet, on a dit.

Je pourrais passer des heures à tenter de comprendre ce qui ne fonctionne pas, mais je réserve l’exercice pour plus tard. Je vais « simplement » remplacer le boîtier par un équivalent.

Le ruban de leds mesure plusieurs mètres, largement trop pour mon projet, qui devrait en consommer une soixantaine de centimètres au plus. Il en restera assez pour d’autres usages. La télécommande fonctionne, ainsi que le bloc d’alimentation.

Le cahier des charges

Le nouveau boîtier de commande doit :

• être utilisable avec une bande de 10 cm à 1 m
• réutiliser la télécommande infra-rouge et le bloc d’alimentation
• être facilement clôné
• être facilement connectable et dé-connectable d’une bande de leds

Je me suis inspiré de plusieurs projets présentés sur youtube, instructables, et d’autres blogs pour développer ma petite solution à base d’Arduino :

• Arduino Uno pour le prototype, un clone pour la cible
• Récepteur infra-rouge
• Commande de la bande de leds RGB via une puce UNL2803 commandée en PWM ( pseudo analogique)
• Alimentation unique pour l’Arduino et la bande de leds

Première étape : piloter la bande de leds

L’UNL2803 est un petit circuit intégré à 20 18 pins permettant de piloter aussi bien des leds que de petits moteurs électriques. Il suffit de lui connecter une masse, les signaux d’entrée et les moteurs ou leds en sortie. Dans le cas d’un moteur, une pin supplémentaire doit être utilisée, pour éviter les « retours » de courant lors d’un arrêt de moteur.

Les pins 0 à 8 reçoivent les signaux PWM en provenance de l’arduino, les pins 10 à 17, juste en face, sont reliés aux leds ou moteurs à contrôler. Le pin 8 doit être relié à la masse, et le 9 ne sera pas utilisé.

La vitesse des moteurs ou l’intensité des LEDS peuvent être commandées finement en PWM – Pulse Width Modulation ou Modulation de longueur d’impulsion – et non en tout-ou-rien.

Dans mon cas, les connections sont les suivantes :

• pin 0, 1 et 2 de l’UNL sur les pins 9, 10 et 11 de l’arduino
• pin 9 de l’UNL sur la masse de l’arduino
• pins 16, 17 et 18 de l’UNL sur les lignes Bleu, Vert, et Rouge de la bande de leds
• ligne 12V de la bande de leds sur le 12V de l’alimentation
• Masse de l’Arduino sur la masse de l’alimentation

Un petit programme trouvé ici permet de vérifier que tout fonctionne correctement. Les différentes couleurs devraient s’éclairer suivant une animation simple.

Seconde étape : identifier le type de télécommande infra-rouge

Là aussi, je me suis inspiré d’un travail existant. J’ai flashé sur l’Arduino un programme permettant de décoder ce qu’envoie chaque touche de la télécommande infra-rouge.

La librairie InfraRed pour l’Arduino offre largement assez de possibilité, et de multiples exemples permettent de s’y retrouver. Malheureusement, elle n’est pas directement utilisable dans mon cas. La classe (le module) sensée gérer le codage « NEC1 » se contente d’afficher des valeurs sur le port série de l’Arduino. Je pourrais lui ajouter ce qui manque (une simple routine de lecture en lieu et place d’un affichage), mais j’ai suivi une autre piste, celle de la librairie IRLib2, que j’ai découverte via un tutorial chez Adafruit.

L’exemple « comboDump » affiche le détail du signal reçu par l’Arduino et identifie le codage utilisé :

Decoded NEC(1): Value:F7E817 Adrs:0 (32 bits)
Raw samples(68): Gap:9364
Head: m9300 s4400
[ . . . ]
Space min:550 max:1750

C’est peu lisible, et j’ai abrégé, mais l’essentiel se trouve sur la première ligne : ma télécommande générique utilise le codage NEC, un classique du genre.

Troisième étape : décoder les touches de la télécommande

J’ai modifié la fonction loop() de l’exemple comboDump fourni avec la librairie IRLib2 pour afficher les codes des touches de la télécommande.

Une fois le programme flashé sur l’Arduino, le moniteur série de l’IDE Arduino affiche effectivement les codes envoyés par la télécommande, qu’il « suffit » de noter pour les utiliser dans le programme final :

Code : F730CF
Code : FFFFFFFF
Code : F708F7
Code : FFFFFFFF
Code : F700FF
Code : FFFFFFFF
Code : FFFFFFFF
Code : FFFFFFFF

Le code FFFFFFFF est un code de répétition, lorsque l’on appuie longuement sur une touche sans la relâcher.

Quatrième étape : choisir et programmer le comportement des LEDS

La télécommande doit permettre de :

• allumer et éteindre les leds
• augmenter et diminuer l’intensité des leds
• allumer toutes les leds en blanc
• sélectionner l’intensité d’une des trois couleurs
• si possible sélectionner une animation des couleurs (flash, fading, etc)

Rien n’empêche de l’utiliser autrement, mais je vais tenter de copier le comportement d’origine. Le but premier est de produire de la lumière, pas de créer de nouveaux effets façon boîte de nuit

Toutes les fonctions, à part les quatre animations, devraient être assez simples à développer, en jouant sur le niveau des signaux en entrée de l’ULN.

Les animations demandent de jouer avec des temporisations, mais rien de vraiment compliqué à la base. Pour limiter les manipulations sur la télécommande pendant les tests, on pourra éventuellement flasher l’Arduino pour démarrer directement sur l’animation testée.

Le programme

Le programme final n’est pas très compliqué. A chaque exécution, la fonction principale effectue les actions suivantes :

1. Si un signal infra-rouge valide est détecté, agir en conséquence :
   • changement d’animation
   • ou changement d’intensité d’une couleur
   • ou passage en mode « blanc » continu
   • ou allumer ou éteindre toutes les leds
2. Mettre à jour l’intensité des leds suivant l’animation en cours

Le code sera disponible librement.

Bilan d’étape

Le montage et le programme fonctionnent correctement. Il me reste encore à coder les animations (flash, etc), mais pour l’instant cela peut attendre. Il suffira de reflasher l’Arduino.

Pour le moment le montage consiste en :

• une carte arduino uno
• une petite alimentation 12, 5 et 3.3V. Seul le 12V est utilisé pour le moment car l’Arduino est alimenté par sa prise USB
• un breadboard supportant l’unl2803 et le récepteur infra-rouge
• une bande de douze leds RGB
• de la filasse pour relier le tout.
• le bloc d’alimentation 12V
• un petit transformateur 12V vers 5 et 3.3 V, pour le moment utilisé en 12V uniquement

Le programme comprend quatre modules :

• affichage de messages sur un terminal série (xterm, putty, etc), pour suivre la progression du programme
• lecture des signaux infra-rouge et décodage/transformation en numéro de touches
• gestion des leds RGB
• programme principal

Quelques liens utilisés

• la librairie IRLib2 et un tutorial chez Adafruit
• le pilotage de leds RGB par un Arduino Uno sur le site instructables.com

Les prochaines étapes

Ce projet n’aurait dû durer qu’une petite semaine, si le boîtier de contrôle d’origine avait fonctionné. J’y ai gagné au change, en découvrant le décodage de commandes infra-rouge, ainsi que le composant unl2803, qui permettent de contrôler de petits moteurs ou des leds RGB .

Pour termine complètement ce projet, il me reste à :

• Améliorer et documenter le code
• Rendre les sorties terminal série désactivables
• Remplacer l’Arduino Uno par un Arduino Mini ou une Menta
• Réaliser un boîtier et le câble de connexion d’une bande de leds

Pour le remplacement de l’Arduino Uno, la première option est d’utiliser une carte Menta dont la partie prototypage recevrait les composants du montage. La seconde est d’utiliser un clone d’Arduino mini. Vu l’encombrement, celle-ci a ma préférence.

L’Arduino mini est posée sur la zone de prototypage de la carte Menta.

Encore quelques petites heures de travail en vue. Je documenterai cette seconde partie dans un prochain article en incluant le programme de l’Arduino.

Les brèves #3 : Eclairage à leds RGB (mini-projet)

Dans mon dernier article, je décidais d’un premier lot de petits projets à terminer, à savoir :

• Une plateforme mobile (sur roulettes) pour mon rack à basses.
• Un clavier « analogique » – si-si ! – nécessaire pour plusieurs projets à base de micro-contrôleurs.
• Un éclairage à leds pour le plateau de mon imprimante 3D.

La plateforme mobile doit attendre que les sœurs Lombaires terminent leur fâcherie. Une deux semaines que ça dure, sans pouvoir conduire – heureusement, je covoit’ avec un de mes frères – sans pouvoir continuer mon petit programme cycliste, bref, il va falloir que ça cesse ! Apparemment, ça se calme un peu de ce côté-là.

Le clavier analogique peut attendre. Il lui faudra de toute manière un boîtier que je fabriquerai sur mesure. L’éclairage pour l’imprimante est donc prioritaire. Ok, j’exagère un peu, mais il faut bien commencer quelque-part.

Le but secondaire est de recycler un ruban de leds RGB, son boîtier de commande et sa télécommande, tous trois achetés sur un marché aux puces.

Le boîtier de commande s’est avéré non fonctionnel. J’ai donc commencé à développer le mien, à base d’Arduino et d’UNL2803, et commandé par infra-rouge, pour recycler également la télécommande.

Mini projet ? Mouip, on repassera…