Pont de bougie vacillante : 6 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Cette instructable montre comment transformer un simple pont de bougie avec lumière statique en une belle lumière d'ambiance éclatante avec des variations infinies de lumières scintillantes, scintillantes, motifs de vagues et ainsi de suite. J'ai acheté chez After Christmas Sales un pont de bougies pour 8 €. Il dispose de 7 lumières LED et d'un adaptateur mural 33 V 3 W. Il brille d'une couleur blanche brillante et chaude et sera parfait pour ce projet, où je mettrai un Arduino pour faire scintiller les bougies. L'Arduino le plus populaire est l'Arduino Uno. Dans ce projet, j'utiliserai un Arduino Mega 2560.

Je vais abandonner l'alimentation 30 V et utiliser une simple banque d'alimentation 5 V destinée aux téléphones portables comme alimentation.

Une bonne chose à savoir sur les banques d'alimentation est qu'elles ont un circuit interne, qui transforme la batterie de 3,7 V en 5 V. Étant donné que le processus utilise de l'énergie, la banque d'alimentation se ferme d'elle-même si elle n'est pas utilisée. Si la banque d'alimentation est utilisée pour des gadgets de bricolage basés sur Arduino, le gadget ne peut pas simplement se mettre en veille d'économie d'énergie et redémarrer après quelques minutes. Cela coupera la banque d'alimentation. Ce pont de bougies vacillantes n'a pas de mode veille. Il utilise constamment de l'énergie, gardant la banque d'alimentation active, jusqu'à ce que le câble d'alimentation soit retiré.

La vidéo montre le pont de bougie en mode statique et en plein scintillement. Le scintillement complet est vraiment assez ennuyeux pour les yeux, tandis que la vidéo le lisse un peu. Une fois le matériel réparé, y compris la coupe des câbles, la soudure de nouvelles connexions et l'ajout de certains composants, tous les motifs lumineux souhaités sont créés en écrivant le code pour l'Arduino. Les modèles que j’inclus dans cette instructable sont:

• 4 lumières vacillantes différentes imitant de vraies bougies
• 2 scintillements différents (clignotement aléatoire des lumières autrement statiques)
• 2 modèles de vagues différents
• lumière statique simple

La commutation des modèles se fait via un bouton-poussoir, l'élément unique de l'interface utilisateur. Plus on veut de motifs et plus on veut de réglages, plus il faut ajouter de boutons et de boutons. Mais la beauté réside dans la simplicité. Limitez le nombre de motifs sélectionnables. Choisissez les meilleurs paramètres lors du codage et des tests, et non en ajoutant de nombreux contrôles au matériel.

Fournitures

• 1 pont de bougie LED avec 7 ampoules. Assurez-vous qu'il s'agit d'un modèle CC basse tension, soit avec des piles, soit avec une source d'alimentation murale, qui transforme le 110 - 240 V CA mortel en 6 - 30 V CC. Il est donc parfaitement sûr de pirater le pont des bougies.
• 1 Arduino Mega (tout autre microcontrôleur fera l'affaire, assurez-vous simplement de pouvoir le programmer)
• 1 maquette de prototypage
• fils de liaison et autres fils
• outil de soudure
• multimètre
• 7 résistances, 120
• 1 bouton poussoir (je vais montrer comment vous pouvez utiliser le bouton intégré sur un Arduino à la place)
• Un transistor Darlington IC pour 7 transistors, ULN2803AP fera l'affaire (si vous utilisez un Arduino Uno ou Meaga, vous n'en avez pas vraiment besoin)
• Une banque d'alimentation 5 V destinée aux téléphones portables

Étape 1: Examinez ce que vous avez

Découvrez à quelle tension fonctionne chaque LED et combien de courant circule.

1. Ouvrez le bas du pont de bougie. Trouvez les deux fils qui vont à une bougie.
2. Retirez une partie de l'isolant des câbles en révélant les fils de cuivre sans couper les fils de cuivre.
3. Allumez les lumières (détendez-vous, ce n'est que quelques volts) et mesurez la tension sur les fils de cuivre révélés.
4. Coupez le câble à l'un des points de mesure (à ce stade, les lumières s'éteignent, bien sûr), dénudez un peu d'isolant (3 - 4 mm) aux deux extrémités. Mesurez le courant traversant. Ce que vous faites est de reconnecter le câble coupé avec votre multimètre, en laissant tout le courant traverser votre multimètre, qui vous indique maintenant la quantité de courant.

Mes lectures

La tension sur une bougie (étape 3): 3,1 V

Notez que la source d'alimentation du pont de bougie était de 33 V. Donc, sept fois 3,1 V ne font que 21,7 V. Sur certaines bougies, il doit y avoir une résistance supplémentaire. Si j'avais mesuré cette tension de bougie, elle devait être d'environ 11 V.

Le courant traversant lorsque la bougie s'allume (étape 4): 19 mA

Je vais tout alimenter avec une batterie 5 V 2 A. Pour les bougies, je dois faire chuter la tension de 5 V à 3 V. J'ai besoin d'une résistance, qui fera chuter la tension de 2 V à un courant de 19 mA.

2 V / 0,019 A = 105

La puissance dissipée est:

2 V * 19 mA = 38 mW

C'est négligeable. Beaucoup plus pourraient faire exploser la résistance elle-même. Pourtant, sans une résistance de 105 Ω, je pourrais faire exploser la LED. J'ai des résistances de 100 et 120 Ω. Je vais avec 120 Ω. Cela donne plus de protection.

Le test des 7 bougies avec 3 V a donné une lumière vive, à l'exception d'une bougie, qui n'avait qu'une lumière très faible, avec seulement 0,8 mA traversant. C'était ma bougie avec la résistance supplémentaire. Il s'est avéré que les autres bougies n'avaient aucune résistance. Les lumières LED utilisées dans le lustre sont simplement destinées au 3 V ! La bougie avec la résistance supplémentaire a dû être ouverte avec une légère violence, mais rien ne s'est cassé. La résistance a été trouvée juste sous la minuscule LED à l'intérieur de l'ampoule de la bougie en plastique. J'ai dû le dessouder et ressouder les fils. C'était un peu salissant, car le fer à souder réchauffait de la colle chaude, qui avait été utilisée pour l'assemblage.

Alors maintenant, je sais que quelle que soit la source d'alimentation que j'utilise, quelle que soit la tension, je dois baisser la tension à 3 V permettant à 19 mA de passer.

Si j'avais été plus familier avec la technologie LED, j'aurais reconnu le type de LED utilisé et j'aurais su qu'il fallait 3 V.

Étape 2: un peu de soudure

Dans cette étape, je connecte tous les fils positifs (+) des 5 bougies à un fil. Ensuite, j'ajoute un fil négatif (-) séparé pour chaque bougie. Une lumière LED ne s'allume que lorsque le '+' et '-' vont à droite. Comme vous n'avez que deux extrémités de câble identiques pour chaque bougie, vous devez tester laquelle est « + » et laquelle est « - ». Pour cela, vous avez besoin d'une source d'alimentation 3 V. J'avais un petit paquet de piles comprenant deux piles AAA. Une pile bouton de 3 V fonctionne également très bien pour les tests.

Le pont à bougies a besoin de 8 câbles pour passer entre l'Arduino et le pont. Si vous trouvez un câble avec 8 fils isolés, ce serait génial. Un fil doit contenir 120 mA, les autres ne portent que 20 mA au maximum. J'ai choisi d'utiliser un câble à 4 fils doubles, ce que j'avais.

La première image montre comment j'ai préparé un fil commun pour connecter tous les fils « + » des bougies. Dénudez une partie de l'isolant du fil commun pour chaque bougie. Ajoutez un morceau de tube isolant thermorétractable (la bande jaune sur l'image) pour chaque joint et placez-le au bon endroit du câble commun. Soudez le fil '+' de chaque bougie à son joint, couvrez le joint avec le tube thermorétractable et rétrécissez-le. Bien sûr, un simple ruban adhésif convient aussi, tout sera couvert à la fin.

La deuxième image montre les fils « - » dont chaque bougie a besoin. Le fil '+' commun va directement à la broche 5 V de l'Arduino (ou peut-être à travers la planche à pain). Chaque fil « - » va à sa propre broche du transistor IC (encore une fois, probablement à travers la planche à pain).

Un Arduino est souvent appelé carte de prototypage. Une maquette est également quelque chose que vous utilisez dans les prototypes. Ce que je décris dans cette instructable est un prototype. Je ne vais pas le développer en un produit chic et brillant avec tout caché dans de jolis boîtiers en plastique. Passer du prototype au niveau supérieur signifierait remplacer la planche à pain par une carte de circuit imprimé et des composants soudés et même remplacer l'Arduino par une simple puce de microcontrôleur (en fait, cette puce est le cerveau de l'Arduino). Et que tout rentre dans un boîtier en plastique ou à l'intérieur du pont de bougie piraté.

Étape 3: les connexions

À propos d'Arduinos, extrait de cette page:

• Courant maximum total par broche d'entrée/sortie: 40 mA
• Somme des courants de toutes les broches d'entrée/sortie combinées: 200 mA

Mes bougies consomment 19 mA chacune lorsqu'elles sont alimentées en 3 V. Il y en a sept, ce qui fait 133 mA. Je pourrais donc les alimenter directement à partir des broches de sortie. Cependant, j'ai des circuits intégrés de transistor Darlington de rechange. Alors j'ai pensé, pourquoi pas. Mon circuit fait les choses correctement: les broches de données ne sont que pour les signaux, pas pour l'alimentation. Au lieu de cela, j'utilise la broche 5 V de l'Arduino pour alimenter les lumières LED. Lors de l'exécution du test, mon ordinateur portable est connecté à l'Arduino. Tout est alimenté par l'USB de l'ordinateur portable, qui donne 5 V. L'Arduino Mega a son propre fusible, qui saute à 500 mA pour protéger l'ordinateur. Mes bougies consomment au maximum 133 mA. L'Arduino probablement beaucoup moins. Tout fonctionne bien, lorsqu'il est alimenté par l'ordinateur portable, donc utiliser une batterie de 5 V connectée au port USB de l'Arduino est très bien.

Les broches de données D3 - D9 vont à l'IC ULN2803APGCN. Les LED fonctionnent sur 3 V. Chaque ampoule est connectée à la source 5 V et en plus à une résistance de 120 Ω. Suite à un canal du CI, qui relie finalement le circuit à la terre à travers un transistor Darlington dans le CI.

Un bouton poussoir est ajouté au circuit pour permettre une action de l'utilisateur. Le pont de bougie pourrait ainsi avoir quelques programmes sélectionnables par l'utilisateur.

Le bouton-poussoir du circuit est connecté à RESET et GND. C'est exactement ce que fait le bouton de réinitialisation intégré. Comme je n'encapsule pas tout dans un boîtier en plastique, j'utilise le bouton de réinitialisation de l'Arduino pour contrôler le programme. L'ajout d'un bouton en fonction de l'image fonctionnera exactement comme le bouton de réinitialisation de la carte. Le programme fonctionne en se rappelant quel programme d'éclairage a été utilisé la dernière fois que le programme a été exécuté. Ainsi, chaque réinitialisation passera au programme d'éclairage suivant.

Les photos montrent comment les nouveaux câbles sortent du pont, comment j'ai posé le transistor IC et les résistances sur la planche à pain et comment les cavaliers se connectent à l'Arduino Mega. J'ai coupé 4 fils de liaison mâle-mâle en 8 demi-fils, que j'ai soudés aux 8 câbles sortant du pont de bougie. De cette façon, je peux simplement coller les câbles dans la planche à pain.

Alternative sans transistors

À l'étape précédente, j'ai préparé un fil « + » commun pour les bougies et des fils « - » séparés, qui traversent le circuit intégré du transistor jusqu'à la terre. Lorsqu'une broche de données passe au niveau haut, le fil « - » correspondant est mis à la terre via son transistor et la LED s'allume.

La connexion des fils « - » directement aux broches de données de l'Arduino fonctionnerait également, mais faites toujours attention à la quantité de courant que les broches de données peuvent supporter ! Cette approche nécessiterait un changement dans mon programme. Il faudrait que les broches de données baissent pour allumer les bougies. Pour utiliser mon programme tel quel, vous devez basculer '+' et '-' dans les bougies. Avoir un fil "-" commun pour les bougies, qui va à GND sur l'Arduino. Et les fils séparés passent entre le fil '+' de la bougie et une broche de données de l'Arduino.

Étape 4: Les programmes lumière

Mon programme, que je présente à l'étape suivante, passe par 9 programmes lumineux. Appuyez sur le bouton pour éteindre les lumières pendant une seconde, puis le programme d'éclairage suivant démarre. Les programmes sont les suivants:

1. Fort scintillement. Les bougies scintillent au hasard. Cela semble très ennuyeux lorsque vous les regardez de près, mais cela peut sembler bien de loin et peut-être derrière une fenêtre de grenier givrée. Cependant, votre voisin pourrait appeler les pompiers.
2. Doux scintillement. Semble très bien. Comme de vraies bougies dans une pièce sans courant d'air.
3. Scintillement variable. Les bougies alternent en douceur entre un scintillement fort et doux à des intervalles de 30 s environ.
4. Scintillement variable. Comme #3, mais chaque bougie varie à son rythme entre 30 s et 60 s.
5. Clignotement rapide. Les bougies brillent à un niveau atténué statique et scintillent de manière aléatoire. En moyenne, il y a un scintillement par seconde.
6. Lent scintillement. Comme #5, mais à un rythme beaucoup plus lent.
7. Vague rapide de la bougie supérieure du milieu aux inférieures.
8. Onde lente de la bougie supérieure du milieu aux inférieures.
9. Lumière vive statique. Je devais l'inclure, je ne voulais pas me débarrasser de la fonction d'origine.

Étape 5: Le code

/*

FLICKERING CANDLE BRIDGE */ // Déclarez la variable de mode pour conserver l'état // via une opération de réinitialisation _attribute_((section(".noinit"))) unsigned int mode; // Lorsque le programme démarre après une réinitialisation, cette // partie de mémoire n'est pas initialisée, mais conserve la valeur // qu'elle avait avant la réinitialisation. La toute première fois que le programme // est exécuté, il contient une valeur aléatoire. /* * La classe bougie contient tout le nécessaire * pour calculer un niveau de lumière pour * une bougie vacillante. */ class chandelier { private: long maxtime; longue minute; long maxlite; longue minlite; longue méchanceté; long origmaxtime; origine longue; long origmaxlite; longue origminlite; longue origmeanlite; temps deltamax long; deltamintime long; long deltamaxlite; longue deltaminlite; longue deltaméanlite; long lforate; longue égalité; démarrage long; cible longue; flotteur phactor; cible longue; temps de démarrage long; temps delta long; void newtarget(void); long onecible(vide); public: bougie (long mat, long mit, long mal, long mil, long mel, long eo); long levelnow (vide); void initlfo(long deltamat, long deltamit, long deltamal, long deltamil, long deltamean, long rate); void setlfo(void); }; bougie:: bougie (long mat, long mit, long mal, long mil, long mel, long eo): maxtime(mat), mintime(mit), maxlite(mal), minlite(mil), Meanlite(mel), evenout (eo), origmaxtime(mat), origmintime(mit), origmaxlite(mal), origminlite(mil), origmeanlite(mel) { cible = Meanlite; nouvellecible(); } /* * levelnow() renvoie le niveau de lumière que la bougie devrait avoir maintenant. * La fonction s'occupe de définir un nouveau niveau de lumière aléatoire et * le temps qu'il faut pour atteindre ce niveau. Le changement n'est pas linéaire, * mais suit une courbe sigmoïde. Lorsqu'il n'est pas temps de définir un nouveau niveau *, la fonction renvoie simplement le niveau de luminosité. */ longue bougie::levelnow(void) { long help, now; flotteur t1, t2; maintenant = millis(); if (maintenant >= targettime) { help = target; nouvellecible(); aide au retour; } else { //help = cible * (millis() - starttime) / deltatime + start * (targettime - millis()) / deltatime; t1 = float(targettime - now) / deltatime; t2 = 1. - t1; // Ceci est l'aide au calcul du sigmoïde = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*target*3 + t2*t2*t2*target; aide au retour; } } void bougie::newtarget(void) { long sum; somme = 0; for (long i = 0; i < evenout; i++) sum += onetarget(); début = cible; cible = somme / evenout; heure de début = millis(); targettime = starttime + random(mintime, maxtime); deltatime = targettime - starttime; } bougie longue::onetarget(void) { if (random(0, 10) lastcheck + 100) { lastcheck = now; /* * L'algo pour le scintillement "après le taux de millisecondes": * Commencer la vérification après le taux / 2 millisecondes * Pendant une période de taux / 2 millisecondes, faire * la chance d'un scintillement d'être de 50 %. * Si le taux est de 10000 ms, pendant 5000 ms la pièce est * retournée 50 fois. * 1/50 = 0,02 * If random(10000) starttime + rate / 2) { if (random(rate) targettime) return lowlite; return (start - lowlite) * (targettime - now) / (targettime - starttime) + lowlite; } void twinkler::twink(void) { starttime = millis(); targettime = random(mintime, maxtime) + starttime; start = random(minlite, maxlite); } void setup() { int led; // Lire la variable du mode magique, qui devrait indiquer // quel programme d'éclairage a été exécuté la dernière fois, l'incrémenter // et remettre à zéro en cas de débordement. mode++; mode %= 9; // Cela prend en charge quelle que soit la valeur // c'était la toute première fois que l'Arduino // exécutait ce programme. /* * NOTE IMPORTANTE * ============== * * La chose essentielle que fait ce programme est de sortir des signaux PWM * aux lumières LED. Ici, je règle les broches 3 à 9 sur le mode de sortie *. Sur un Arduino Mega2560, ces broches produisent des signaux * joliment PWM. Si vous avez un autre Arduino, vérifiez * quelles broches (et combien) vous pouvez utiliser. Vous pouvez toujours * réécrire le code pour utiliser le logiciel PWM, si votre Arduino * ne peut pas fournir suffisamment de broches PWM matérielles. * */ pinMode(3, SORTIE); pinMode(4, SORTIE); pinMode(5, SORTIE); pinMode (6, SORTIE); pinMode(7, SORTIE); pinMode(8, SORTIE); pinMode(9, SORTIE); pinMode(LED_BUILTIN, SORTIE); analogWrite(LED_BUILTIN, 0); // Il suffit d'éteindre la led rouge gênante de la bougie Arduino *can[7]; // préparez-vous à utiliser les bougies vacillantes, que vous les utilisiez ou non twinkler *twink[7]; // préparez-vous à utiliser les bougies scintillantes… if (mode == 8) { for (int i = 3; i < 10; i++) analogWrite(i, 255); tandis que (vrai); // Chaque fois que ce programme s'exécute, il entre dans // ce type de boucle sans fin, jusqu'à ce que le bouton de réinitialisation // soit enfoncé. } if (mode < 2) // scintillement { long maxtime_; long mintime_; long maxlite_; long minlite_; long signifielite_; long even_; if (mode == 0) { maxtime_ = 250; mintime_ = 50; maxlite_ = 256; minlite_ = 0; Meanlite_ = 128; even_ = 1; } if (mode == 1) { maxtime_ = 400; mintime_ = 150; maxlite_ = 256; minlite_ = 100; Meanlite_ = 200; even_ = 1; } for (int i = 0; i < 7; i++) { can = nouvelle bougie(maxtime_, mintime_, maxlite_, minlite_, Meanlite_, even_); } while (true) // La boucle sans fin pour les bougies vacillantes { for (int i = 0; i levelnow()); } } if (mode < 4) // lfo ajouté au scintillement { if (mode == 2) // même lfo (30 s) pour toutes les bougies { for (int i = 0; i initlfo(75, 50, 0, 50, 36, 30000); } } if (mode == 3) // variant lfo:s pour les bougies { for (int i = 0; i initlfo(75, 50, 0, 50, 36, 20000); can[1]->initlfo(75, 50, 0, 50, 36, 25000); can[2]->initlfo(75, 50, 0, 50, 36, 30000); can[3]->initlfo(75, 50, 0, 50, 36, 35000); can[4]->initlfo(75, 40, 0, 50, 36, 40000); can[5]->initlfo(75, 30, 0, 50, 26, 45000); can[6]->initlfo(75, 20, 0, 50, 16, 50000); can[7]->initlfo(75, 10, 0, 50, 6, 55000); } tandis que (true) // La boucle sans fin pour les bougies vacillantes avec un lfo { long lastclock = 0; for (int i = 0; i levelnow()); if (millis() > lastclock + 4000) { lastclock = millis(); for (int i = 0; i setlfo(); } } } if (mode < 6) // bougies scintillantes { int speedo; if (mode == 4) speedo = 6000; else speedo = 22000; for (int i = 0; i < 7; i++) twink = new twinkler(300, 295, 255, 250, speedo); while (true) { for (int i = 0; i levelnow()); } } // Vagues. // Cette section commence par des accolades // juste pour s'assurer qu'il n'y a pas de noms de variables en conflit. // Pas besoin d'autres crochets, pas besoin de vérifier // la valeur de mode.{ int lolite = 2; int hilite = 255; int signifie; ampli int; flotteur fasedelta = 2,5; flotteur; int allongé; flotteur phactor; longue période; moyenne = (lolite + hilite) / 2; ampl = hilite - moyenne; si (mode == 6) période = 1500; sinon période = 3500; phactor = 6,28318530718 / période; while (true) { fase = phactor * (millis() % période); elong = moyenne + ampl * sin(fase); analogWrite(7, elong); analogWrite(9, elong); fase = phactor * ((millis() + période / 4) % période); elong = moyenne + ampl * sin(fase); analogWrite(3, elong); analogWrite(8, elong); fase = phactor * ((millis() + période / 2) % période); elong = moyenne + ampl * sin(fase); analogWrite(4, elong); analogWrite(5, elong); fase = phactor * ((millis() + 3 * période / 4) % période); elong = moyenne + ampl * sin(fase); analogWrite(6, elong); } // Lors de la connexion des fils de bougie à l'Arduino, // je les ai mélangés et je ne les ai jamais mis dans l'ordre. // L'ordre est important pour créer des motifs d'onde, // donc je viens d'écrire ce petit tableau pour moi: // // Candle# in the bridge: 2 3 5 4 7 6 1 // Data pin sur Arduino: 3 4 5 6 7 8 9 } } void loop() { // Puisque chaque programme d'éclairage est sa propre boucle infinie, // j'ai écrit toutes les boucles dans la section begin() // et je n'ai rien laissé pour cette section loop(). }

Étape 6: À propos de PWM

Les leds brillent lorsqu'elles sont alimentées en 3 V. Utilisant seulement 1,5 V, elles ne s'allument pas du tout. Les lumières LED ne s'estompent pas bien avec la tension de décoloration, comme le font les lumières incandescentes. Au lieu de cela, ils doivent être allumés à pleine tension, puis éteints. Lorsque cela se produit 50 fois par seconde, ils brillent joliment avec une luminosité de 50 %, plus ou moins. S'ils sont autorisés à être allumés seulement 5 ms et éteints 15 ms, ils pourraient briller avec une luminosité de 25 %. Cette technique est ce qui rend la lumière LED dimmable. Cette technique est appelée modulation de largeur d'impulsion ou PWM. Un microcontrôleur comme Arduino a généralement des broches de données, qui peuvent envoyer des signaux marche/arrêt. Certaines des broches de données ont des capacités intégrées pour PWM. Mais s'il n'y a pas assez de broches avec PWM intégré, il est généralement possible d'utiliser des bibliothèques de programmation dédiées pour créer des "broches PWM logicielles".

Dans mon projet, j'ai utilisé un Arduino Mega2560, doté d'un PWM matériel sur les broches 3 à 9. Si vous utilisez un Arduino UNO, vous n'avez que six broches PWM. Dans ce cas, si vous avez besoin d'une 7ème bougie (ou même plus), je peux vous recommander la bibliothèque PWM logicielle de Brett Hagman, que vous pouvez trouver ici.