Lumières bougies artificielles contrôlées par Arduino

Outils et machines nécessaires

Fer à souder (générique)

À propos de ce projet

Il y a quelque temps, j'ai commencé à travailler sur un projet pour éclairer subtilement notre salle de l'atrium qui devient un peu trop sombre en automne et en hiver. Je voulais quelque chose de plus naturel que les lumières LED dures, de préférence l'aspect vivant de bougies vacillantes.

Pour les impatients (qui ne veulent pas faire défiler jusqu'en bas pour trouver une vidéo), voici le résultat :

...et une version de Noël :

Maintenant, revenons à l'histoire :

Mais créer une flamme artificielle réaliste n'est pas une tâche facile, donc mon idée était de placer les lumières de manière à ne pas voir la "flamme" directement, mais simplement la lumière qu'elle produit, dansant sur le mur.

La pièce étant majoritairement constituée de parois vitrées, le choix s'est alors imposé de laisser la lumière se projeter sur les poutres blanches retenant les fenêtres. J'ai décidé de placer les lumières sur le bas du faisceau horizontal, en projetant la lumière vers le bas sur les faisceaux verticaux.

Préparation et planification

Comme je voulais pouvoir contrôler chaque « bougie » individuellement, le choix de la lumière LED était facile; il devrait évidemment s'agir d'un ensemble de modules LED basés sur WS2812, j'ai donc commandé 100 LED individuelles.

Comme vous pouvez le voir sur l'image ci-dessus, chaque LED a six connexions - et une direction marqué d'une flèche à l'arrière.

Deux des connexions sont marquées 5V , deux sont GND et puis il y a le Din (Data In) et le Dout (Données sortantes). Les deux 5V sont connectés et les deux GND le sont aussi s. Donc en pratique il y a quatre Connexions; 5 V , GND , Din et Dout .

Après quelques essais avec différents nombres de LED par "bougie", j'ai trouvé un nombre de quatre . Ce nombre m'a permis de faire suffisamment de manipulations de lumière intéressantes sur chaque faisceau pour faire un look de bougie réaliste sans exiger trop de LED.

Cependant, si je devais le refaire, j'aurais commandé un ensemble de modules 2 par 2 LED, pour simplifier le montage.

Le contrôleur n'avait pas besoin d'être très avancé, et mon hypothèse était qu'un Arduino Nano suffirait.

Le placement de l'Arduino n'était pas évident. J'ai finalement choisi de le poser sur la poutre horizontale elle-même, derrière le pilier épais que l'on voit sur la première photo ci-dessus (tout à gauche). Le pilier est placé dans le coin de la pièce où se rencontrent les deux parois vitrées (dont la paroi "droite" est représentée sur la photo). De cette façon, je pourrais avoir les LED sur deux chaînes parallèles - une pour chaque mur - afin de minimiser la longueur physique de chaque chaîne. Maintenant, la longueur totale de chaque chaîne serait d'environ 4 mètres (13 pieds) au lieu d'en avoir une double.

L'Überguide Adafruit NeoPixel a été une très bonne lecture ici; si vous envisagez de jouer avec les modules LED WS2812, vous devez absolument le lire ! Par exemple, il m'a dit pourquoi il est bon de limiter les longueurs physiques des fils.

Cacher les câbles...

... n'était pas si difficile dans mon cas puisque les LED devaient être placées sur le côté inférieur du faisceau horizontal. J'ai cherché une chaîne câblée bon marché et en ai trouvé une sur IKEA (je ne peux pas dire si c'est ironique ou évident, étant de Suède).

Les modules LED eux-mêmes ont été simplement placés avec un ruban adhésif double face solide.

Création des modules LED

Comme je ne voulais pas souder le tout ensemble sur une seule corde pleine longueur (j'imaginais le bourrage de câble que je rencontrerais en essayant d'installer la chose sur la face inférieure du faisceau), j'ai décidé de construire les modules LED avec connecteurs pour les câbles.

Les modules LED devaient être placés juste à côté des faisceaux verticaux afin d'obtenir le plus de lumière possible qui s'y reflète. Je voulais aussi que le câble passe près du faisceau - et je devais respecter la direction des LED. Cela m'a conduit (sans jeu de mots) à avoir deux versions du module ; une configuration placée sur la chaîne allant à droite de l'Arduino et un allant à gauche .

Les deux versions de module nécessitaient deux configurations de soudure uniques, où la principale différence était de maintenir le flux de données allant de la bonne LED à la suivante.

Comme les LED sont assez petites, environ 9 millimètres de diamètre (3/8"), il n'a pas été facile de les souder ; et compte tenu de mon manque d'expérience en soudure, le résultat n'est pas si beau et joli. Mais cela a fonctionné.

La soudure

Avant de souder, j'ai coupé un module LED 2 par 2 des sections d'origine 2 par 5. Ensuite, j'ai peint une extrémité en rouge et l'autre en noir pour marquer les côtés proches du 5V et du GND (afin d'éviter des erreurs stupides).

Étape 1 Le premier exercice de soudure consistait à mettre une "goutte" de soudure sur le petit îlot métallique de chaque LED.

L'étape suivante consistait à connecter les simples connexions droites et proches.

Ensuite, les câbles suivants devaient conserver leur isolation, car ils se chevauchaient.

Au total, il y avait cinq poutres dans chaque direction - plus la poutre d'angle - ce qui donne un grand total de onze poutres. Étant donné que chaque module LED avait quatre LED, le nombre de LED individuelles est de 44.

Après quelques modules, j'ai pris le coup et au final j'ai pu souder un module complet en 30 minutes environ.

Le "truc du câble court"

La plupart des câbles minuscules avaient besoin de leur isolation, mais il était difficile de couper juste assez d'isolation à chaque extrémité pour exposer le noyau interne lorsque la longueur totale du câble était inférieure à un centimètre.

Ensuite, j'ai trouvé cette astuce (évidente) :

1. Soudez une extrémité du câble, puis pliez-le et coupez-le à la longueur souhaitée. (Dans cet exemple, l'extrémité non soudée doit être connectée au Dout de la LED en bas à droite dans l'image ci-dessous.)

2. Faites glisser un peu l'isolant.

3. Coupez la longueur désirée de l'isolant libéré.

4. Faites glisser l'isolant vers l'arrière, exposant le noyau sur l'extrémité libre. Tadaa !

De cette façon, la longueur exacte du noyau de câble exposé a pu être créée, et le résultat était plutôt sympa :

Finalisation des modules LED

En fin de compte, les modules LED doivent être fixés à l'envers sur le faisceau, de sorte que la face arrière soudée et remplie de câbles doit être préparée pour contenir le ruban adhésif.

J'en suis venu à utiliser du plastique plat au hasard que j'ai simplement coupé en carrés. Ceux-ci étaient simplement fixés aux modules LED avec de la colle chaude.

Voici tous les modules complets ! Hourra !

(À ce stade, il était essentiel d'avoir des marquages ​​dessus, pour séparer ceux qui partent à gauche de ceux qui partent à droite !)

Les modules complets ont été facilement fixés à l'aide d'un ruban adhésif solide sur leur dos désormais plat.

Faire les câbles

Heureusement, j'avais un vieux rouleau de rallonge téléphonique qui traînait. Ce câble avait quatre fils séparés, ce qui était plus que suffisant, car j'avais besoin de trois fils (5V, GND et données).

Le montage des douilles femelles sans l'outil de sertissage spécial n'était pas si facile, mais tout à fait faisable.

Le canal de câble a été facilement monté; il suffit de le couper en longueurs appropriées et d'utiliser le ruban adhésif pré-attaché pour le fixer à la poutre horizontale.

Voici à quoi ressemblait un module monté finalisé :

Activation et désactivation automatiques

Comme je ne veux pas allumer les lumières manuellement quand il fait noir et les éteindre après, j'ai mis une photorésistance.

Je ne voulais pas un simple on/off, mais un changement progressif de l'intensité lumineuse pendant la période crépusculaire. Pour cette raison, j'avais besoin de connaître la valeur analogique de ma photorésistance au moment du soir où j'ai décidé que la "lumière du jour" se transformait en "crépuscule" et au moment où le "crépuscule" se transformait en "obscurité".

Dans le graphique ci-dessous, la courbe rouge représente la lecture analogique de la photorésistance lorsqu'elle se déplace au cours d'une journée (pas une lecture réelle ci-dessous, juste mon dessin à main levée). Les deux lignes horizontales pâles marquent les deux niveaux; celle du haut est la limite où la "lumière du jour" se transforme en "crépuscule" et celle du bas où le "crépuscule" se transforme en "obscurité". Ainsi, lorsque la courbe rouge est au-dessus de la ligne horizontale supérieure, je considère que c'est le JOUR, et lorsqu'elle est en dessous de celle du bas, c'est la NUIT.

La ligne verte la plus droite est la mesure de la lumière du jour "nettoyée", c'est-à-dire minimum (0,0) pendant la nuit et maximum (1,0) pendant la journée, et une pente linéaire au crépuscule.

Pour connaître les lectures analogiques réelles, j'ai connecté quatre photorésistances à un Arduino avec un écran LCD pour afficher les valeurs actuelles, minimales et maximales des quatre résistances. J'en ai utilisé quatre parce que je ne savais pas si j'en avais un mauvais, donc si la plupart d'entre eux avaient à peu près la même lecture, je savais qu'ils fonctionneraient. Évidemment, j'ai placé l'appareil au même endroit où je voulais que l'Arduino pilote les LED à la fin. Voici à quoi cela ressemblait :

Comme l'écran LCD est assez limité, j'ai montré la lecture d'une photorésistance à la fois pendant environ cinq secondes. Ensuite, pendant la journée, je passais de temps en temps et notais les chiffres sur un morceau de papier. (Évidemment, j'aurais pu le garder connecté à mon ordinateur portable et envoyer les numéros sur la connexion série, mais j'avais besoin de mon ordinateur portable pendant la journée et je ne voulais pas rester assis dans l'atrium toute la journée).

En fin de compte, j'ai décidé qu'il faisait sombre en dessous de "630" et clair au-dessus de "800". Mais ces chiffres correspondent évidemment à ma photorésistance avec la résistance de 10 kΩ que j'ai utilisée en série, ce n'est donc pas une vérité absolue.

Le code source Arduino

Je voulais pouvoir avoir différents types d'effets d'éclairage, pas seulement des bougies. Pour cette raison, j'ai construit le code source de manière modulaire, en essayant d'isoler les différents mécanismes dans différents fichiers pour une vue d'ensemble plus facile.

Le .ino principal -file est maintenu très petit. En gros, je démarre le tout et appelle Update() sur quelques classes d'aide (qui à leur tour fait l'affaire).

Actuellement, le code source prend en charge deux effets différents; l'effet bougie et un effet "Noël". Pour le moment, le choix de l'effet est codé en dur, ce qui signifie que je dois recompiler le code si je veux faire un changement. En fin de compte, cela devrait être contrôlé à l'aide d'une télécommande - ou, mieux encore, d'un téléphone intelligent. On verra.

Code

Éclairage de l'atrium

Schémas