Podul lumânărilor pâlpâitoare: 6 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

Această instrucțiune arată cum să transformați un simplu pod de lumânări cu lumină statică într-o lumină de dispoziție strălucitoare, cu variații nesfârșite de lumini pâlpâitoare, sclipiri, modele de undă și ce nu. Am cumpărat de la After Christmas Sales un pod de lumânări cu 8 €. Are 7 lumini LED și un adaptor de perete de 33 V 3 W. Străluceste cu o culoare albă strălucitoare și caldă și va fi perfectă pentru acest proiect, unde voi pune un Arduino pentru ca lumânările să pâlpâie. Cel mai popular Arduino este Arduino Uno. În acest proiect, voi folosi un Arduino Mega 2560.

Voi renunța la sursa de alimentare de 30 V și voi folosi o sursă de alimentare simplă de 5 V destinată telefoanelor mobile ca sursă de alimentare.

Un lucru bun de știut despre băncile de alimentare este că au un circuit interior, care transformă bateria de 3,7 V la 5 V. Deoarece procesul folosește o anumită putere, banca de putere se închide singură, dacă nu este utilizată. Dacă banca de energie este utilizată pentru gadget-urile DIY bazate pe Arduino, gadgetul nu se poate pune doar în somn de economisire a energiei și poate porni din nou după câteva minute. Asta va opri banca de energie. Acest pod de lumânări pâlpâitor nu are modul de somn. Folosește constant energie, menținând banca de alimentare activă, până când cablul de alimentare este oprit.

Videoclipul arată podul lumânării în modul static și în pâlpâire completă. Pâlpâirea completă este într-adevăr destul de enervantă pentru ochi, în timp ce videoclipul o netezește puțin. După ce hardware-ul a fost reparat, inclusiv tăierea cablurilor, lipirea conexiunilor noi și adăugarea unor componente, toate modelele de lumină dorite sunt create prin scrierea codului pentru Arduino. Modelele pe care le includ în acest instructable sunt:

• 4 lumini pâlpâitoare diferite care imită lumânări reale
• 2 sclipiri diferite (clipire aleatorie a luminilor altfel statice)
• 2 modele de unde diferite
• lumină statică simplă

Comutarea modelelor are loc printr-un buton, elementul de interfață unică a utilizatorului. Cu cât se dorește mai multe modele și cu cât se dorește ajustabilitatea, cu atât mai multe butoane și butoane trebuie adăugate. Dar frumusețea constă în simplitate. Păstrați numărul de modele selectabile în jos. Alegeți cele mai bune setări în timp ce codificați și testați, nu adăugând o mulțime de controale la hardware.

Provizii

• 1 pod de lumânări cu LED cu 7 becuri. Asigurați-vă că este un model de curent continuu de joasă tensiune, fie cu baterii, fie cu o sursă de alimentare cu montare pe perete, care transformă mortalul 110 - 240 V c.a.în aproximativ 6 - 30 V c.c. Deci, este perfect sigur să sparg podul cu lumânări.
• 1 Arduino Mega (orice alt microcontroler va face, asigurați-vă că îl puteți programa)
• 1 panou de protejare
• fire jumper și alte fire
• instrument de lipit
• multimetru
• 7 rezistențe, 120 Ω
• 1 buton (voi arăta cum puteți folosi butonul încorporat pe un Arduino în schimb)
• Un CI de tranzistori darlington pentru 7 tranzistori, ULN2803AP va face (Dacă utilizați un Arduino Uno sau Meaga, nu aveți nevoie de acest lucru)
• O bancă de putere de 5 V destinată telefoanelor mobile

Pasul 1: examinează ceea ce ai

Aflați ce tensiune funcționează fiecare LED și cât de mult curent circulă.

1. Deschideți fundul podului cu lumânări. Găsiți cele două fire care merg la o lumânare.
2. Îndepărtați unele izolații din cabluri care dezvăluie firele de cupru fără a tăia firele de cupru.
3. Aprindeți luminile (relaxați-vă, sunt doar câțiva volți) și măsurați tensiunea peste firele de cupru dezvăluite.
4. Tăiați cablul la unul dintre punctele de măsurare (în acest moment luminile se sting, desigur), scoateți o izolație (3 - 4 mm) la ambele capete. Măsurați curentul care trece. Ceea ce faceți este să reconectați cablul tăiat la multimetru, lăsând tot curentul să curgă prin multimetru, care acum vă spune cantitatea de curent.

Lecturile mele

Tensiunea pe o lumânare (pasul 3): 3,1 V

Rețineți că sursa de alimentare a podului pentru lumânări a fost de 33 V. Deci, de șapte ori 3,1 V este de numai 21,7 V. Pe unele lumânări trebuie să existe un rezistor suplimentar. Dacă aș fi măsurat tensiunea lumânării, trebuie să fi fost de aproximativ 11 V.

Curentul care trece când se aprind lumânările (pasul 4): 19 mA

Voi alimenta totul cu un acumulator de 5 V 2 A. Pentru lumânări, trebuie să scap tensiunea de la 5 V la 3 V. Am nevoie de un rezistor, care să scadă tensiunea de 2 V la un curent de 19 mA.

2 V / 0,019 A = 105 Ω

Disiparea puterii este:

2 V * 19 mA = 38 mW

Acest lucru este neglijabil. Mult mai multe ar putea arunca rezistența în sine. Cu toate acestea, fără un rezistor de 105 Ω aș putea să arunc LED-ul. Am rezistențe de 100 Ω și 120 Ω. Merg cu 120 Ω. Oferă mai multă protecție.

Testarea tuturor celor 7 lumânări cu 3 V a dat o lumină puternică, cu excepția unei lumânări, care avea doar o lumină foarte slabă, trecând doar 0,8 mA. Aceasta a fost lumânarea mea cu rezistența suplimentară. S-a dovedit că celelalte lumânări nu aveau deloc rezistențe. Luminile LED utilizate în candelabru sunt destinate pur și simplu pentru 3 V! Lumânarea cu rezistența suplimentară a trebuit să fie deschisă folosind violență ușoară, dar nu s-a stricat nimic. Rezistorul a fost găsit chiar sub LED-ul minuscul din interiorul becului din plastic pentru lumânări. A trebuit să-l desoldez și să-i revând firele. A fost un pic dezordonat, deoarece fierul de lipit a încălzit niște adeziv fierbinte, care fusese folosit pentru asamblare.

Deci, acum știu că, indiferent de sursa de alimentare pe care o folosesc, indiferent de tensiune, trebuie să scad tensiunea la 3 V, permițând trecerea a 19 mA.

Dacă aș fi fost mai familiarizat cu tehnologia LED, aș fi recunoscut tipul de LED folosit și aș fi știut că are nevoie de 3 V.

Pasul 2: Unele lipiri

În acest pas conectez toate firele pozitive (+) de la cele 5 lumânări la un fir. Apoi adaug un fir negativ separat (-) pentru fiecare lumânare. O lumină LED se aprinde numai atunci când „+” și „-” merg la dreapta. Deoarece aveți doar două capete identice de cablu din fiecare lumânare, trebuie să testați care este „+” și care este „-”. Pentru aceasta aveți nevoie de o sursă de alimentare de 3 V. Aveam un pachet mic de baterii, inclusiv două baterii AAA. O baterie de 3 V monedă funcționează excelent și pentru testare.

Podul pentru lumânări are nevoie de 8 cabluri pentru a rula între Arduino și pod. Dacă găsiți un cablu cu 8 fire izolate, ar fi minunat. Un fir trebuie să conțină 120 mA, restul transportând doar cel mult 20 mA. Am ales să folosesc 4 cabluri cu două fire, pe care întâmplător le aveam.

Prima imagine arată cum am pregătit un fir comun pentru a conecta toate firele „+” de la lumânări. Scoateți o izolație a firului comun pentru fiecare lumânare. Adăugați o bucată de tub termoizolant (banda galbenă din imagine) pentru fiecare îmbinare și puneți-l la locul potrivit al cablului comun. Lipiți firul „+” de la fiecare lumânare la îmbinarea sa, acoperiți îmbinarea cu tubul de contracție și micșorați-l. Desigur, și banda adezivă simplă este bună, de asemenea, totul va fi acoperit în cele din urmă.

A doua imagine arată firele „-” de care are nevoie fiecare lumânare. Sârmă obișnuită „+” merge direct la pinul de 5 V al Arduino (sau poate prin panou). Fiecare fir „-” se îndreaptă către propriul pin al tranzistorului IC (din nou, probabil prin panoul de măsurare).

Un Arduino este adesea numit o placă de prototipare. O placă de măsurare este, de asemenea, ceva ce utilizați în prototipuri. Ceea ce descriu în acest instructable este un prototip. Nu-l voi transforma într-un produs strălucitor și elegant, cu totul ascuns în cutii frumoase din plastic. Luarea acestuia de la prototip la nivelul următor ar însemna înlocuirea plăcii cu o placă cu circuite imprimate și componente lipite și chiar înlocuirea Arduino cu doar un simplu cip de microcontroler (de fapt, un astfel de cip este creierul Arduino). Și având totul încap într-o cutie de plastic sau în interiorul podului de lumânări spart.

Pasul 3: Conexiunile

Despre Arduinos, preluat de pe această pagină:

• Curent maxim total per pin de intrare / ieșire: 40mA
• Suma de curenți din toți pinii de intrare / ieșire combinați: 200mA

Lumânările mele atrag 19 mA fiecare, când sunt alimentate cu 3 V. Există șapte dintre ele, ceea ce face 133 mA. Așa că le-aș putea alimenta direct de la pinii de ieșire. Cu toate acestea, am niște circuite integrate de tranzistor darlington de rezervă. Așa că m-am gândit, de ce nu. Circuitul meu face acest lucru în mod corect: pinii de date sunt doar pentru semnale, nu pentru alimentare. În schimb, folosesc pinul de 5 V de pe Arduino pentru alimentarea luminilor LED. Când rulez test, am laptopul conectat la Arduino. Totul este alimentat de la laptopul USB, care dă 5 V. Arduino Mega are o siguranță proprie, care suflă la 500 mA pentru a proteja computerul. Lumânările mele atrag cel mult 133 mA. Arduino probabil mult mai puțin. Totul funcționează bine, atunci când este alimentat de laptop, așa că utilizarea unui acumulator de 5 V conectat la portul USB al Arduino este bine.

Pinii de date D3 - D9 merg la IC ULN2803APGCN. LED-urile funcționează la 3 V. Fiecare bec este conectat la sursa de 5 V și apoi la un rezistor de 120 Ω. Mai departe către un canal al IC-ului, care conectează în cele din urmă circuitul la sol printr-un tranzistor darlington din IC.

Se adaugă un buton la circuit pentru a permite o acțiune a utilizatorului. Podul de lumânări ar putea avea astfel câteva programe selectabile de utilizator.

Butonul din circuit este conectat la RESET și GND. Exact asta face butonul de resetare încorporat. Deoarece nu încapsulez totul într-o carcasă din plastic, folosesc butonul de resetare de pe Arduino pentru controlul programului. Adăugarea unui buton conform imaginii va funcționa exact ca butonul de resetare a plăcii. Programul funcționează amintind ce program ușor a fost folosit ultima dată când a rulat programul. Astfel, fiecare resetare va trece la următorul program de iluminare.

Fotografiile arată modul în care noile cabluri ies din pod, cum am așezat tranzistorul IC și rezistențele pe panou și cum se conectează firele jumperului la Arduino Mega. Am tăiat 4 fire jumper-mascul în 8 jumătăți de fire, pe care le-am lipit la cele 8 cabluri care ieșeau din podul lumânării. În acest fel pot să lipesc doar cablurile în panou.

Alternativă fără tranzistoare

În pasul anterior, am pregătit un fir comun „+” pentru lumânări și fire separate „-”, care trec prin tranzistorul IC la sol. Când un pin de date se ridică, firul corespunzător „-” se împământă prin tranzistorul său și luminile LED.

Conectarea firelor „-” direct la pinii de date ai Arduino-ului ar funcționa, de asemenea, dar aveți întotdeauna în vedere cât de curent pot sta pinii de date! Această abordare ar necesita o schimbare în programul meu. Pentru a aprinde lumânările, ar fi nevoie de știfturile de date pentru a scădea. Pentru a utiliza programul meu așa cum este, trebuie să comutați „+” și „-” în lumânări. Aveți un fir comun pentru lumânări, care merge la GND pe Arduino. Și firele separate rulează între firul „+” al lumânării și un știft de date al Arduino.

Pasul 4: Programele Light

Programul meu, pe care îl prezint în pasul următor, trece prin 9 programe ușoare. Apăsând butonul se vor stinge luminile o secundă, apoi urmează următorul program de iluminare. Programele sunt după cum urmează:

1. Pâlpâit puternic. Lumânările pâlpâie la întâmplare. Acest lucru pare foarte enervant atunci când îi priviți de la distanță, dar s-ar putea să arate bine de la distanță și poate în spatele unei ferestre înghețate de la mansardă. Totuși, vecinul tău ar putea apela la pompieri.
2. Pâlpâire moale. Arată foarte bine. Ca lumânări adevărate într-o cameră fără curent.
3. Pâlpâind variabil. Lumânările alternează ușor între pâlpâirea puternică și moale la intervale de aproximativ 30 de secunde.
4. Pâlpâind variabil. La fel ca # 3, dar fiecare lumânare variază în ritmul său între 30 s și 60 s.
5. Sclipire rapidă. Lumânările strălucesc la un nivel static estompat și sclipesc aleatoriu. În medie, există o sclipire în fiecare secundă.
6. Sclipire lentă. Ca # 5, dar la o rată mult mai lentă.
7. Unda rapidă de la lumânarea superioară mijlocie la cele inferioare.
8. Unda lentă de la lumânarea superioară mijlocie la cele inferioare.
9. Lumină puternică statică. A trebuit să includ asta, nu am vrut să scap de funcția originală.

Pasul 5: Codul

/*

FLICKERING CANDLE BRIDGE * / // Declară variabila de mod pentru a menține starea // printr-o operațiune de resetare _attribute _ ((secțiunea (". Noinit"))) mod int nesemnat; // Când programul pornește după o resetare, această bucată // de memorie nu este inițializată, ci deține valoarea // pe care o avea înainte de resetare. Prima dată când programul // este rulat, acesta deține o valoare aleatorie. / * * Clasa lumânărilor conține tot ce este necesar * pentru calcularea nivelului de lumină pentru * o lumânare pâlpâitoare. * / lumânare de clasă {privat: maxtime lung; mentă lungă; maxlit lung; minlit lung; lung meanlit; lung origmaxtime; lung origmintime; lung origmaxlit; origminlit lung; lung origmeanlit; deltamaxtime lung; deltamintime lung; deltamaxlit lung; deltaminlit lung; deltameanlit lung; lforat lung; seara lungă; început lung; țintă lungă; phactor plutitor; timp îndelungat; timp de început lung; lung deltatime; void newtarget (nul); onetarget lung (nul); public: lumânare (lung mat, long mit, long mal, long mil, long mel, long eo); nivel lung acum (nul); voit initlfo (deltamat lung, deltamit lung, deltamal lung, deltamil lung, deltamean lung, ritm lung); void setlfo (nul); }; candle:: candle (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) {target = meanlite; newtarget (); } / * * levelnow () returnează nivelul de lumină pe care ar trebui să îl aibă lumânarea chiar acum. * Funcția se ocupă de definirea unui nou nivel aleatoriu de lumină și * timpul necesar pentru a atinge acel nivel. Modificarea nu este liniară, dar urmează o curbă sigmoidă. Când nu este timpul pentru definirea unui nou nivel *, funcția returnează pur și simplu nivelul de lumină. * / lumânare lungă:: levelnow (nul) {ajutor lung, acum; plutitor t1, t2; acum = millis (); if (now> = targettime) {help = target; newtarget (); returnează ajutorul; } else {// help = target * (millis () - starttime) / deltatime + start * (targettime - millis ()) / deltatime; t1 = float (targettime - now) / deltatime; t2 = 1. - t1; // Acesta este ajutorul pentru calcularea sigmoidului = t1 * t1 * t1 * start + t1 * t1 * t2 * start * 3 + t1 * t2 * t2 * target * 3 + t2 * t2 * t2 * target; returnează ajutorul; }} void candle:: newtarget (void) {sumă lungă; suma = 0; for (long i = 0; i <evenout; i ++) sum + = onetarget (); start = target; target = suma / evenout; ora de start = milis (); targettime = starttime + random (mintime, maxtime); deltatime = targettime - starttime; } lumânare lungă:: onetarget (nul) {if (random (0, 10) lastcheck + 100) {lastcheck = now; / * * Algoritmul pentru sclipirea „după rata milisecunde”: * Începeți verificarea după rata / 2 milisecunde * În timpul unei perioade de rată / 2 milisecunde, faceți * șansa ca o sclipire să fie de 50%. * Dacă rata este de 10000 ms, pe parcursul a 5000 ms moneda este * răsturnată de 50 de ori. * 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 = aleatoriu (minlite, maxlite); } void setup () {int led; // Citiți variabila modului magic, care ar trebui să spună // ce program ușor a fost rulat ultima dată, incrementați-l // și resetați la zero dacă se revarsă. mod ++; modul% = 9; // Aceasta are grijă de orice valoare // a fost prima dată când Arduino // a rulat acest program. / * * NOTĂ IMPORTANTĂ * ============= * * Lucrul esențial pe care îl face acest program este transmiterea semnalelor PWM * la luminile LED. Aici am setat pinii de la 3 la 9 la * modul de ieșire. Pe un Arduino Mega2560, acești pini emit * semnale PWM frumos. Dacă aveți un alt Arduino, verificați * ce pini (și câte) puteți utiliza. Puteți întotdeauna * rescrie codul pentru a utiliza software-ul PWM, dacă Arduino * nu poate furniza suficiente pini hardware PWM. * * / pinMode (3, OUTPUT); pinMode (4, OUTPUT); pinMode (5, OUTPUT); pinMode (6, OUTPUT); pinMode (7, OUTPUT); pinMode (8, OUTPUT); pinMode (9, OUTPUT); pinMode (LED_BUILTIN, OUTPUT); analogWrite (LED_BUILTIN, 0); // Opriți doar ledul roșu enervant de pe lumânarea Arduino * poate [7]; // pregătește-te să folosești lumânările pâlpâitoare, indiferent dacă le folosești sau nu twinkler * twink [7]; // pregătește-te să folosești lumânările sclipitoare … if (mode == 8) {pentru (int i = 3; i <10; i ++) analogWrite (i, 255); while (adevărat); // De fiecare dată când rulează acest program, acesta intră în // acest tip de buclă nesfârșită, până când este apăsat butonul de resetare //. } if (mode <2) // pâlpâind {long maxtime_; lung mintime_; lung maxlite_; lung minlite_; long meanlite_; lung chiar_; if (mode == 0) {maxtime_ = 250; mintime_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; chiar_ = 1; } if (mode == 1) {maxtime_ = 400; mintime_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; chiar_ = 1; } for (int i = 0; i <7; i ++) {can = new candle (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (adevărat) // Bucla nesfârșită pentru lumânări pâlpâitoare {pentru (int i = 0; i levelnow ()); }} if (mode <4) // lfo adăugat la pâlpâitor {if (mode == 2) // același lfo (30 s) pentru toate lumânările {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} if (mode == 3) // varianta lfo: s pentru lumânări {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);} while (true) // Bucla nesfârșită pentru lumânări pâlpâitoare cu 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) // lumânări sclipitoare {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 (adevărat) {for (int i = 0; i levelnow ()); } } // Valuri. // Această secțiune începe cu paranteze cretate doar // pentru a vă asigura că nu există nume de variabile conflictuale. // Nu există altă nevoie de paranteze, nu este nevoie să verificați // valoarea modului.{int lolite = 2; int hilite = 255; int mean; int ampl; float fasedelta = 2,5; float fase; int alung; phactor plutitor; perioada lunga; medie = (lolit + hilit) / 2; ampl = hilite - medie; if (mode == 6) period = 1500; else period = 3500; phactor = 6.28318530718 / perioadă; while (adevărat) {fase = phactor * (milis ()% perioadă); alung = mean + ampl * sin (fase); analogWrite (7, alung); analogWrite (9, alung); fase = phactor * ((millis () + perioadă / 4)% perioadă); alung = mean + ampl * sin (fase); analogWrite (3, alung); analogWrite (8, alung); fase = phactor * ((millis () + perioadă / 2)% perioadă); alung = mean + ampl * sin (fase); analogWrite (4, alung); analogWrite (5, alung); fase = phactor * ((millis () + 3 * perioadă / 4)% perioadă); alung = mean + ampl * sin (fase); analogWrite (6, alung); } // În timp ce conectam firele lumânării la Arduino, // le-am amestecat și nu le-am pus niciodată în ordine. // Ordinea este importantă pentru crearea modelelor de undă, // așa că tocmai am scris acest mic tabel pentru mine: // // Candle # in the bridge: 2 3 5 4 7 6 1 // Pinul de date pe Arduino: 3 4 5 6 7 8 9}} void loop () {// Deoarece fiecare program de lumină este propria sa buclă infinită, // am scris toate buclele în secțiunea begin () // și nu am lăsat nimic pentru această secțiune loop (). }

Pasul 6: Despre PWM

Ledurile strălucesc puternic când sunt alimentate cu 3 V. Folosind doar 1,5 V nu se aprind deloc. Luminile cu LED-uri nu se estompează frumos cu tensiunea de estompare, așa cum o fac luminile cu incandescență. În schimb, trebuie să fie pornite cu tensiune maximă, apoi oprite. Când acest lucru se întâmplă de 50 de ori pe secundă, strălucesc frumos cu o luminozitate de 50%, mai mult sau mai puțin. Dacă li se permite să fie pornit doar 5 ms și oprit 15 ms, ar putea străluci cu o luminozitate de 25%. Această tehnică este ceea ce face ca lumina LED să fie regulabilă. Această tehnică se numește modulația lățimii impulsului sau PWM. Un microcontroler precum Arduino are de obicei pini de date, care pot trimite semnale de pornire / oprire. Unele dintre pinii de date au capacități integrate pentru PWM. Dar dacă nu există suficienți pini cu PWM încorporat, este de obicei posibil să utilizați biblioteci de programare dedicate pentru a crea „pini software PWM”.

În proiectul meu, am folosit un Arduino Mega2560, care are hardware PWM pe pinii 3 - 9. Dacă utilizați un Arduino UNO, aveți doar șase pins PWM. În acest caz, dacă aveți nevoie de o a șaptea (sau chiar mai multă) lumânare, vă pot recomanda biblioteca PWM software Brett Hagman, pe care o puteți găsi aici.