Flimrende stearinbro: 6 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:27

Denne instruktive viser, hvordan man forvandler en simpel stearinbro med statisk lys til et dejligt glødende stemningslys med endeløse variationer af flimrende lys, blinkende, bølgemønstre og hvad ikke mere. Jeg købte en stearinlysbro efter After Christmas Sales for 8 €. Den har 7 LED -lamper og nogle 33 V 3 W vægadapter. Det skinner med en lys og varm hvid farve og vil være perfekt til dette projekt, hvor jeg vil sætte en Arduino for at få lysene til at flimre. Den mest populære Arduino er Arduino Uno. I dette projekt bruger jeg en Arduino Mega 2560.

Jeg vil droppe 30 V strømforsyningen og vil bruge en simpel 5 V strømbank beregnet til mobiltelefoner som strømforsyning.

En god ting at vide om power -banker er, at de har et indre kredsløb, som omdanner batteriet 3,7 V til 5 V. Fordi processen bruger lidt strøm, lukker powerbanken sig selv, hvis det ikke bruges. Hvis strømbanken bruges til Arduino -baserede DIY -gadgets, kan gadgeten ikke bare lægge sig selv i strømbesparende søvn og starte igen efter et par minutter. Det vil lukke strømbanken. Denne flimrende lysbro har ingen dvaletilstand. Den bruger konstant strøm og holder powerbanken aktiv, indtil strømkablet trækkes af.

Videoen viser lysbroen i statisk tilstand og i fuldt flimmer. Den fulde flimring er virkelig ret irriterende for øjnene, mens videoen glatter det lidt ud. Efter hardwaren er blevet repareret, herunder skæring af kabler, lodning af nye forbindelser og tilføjelse af nogle komponenter, skabes alle de ønskede lysmønstre ved at skrive kode til Arduino. De mønstre, jeg inkluderer i denne instruerbare, er:

• 4 forskellige flimrende lys, der efterligner ægte lys
• 2 forskellige blinkende (tilfældigt blinkende ellers statiske lys)
• 2 forskellige bølgemønstre
• simpelt statisk lys

Skiftemønstre sker via en trykknap, det enkelte brugergrænsefladeelement. Jo flere mønstre man ønsker og jo mere justerbarhed man ønsker, jo flere knapper og knapper skal man tilføje. Men skønheden ligger i enkelheden. Hold antallet af valgbare mønstre nede. Vælg de bedste indstillinger, mens du koder og tester, ikke ved at tilføje masser af kontroller til hardwaren.

Forbrugsvarer

• 1 LED lysbro med 7 pærer. Sørg for, at det er en lavspændings DC -model, enten med batterier eller med en vægmonteret strømkilde, som forvandler den dødelige 110 - 240 V AC til cirka 6 - 30 V DC. Så det er helt sikkert at hacke stearinbroen.
• 1 Arduino Mega (enhver anden mikrokontroller gør, bare sørg for at du kan programmere den)
• 1 prototyping brødbræt
• jumperwires og anden ledning
• loddeværktøj
• multimeter
• 7 modstande, 120 Ω
• 1 trykknap (jeg viser i stedet, hvordan du kan bruge den indbyggede knap på en Arduino)
• En darlington transistor IC til 7 transistorer, vil ULN2803AP gøre (Hvis du bruger en Arduino Uno eller Meaga, har du ikke rigtig brug for dette)
• En 5 V powerbank beregnet til mobiltelefoner

Trin 1: Undersøg, hvad du har

Find ud af, hvilken spænding hver LED driver, og hvor meget strøm der strømmer igennem.

1. Åbn bunden af lysbroen. Find de to ledninger, der går til det ene lys.
2. Fjern noget isolering fra kablerne, der afslører kobbertrådene uden at skære kobbertrådene.
3. Tænd lyset (slap af, det er kun et par volt) og mål spændingen over de afslørede kobbertråde.
4. Klip kablet på et af målepunkterne (på dette tidspunkt slukker lyset selvfølgelig), fjern lidt isolering (3 - 4 mm) i begge ender. Mål strømmen, der går igennem. Hvad du gør er at tilslutte det afskårne kabel igen med dit multimeter, så al strøm strømmer gennem dit multimeter, som nu fortæller dig mængden af strøm.

Mine aflæsninger

Spændingen over et lys (trin 3): 3,1 V

Bemærk, at strømkilden til lysbroen var 33 V. Så syv gange er 3,1 V kun 21,7 V. På nogle af stearinlysene skal der være en ekstra modstand. Havde jeg målt denne lysspænding, må den have været omkring 11 V.

Strømmen strømmer igennem, når stearinlys lyser (trin 4): 19 mA

Jeg kommer til at forsyne alt med et 5 V 2 A batteri. Til stearinlysene skal jeg sænke spændingen fra 5 V til 3 V. Jeg har brug for en modstand, som vil falde spændingen 2 V ved en 19 mA strøm.

2 V / 0,019 A = 105 Ω

Strømspredningen er:

2 V * 19 mA = 38 mW

Det er ubetydeligt. Meget mere kunne blæse modstanden selv. Men uden en 105 Ω modstand kan jeg blæse LED'en. Jeg har 100 Ω og 120 Ω modstande. Jeg går med 120 Ω. Det giver mere beskyttelse.

Test af alle 7 stearinlys med 3 V gav et skarpt lys, bortset fra et stearinlys, som kun havde et meget svagt lys, med kun 0,8 mA. Dette var mit lys med den ekstra modstand. Det viste sig, at de andre lys overhovedet ikke havde nogen modstande. LED -lysene, der bruges i lysekronen, er simpelthen beregnet til 3 V! Lyset med den ekstra modstand skulle åbnes ved hjælp af mild vold, men intet gik i stykker. Modstanden blev fundet lige under den lille lysdiode inde i plastlyspæren. Jeg var nødt til at aflodse den og løse ledningerne. Det var lidt rodet, da loddejernet varmede lidt varm lim op, som var blevet brugt til samlingen.

Så nu ved jeg, at uanset hvilken strømkilde jeg bruger, uanset spændingen, skal jeg sænke spændingen til 3 V, så 19 mA kan gå igennem.

Hvis jeg havde været mere fortrolig med LED -teknologi, ville jeg have genkendt den type LED, der blev brugt, og jeg ville have vidst, at den havde brug for 3 V.

Trin 2: Nogle lodninger

I dette trin forbinder jeg alle positive (+) ledninger fra de 5 lys til en ledning. Derefter tilføjer jeg en separat negativ (-) ledning til hvert lys. En LED-lampe lyser kun, når '+' og '-' går til højre. Da du kun har to identiske kabelender fra hvert lys, skal du teste, hvilken der er '+' og hvilken '-'. Til dette har du brug for en 3 V strømkilde. Jeg havde en lille batteripakke inklusive to AAA -batterier. Et 3 V møntbatteri fungerer også godt til test.

Stearinbroen har brug for 8 kabler til at køre mellem Arduino og broen. Hvis du finder et kabel med 8 isolerede ledninger, ville det være fantastisk. En ledning skal indeholde 120 mA, resten af dem bærer højst 20 mA. Jeg valgte at bruge 4 dobbeltkabel, som jeg tilfældigvis havde.

Det første billede viser, hvordan jeg forberedte en fælles ledning til at forbinde alle '+' ledninger fra lysene. Fjern en vis isolering af den fælles ledning for hvert lys. Tilføj et stykke krympisoleringsrør (den gule strimmel på billedet) til hver samling, og få det placeret på det rigtige sted i det fælles kabel. Lod '+' ledningen fra hvert lys til dets led, dæk fugen med krympeslangen og krymp den. Selvfølgelig er simpel klæbebånd også fint, alt bliver dækket til sidst.

Det andet billede viser '-' ledningerne, som hvert lys har brug for. Den almindelige '+' ledning går direkte til 5 V -stiften på Arduino (eller måske gennem brødbrættet). Hver '-' ledning går til sin egen pin på transistoren IC (igen, sandsynligvis gennem brødbrættet).

En Arduino kaldes ofte et prototypebord. Et brødbræt er også noget, du bruger i prototyper. Hvad jeg beskriver i denne instruerbare er en prototype. Jeg vil ikke udvikle det til et lækkert skinnende produkt med alt skjult i flotte plastkasser. At tage det fra prototypen til det næste niveau ville betyde udskiftning af brødbrættet med et printkort og loddet komponenter og endda udskiftning af Arduino med bare en simpel mikrokontroller -chip (faktisk er denne chip Arduino -hjernen). Og at få alt til at passe i en plastkasse eller inde i den hackede stearinbro.

Trin 3: Forbindelserne

Om Arduinos, taget fra denne side:

• Total maksimal strøm pr. Input/output pin: 40mA
• Summen af strømme ud af alle input/output pins kombineret: 200mA

Mine lys trækker 19 mA hver, når de drives af 3 V. Der er syv af dem, hvilket gør 133 mA. Så jeg kunne drive dem direkte fra output pins. Jeg har dog nogle ekstra darlington transistor IC'er. Så jeg tænkte, hvorfor ikke. Mit kredsløb gør tingene den rigtige måde: Datastifter er kun til signaler, ikke til strøm. I stedet bruger jeg 5 V -stiften på Arduino til at drive LED -lysene. Når testen kører, har jeg min bærbare tilsluttet Arduino. Alt er drevet fra den bærbare USB -USB, som giver 5 V. Arduino Mega har sin egen sikring, som blæser ved 500 mA for at beskytte computeren. Mine stearinlys trækker højst 133 mA. Arduinoen er sandsynligvis meget mindre. Alt kører fint, når det drives af den bærbare computer, så det er helt fint at bruge en 5 V batteripakke tilsluttet USB -porten på Arduino.

Datastifterne D3 - D9 går til IC ULN2803APGCN. Lysdioderne fungerer på 3 V. Hver pære er forbundet til 5 V -kilden og videre til en 120 Ω modstand. Videre til en kanal af IC'en, som endelig forbinder kredsløbet til jorden gennem en darlington -transistor i IC.

En trykknap tilføjes til kredsløbet for at muliggøre en vis brugerhandling. Lysbroen kunne således have et par programmer, der kan vælges af brugeren.

Trykknappen i kredsløbet er forbundet til RESET og GND. Det er præcis, hvad den indbyggede nulstillingsknap gør. Da jeg ikke indkapsler alt i et plastikhus, bruger jeg nulstillingsknappen på Arduino til at styre programmet. Tilføjelse af en knap i henhold til billedet fungerer nøjagtigt som knappen til nulstilling af tavlen. Programmet fungerer ved at huske hvilket lysprogram der blev brugt sidste gang programmet kørte. Hver nulstilling går således videre til det næste lysprogram.

Billederne viser, hvordan de nye kabler kommer ud af broen, hvordan jeg lagde transistoren IC og modstandene på brødbrættet, og hvordan jumper -ledningerne forbindes til Arduino Mega. Jeg skar 4 han-han-jumpertråde i 8 halve ledninger, som jeg lodde til de 8 kabler, der kom ud af lysbroen. På denne måde kan jeg bare stikke kablerne ind i brødbrættet.

Alternativ uden transistorer

I det foregående trin forberedte jeg en fælles '+' ledning til stearinlysene og separate '-' ledninger, som går gennem transistoren IC til jorden. Når en datapind går højt, bliver den tilsvarende '-' ledning jordet gennem sin transistor, og LED'en lyser.

Tilslutning af '-' ledningerne direkte til datastifterne på Arduino ville også fungere, men husk altid, hvor meget strøm datastifterne kan holde til! Denne tilgang ville kræve en ændring af mit program. Det ville have brug for datastifterne for at gå lavt for at tænde lysene. For at bruge mit program som det er, skal du skifte '+' og '-' i lysene. Hav en fælles '-' ledning til stearinlysene, som går til GND på Arduino. Og de separate ledninger løber mellem '+' ledningen på stearinlyset og en datapind af Arduino.

Trin 4: Lysprogrammerne

Mit program, som jeg præsenterer i det næste trin, gennemgår 9 lysprogrammer. Hvis du trykker på knappen, slukkes lysene i et sekund, hvorefter følgende lysprogram starter. Programmerne er som følger:

1. Stærkt flimring. Lysene flimrer tilfældigt. Dette ser meget irriterende ud, når du stirrer på dem fra tæt afstand, men kan se godt ud på afstand og måske bag et frostfrit loftsvindue. Dog kan din nabo ringe til brandvæsenet.
2. Blødt flimrende. Ser meget godt ud. Som rigtige stearinlys i et værelse uden træk.
3. Varierende flimmer. Stearinlysene veksler glat mellem stærkt og blødt flimring i cirka 30 s intervaller.
4. Varierende flimmer. Ligesom nr. 3, men hvert lys varierer i sit eget tempo mellem 30 s og 60 s.
5. Hurtigt glimt. Stearinlysene skinner på et statisk dæmpet niveau og glimter tilfældigt. I gennemsnit er der et glimt hvert sekund.
6. Langsomt glimt. Ligesom #5, men i en meget langsommere hastighed.
7. Hurtig bølge fra midten øverste lys til de nederste.
8. Langsom bølge fra midten øverste lys til de nederste.
9. Statisk skarpt lys. Jeg var nødt til at inkludere dette, ville ikke slippe af med den oprindelige funktion.

Trin 5: Koden

/*

FLICKERING CANDLE BRIDGE */ // Deklarér tilstandsvariablen til at holde tilstanden // ved hjælp af en nulstilling _attribute _ ((sektion (". Noinit"))) usigneret int -tilstand; // Når programmet starter efter en nulstilling, initialiseres dette stykke hukommelse ikke, men holder værdien // det havde før nulstillingen. Første gang // -programmet køres, har det en tilfældig værdi. / * * Stearinlysklassen rummer alt det nødvendige * til beregning af et lysniveau for * et flimrende lys. */ klasse lys {privat: lang maxtime; lang tid; lang maxlite; lang minlit; lang gennemsnitlig; lang origmaxtime; lang origintime; lang origmaxlit; lang origminlit; lang origmeanlite; lang deltamaxtime; lang deltamintime; lang deltamaxlit; lang deltaminlit; lang deltameanlit; lang lforat; lang udligning; lang start; langt mål; flydefaktor; lang måltid; lang starttid; lang deltid; void newtarget (void); lang onetarget (ugyldig); offentligt: stearinlys (lang måtte, lang mit, lang mal, lang mil, lang mel, lang eo); langt niveau nu (ugyldigt); ugyldig initlfo (lang deltamat, lang deltamit, lang deltamal, lang deltamil, lang deltamean, lang hastighed); void setlfo (void); }; stearinlys:: stearinlys (lang måtte, lang mit, lang mal, lang mil, lang mel, lang 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 () returnerer det lysniveau lyset skal have lige nu. * Funktionen sørger for at definere et nyt tilfældigt lysniveau og * den tid, det skal tage for at nå dette niveau. Ændringen er ikke lineær, * men følger en sigmoidkurve. Når det ikke er tid til at definere et nyt * niveau, returnerer funktionen simpelthen lysniveauet. */ langt lys:: levelnow (void) {lang hjælp, nu; flyde t1, t2; nu = millis (); hvis (nu> = måltid) {hjælp = mål; newtarget (); tilbagevenden hjælp; } andet {// hjælp = mål * (millis () - starttid) / deltatime + start * (måltid - millis ()) / deltatime; t1 = float (måltid - nu) / deltatime; t2 = 1. - t1; // Dette er sigmoide beregningshjælpen = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*mål*3 + t2*t2*t2*mål; tilbagevenden hjælp; }} void candle:: newtarget (void) {lang sum; sum = 0; for (lang i = 0; i <evenout; i ++) sum+= onetarget (); start = mål; target = sum / lige ud; starttid = millis (); måltid = starttid + tilfældig (mintime, maxtime); deltatime = måltid - starttid; } langt lys:: onetarget (void) {if (random (0, 10) lastcheck + 100) {lastcheck = nu; / * * Algo for blinkende "efter hastighed millisekunder": * Begynd at kontrollere efter hastighed / 2 millisekunder * I en periode med hastighed / 2 millisekunder, gør * chancen for et glimt til at være 50 %. * Hvis hastigheden er 10000 ms, vendes mønten i løbet af 5000 ms * 50 gange. * 1/50 = 0,02 * Hvis tilfældig (10000) starttid + sats / 2) {hvis (tilfældig (sats) måltid) returnerer lowlite; return (start - lowlite) * (måltid - nu) / (måltid - starttid) + lowlite; } void twinkler:: twink (void) {starttime = millis (); måltid = tilfældig (mintime, maxtime) + starttid; start = tilfældig (minlite, maxlite); } ugyldig opsætning () {int led; // Læs variablen i den magiske tilstand, som skal fortælle // hvilket lysprogram der blev kørt sidste gang, øg det // og nulstil, hvis overløb. tilstand ++; tilstand %= 9; // Dette tager sig af uanset værdien // var den allerførste gang Arduino // kørte dette program. / * * VIGTIG BEMÆRKNING * =============== * * Det væsentlige, dette program gør, er at udsende PWM * -signaler til LED -lys. Her sætter jeg stifterne 3 til 9 til * output -tilstand. På en Arduino Mega2560 udsender disse stifter * pænt PWM -signaler. Hvis du har en anden Arduino, skal du kontrollere * hvilke pins (og hvor mange) du kan bruge. Du kan altid * omskrive koden for at bruge software PWM, hvis din Arduino * ikke kan levere nok hardware PWM -ben. * */ 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); // Sluk bare for den irriterende røde LED på Arduino -stearinlys *dåsen [7]; // forbered dig på at bruge de flimrende stearinlys, uanset om du bruger dem eller ikke twinkler *twink [7]; // forbered dig på at bruge de blinkende stearinlys … if (mode == 8) {for (int i = 3; i <10; i ++) analogWrite (i, 255); mens (sandt); // Hver gang dette program kører, går det ind i // denne form for endeløs loop, indtil der trykkes på reset // -knappen. } hvis (tilstand <2) // flimrer {lang maxtime_; lang mintid_; lang maxlite_; lang minlite_; lang meanlite_; lang endda_; hvis (mode == 0) {maxtime_ = 250; mintid_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; lige_ = 1; } hvis (mode == 1) {maxtime_ = 400; mintid_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; lige_ = 1; } for (int i = 0; i <7; i ++) {kan = nyt lys (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } mens (true) // Den endeløse sløjfe til flimrende lys {for (int i = 0; i levelnow ()); }} hvis (tilstand <4) // lfo tilføjet til det flimrende {if (mode == 2) // samme lfo (30 s) for alle lys {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} if (mode == 3) // varierende lfo: s for stearinlysene {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); kan [1]-> initlfo (75, 50, 0, 50, 36, 25000); kan [2]-> initlfo (75, 50, 0, 50, 36, 30000); kan [3]-> initlfo (75, 50, 0, 50, 36, 35000); kan [4]-> initlfo (75, 40, 0, 50, 36, 40000); kan [5]-> initlfo (75, 30, 0, 50, 26, 45000); kan [6]-> initlfo (75, 20, 0, 50, 16, 50000); kan [7]-> initlfo (75, 10, 0, 50, 6, 55000);} mens (true) // Den endeløse sløjfe til flimrende lys med en 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) // blinkende stearinlys {int speedo; if (mode == 4) speedo = 6000; ellers speedo = 22000; for (int i = 0; i <7; i ++) twink = ny twinkler (300, 295, 255, 250, speedo); mens (true) {for (int i = 0; i levelnow ()); }} // Bølger. // Dette afsnit starter med krøllede parenteser bare // for at sikre, at der ikke er modstridende variabelnavne. // Intet andet behov for parenteser, ikke behov for at kontrollere // værdien af tilstand.{int lolite = 2; int hilite = 255; int betyder; int ampl; float fasedelta = 2,5; flyde fase; int forlænget; flydefaktor; lang periode; middelværdi = (lolit + hilit) / 2; ampl = hilite - middelværdi; hvis (mode == 6) periode = 1500; anden periode = 3500; phactor = 6,28318530718 / periode; mens (true) {fase = phactor * (millis () % periode); elong = middel + ampl * sin (fase); analogWrite (7, langstrakt); analogWrite (9, langstrakt); fase = faktor * ((millis () + periode / 4) % periode); elong = middel + ampl * sin (fase); analogWrite (3, langstrakt); analogWrite (8, langstrakt); fase = faktor * ((millis () + periode / 2) % periode); elong = middel + ampl * sin (fase); analogWrite (4, langstrakt); analogWrite (5, langstrakt); fase = faktor * ((millis () + 3 * periode / 4) % periode); elong = middel + ampl * sin (fase); analogWrite (6, langstrakt); } // Mens jeg tilsluttede stearinledningerne til Arduino, // fik jeg dem blandet og fik dem aldrig i orden. // Rækkefølgen er vigtig for at skabe bølgemønstre, // så jeg skrev lige denne lille tabel til mig: // // Candle# i broen: 2 3 5 4 7 6 1 // Datapind på Arduino: 3 4 5 6 7 8 9}} void loop () {// Da hvert lysprogram er sit eget uendelige loop, // skrev jeg alle loops i start () sektionen // og efterlod intet til denne loop () sektion. }

Trin 6: Om PWM

Lysdioderne skinner lyst, når de drives med 3 V. Ved kun 1,5 V lyser de slet ikke. LED -lys falmer ikke pænt med fadespændingen, ligesom glødelamper gør. I stedet skal de tændes med fuld spænding og derefter slukkes. Når dette sker 50 gange i sekundet, skinner de pænt med en 50 % lysstyrke, mere eller mindre. Hvis de kun får lov til at være på 5 ms og fra 15 ms, kan de skinne med en 25 % lysstyrke. Denne teknik gør LED -lys dæmpbart. Denne teknik kaldes pulsbreddemodulation eller PWM. En mikrokontroller som Arduino har normalt datastifter, som kan sende on/off signaler. Nogle af datastifterne har indbyggede funktioner til PWM. Men hvis der ikke er nok pins med indbygget PWM, er det normalt muligt at bruge dedikerede programmeringsbiblioteker til at oprette "software PWM -pins".

I mit projekt har jeg brugt en Arduino Mega2560, som har hardware PWM på ben 3 - 9. Hvis du bruger en Arduino UNO, har du kun seks PWM -ben. I så fald, hvis du har brug for et 7. (eller endnu mere) lys, kan jeg anbefale Brett Hagmans software PWM -bibliotek, som du kan finde her.