Flimrende lysbro: 6 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:22

Denne instruksjonsfilen viser hvordan du gjør en enkel stearinbro med statisk lys til et godt glødende stemningslys med endeløse variasjoner av flimrende lys, blinkende, bølgemønstre og hva ikke mer. Jeg kjøpte en stearinbro fra After Christmas Sales for 8 €. Den har 7 LED -lys og en 33 V 3 W veggadapter. Den lyser med en lys og varm hvit farge og vil være perfekt for dette prosjektet, hvor jeg skal sette en Arduino for å få lysene til å flimre. Den mest populære Arduino er Arduino Uno. I dette prosjektet bruker jeg en Arduino Mega 2560.

Jeg kommer til å droppe 30 V strømforsyningen og vil bruke en enkel 5 V strømbank beregnet på mobiltelefoner som strømforsyning.

En god ting å vite om kraftbanker er at de har en indre krets, som transformerer batteriet 3,7 V til 5 V. Fordi prosessen bruker litt strøm, slår strømbanken seg av hvis den ikke brukes. Hvis strømbanken brukes til Arduino -baserte DIY -gadgets, kan gadgeten ikke bare sette seg i energisparende søvn og starte på nytt etter noen minutter. Det vil slå av strømbanken. Denne flimrende lysbroen har ingen hvilemodus. Den bruker konstant strøm, og holder strømbanken aktiv til strømkabelen trekkes av.

Videoen viser lysbroen i statisk modus og i full flimring. Hele flimringen er egentlig ganske irriterende for øynene, mens videoen jevner den litt ut. Etter at maskinvaren er fikset, inkludert kutting av kabler, lodding av nye tilkoblinger og tilføyelse av noen komponenter, opprettes alle de ønskede lysmønstrene ved å skrive kode for Arduino. Mønstrene jeg inkluderer i denne instruerbare er:

• 4 forskjellige flimrende lys som etterligner ekte lys
• 2 forskjellige blinkende (tilfeldig blinking av ellers statiske lys)
• 2 forskjellige bølgemønstre
• enkelt statisk lys

Byttemønstre skjer gjennom en trykknapp, elementet for enkelt brukergrensesnitt. Jo flere mønstre man ønsker og jo mer justerbarhet man vil ha, jo flere knapper og knapper må man legge til. Men skjønnheten ligger i enkelhet. Hold antallet valgbare mønstre nede. Velg de beste innstillingene mens du koder og tester, ikke ved å legge til mange kontroller på maskinvaren.

Rekvisita

• 1 LED lysbro med 7 pærer. Sørg for at det er en lavspennings DC -modell, enten med batterier eller med en veggmontert strømkilde, som forvandler den dødelige 110 - 240 V AC til omtrent 6 - 30 V DC. Så det er helt trygt å hacke lysbroen.
• 1 Arduino Mega (hvilken som helst annen mikrokontroller vil gjøre, bare sørg for at du kan programmere den)
• 1 prototyping brødbrett
• jumper ledninger og annen ledning
• loddeverktøy
• multimeter
• 7 motstander, 120 Ω
• 1 trykknapp (jeg viser hvordan du kan bruke den innebygde knappen på en Arduino i stedet)
• En darlington transistor IC for 7 transistorer, vil ULN2803AP gjøre (Hvis du bruker en Arduino Uno eller Meaga, trenger du egentlig ikke dette)
• En 5 V strømbank beregnet på mobiltelefoner

Trinn 1: Undersøk hva du har

Finn ut hvilken spenning hver LED driver og hvor mye strøm som strømmer gjennom.

1. Åpne bunnen av lysbroen. Finn de to ledningene som går til ett lys.
2. Fjern litt isolasjon fra kablene som avslører kobbertrådene uten å kutte kobbertrådene.
3. Slå på lysene (slapp av, det er bare noen få volt) og mål spenningen over de avslørte kobbertrådene.
4. Klipp av kabelen ved et av målepunktene (på dette tidspunktet slukker lysene, selvfølgelig), fjern litt isolasjon (3 - 4 mm) i begge ender. Mål strømmen som går gjennom. Det du gjør er å koble til den kuttede kabelen igjen med multimeteret ditt, slik at all strøm strømmer gjennom multimeteret ditt, som nå forteller deg mengden strøm.

Mine opplesninger

Spenningen over ett lys (trinn 3): 3,1 V

Vær oppmerksom på at strømkilden til lysbroen var 33 V. Så syv ganger er 3,1 V bare 21,7 V. På noen av lysene må det være en ekstra motstand. Hadde jeg målt lysspenningen, må den ha vært rundt 11 V.

Strømmen strømmer gjennom når lys lyser (trinn 4): 19 mA

Jeg kommer til å drive alt med en 5 V 2 A batteripakke. For lysene må jeg slippe spenningen fra 5 V til 3 V. Jeg trenger en motstand, som vil slippe spenningen 2 V ved en 19 mA strøm.

2 V / 0,019 A = 105 Ω

Effekten som spres er:

2 V * 19 mA = 38 mW

Det er ubetydelig. Mye mer kan blåse motstanden selv. Likevel, uten en 105 Ω motstand kan jeg blåse lysdioden. Jeg har 100 Ω og 120 Ω motstander. Jeg går med 120 Ω. Det gir mer beskyttelse.

Testing av alle de 7 lysene med 3 V ga sterkt lys, bortsett fra ett lys, som bare hadde et veldig svakt lys, med bare 0,8 mA. Dette var mitt lys med den ekstra motstanden. Det viste seg at de andre lysene ikke hadde motstander i det hele tatt. LED -lysene som brukes i lysekronen er rett og slett ment for 3 V! Lyset med den ekstra motstanden måtte åpnes med mild vold, men ingenting gikk i stykker. Motstanden ble funnet like under den lille LED -lampen inne i lyspæren i plast. Jeg måtte desolde den bort og løse ledningene. Det var litt rotete, siden loddejernet varmet opp litt varmt lim, som hadde blitt brukt til monteringen.

Så nå vet jeg at uansett hvilken strømkilde jeg bruker, uansett spenning, må jeg senke spenningen til 3 V slik at 19 mA kan gå igjennom.

Hvis jeg hadde vært mer kjent med LED -teknologi, ville jeg ha gjenkjent hvilken type LED som ble brukt, og jeg ville ha visst at den trengte 3 V.

Trinn 2: Litt lodding

I dette trinnet kobler jeg alle positive (+) ledninger fra de 5 lysene til en ledning. Deretter legger jeg til en egen negativ (-) ledning for hvert lys. Et LED-lys tennes bare når '+' og '-' går til høyre. Siden du bare har to identiske kabelender fra hvert lys, må du teste hvilken som er '+' og hvilken '-'. For dette trenger du en 3 V strømkilde. Jeg hadde en liten batteripakke inkludert to AAA -batterier. Et 3 V myntbatteri fungerer også utmerket for testing.

Stearinbroen trenger 8 kabler for å gå mellom Arduino og broen. Hvis du finner en kabel med 8 isolerte ledninger, ville det vært flott. En ledning må holde 120 mA, resten av dem bærer bare maksimalt 20 mA. Jeg valgte å bruke 4 dobbeltkabel, som jeg tilfeldigvis hadde.

Det første bildet viser hvordan jeg forberedte en felles ledning for å koble alle '+' ledninger fra lysene. Fjern litt isolasjon av den vanlige ledningen for hvert lys. Legg til et stykke krympingsisoleringsrør (den gule stripen på bildet) for hver ledd og legg det på riktig sted i den vanlige kabelen. Lodd '+' ledningen fra hvert lys til leddet, dekk leddet med krympeslangen og krymp det. Selvfølgelig er enkelt tape også greit, alt blir dekket til slutt.

Det andre bildet viser '-' ledningene som hvert lys trenger. Den vanlige '+' ledningen går direkte til 5 V -pinnen på Arduino (eller kanskje gjennom brødbrettet). Hver '-' ledning går til sin egen pin på transistoren IC (igjen, sannsynligvis gjennom brødbrettet).

En Arduino kalles ofte et prototypebrett. Et brødbrett er også noe du bruker i prototyper. Det jeg beskriver i denne instruerbare er en prototype. Jeg vil ikke utvikle det til et elegant, skinnende produkt med alt gjemt i fine plastkasser. Å ta den fra prototypen til neste nivå ville bety å bytte brødbrettet med et kretskort og loddet komponenter og til og med bytte ut Arduino med bare en enkel mikrokontrollerbrikke (faktisk er denne brikken Arduino -hjernen). Og å ha alt passe i en plastkasse eller inne i den hackede lysbroen.

Trinn 3: Tilkoblingene

Om Arduinos, hentet fra denne siden:

• Total maks strøm per input/output pin: 40mA
• Summen av strømmer ut av alle inngangs-/utgangspinner kombinert: 200mA

Lysene mine trekker 19 mA hver, når de drives av 3 V. Det er syv av dem, noe som gir 133 mA. Så jeg kunne drive dem direkte fra utgangspinnene. Imidlertid har jeg noen ekstra darlington transistor ICer. Så jeg tenkte, hvorfor ikke. Kretsen min gjør tingen på riktig måte: datapinner er bare for signaler, ikke for strøm. I stedet bruker jeg 5 V -pinnen på Arduino for å drive LED -lysene. Når jeg tester, har jeg den bærbare datamaskinen koblet til Arduino. Alt drives av den bærbare USB -en, som gir 5 V. Arduino Mega har en egen sikring, som blåser på 500 mA for å beskytte datamaskinen. Lysene mine trekker maksimalt 133 mA. Arduino sannsynligvis mye mindre. Alt går bra når det drives av den bærbare datamaskinen, så det er helt fint å bruke en 5 V batteripakke som er koblet til USB -porten på Arduino.

Datapinnene D3 - D9 går til IC ULN2803APGCN. Lysdiodene fungerer på 3 V. Hver pære er koblet til 5 V -kilden og videre til en 120 Ω motstand. Videre til en kanal av IC, som til slutt kobler kretsen til bakken gjennom en darlington -transistor i IC.

En trykknapp er lagt til kretsen for å aktivere noen brukerhandlinger. Lysbroen kan dermed ha noen få programmer som kan velges av brukeren.

Trykknappen i kretsen er koblet til RESET og GND. Dette er akkurat det den innebygde reset -knappen gjør. Siden jeg ikke innkapsler alt i en plastikk, bruker jeg tilbakestillingsknappen på Arduino for å kontrollere programmet. Å legge til en knapp i henhold til bildet vil fungere akkurat som knappen for tilbakestilling av brettet. Programmet fungerer ved å huske hvilket lysprogram som ble brukt sist gang programmet kjørte. Dermed vil hver tilbakestilling gå videre til neste lysprogram.

Bildene viser hvordan de nye kablene kommer ut av broen, hvordan jeg la transistoren IC og motstandene på brødbrettet og hvordan jumper -ledningene kobles til Arduino Mega. Jeg kuttet 4 mannlige-mannlige jumper-ledninger i 8 halve ledninger, som jeg loddet til de 8 kablene som kom ut av lysbroen. På denne måten kan jeg bare stikke kablene inn i brødbrettet.

Alternativ uten transistorer

I forrige trinn forberedte jeg en vanlig '+' ledning for lysene og separate '-' ledninger, som går gjennom transistoren IC til bakken. Når en datapinne går høyt, blir den tilsvarende '-' ledningen jordet gjennom transistoren og LED-lampene lyser.

Å koble '-' ledningene direkte til datapinnene på Arduino ville også fungere, men husk alltid hvor mye strøm datapinnene tåler! Denne tilnærmingen vil trenge en endring i programmet mitt. Det ville trenge datapinnene for å gå lavt for å slå på lysene. For å bruke programmet mitt som det er, må du bytte '+' og '-' i lysene. Ha en felles '-' ledning for lysene, som går til GND på Arduino. Og de separate ledningene går mellom '+' ledningen til stearinlyset og en datapinne på Arduino.

Trinn 4: Lysprogrammene

Programmet mitt, som jeg presenterer i neste trinn, går gjennom 9 lysprogrammer. Trykk på knappen for å slukke lysene i et sekund, og deretter starter følgende lysprogram. Programmene er som følger:

1. Sterk flimring. Lysene flimrer tilfeldig. Dette ser veldig irriterende ut når du stirrer på dem på nært hold, men kan se bra ut på avstand og kanskje bak et frostig vindusvindu. Selv om naboen din kan ringe brannvesenet.
2. Myk flimring. Ser veldig bra ut. Som ekte lys i et rom uten trekk.
3. Varierende flimring. Lysene veksler jevnt mellom sterk og myk flimring i noen 30 s intervaller.
4. Varierende flimring. Som nr. 3, men hvert lys varierer i sitt eget tempo mellom 30 s og 60 s.
5. Rask glimt. Lysene skinner på et statisk nedtonet nivå og glimter tilfeldig. I gjennomsnitt er det et glimt hvert sekund.
6. Sakte glimt. Som nr. 5, men med en mye lavere hastighet.
7. Rask bølge fra midten øverste lys til de nedre.
8. Sakte bølge fra midten øverste lys til de nedre.
9. Statisk sterkt lys. Jeg måtte inkludere dette, ville ikke bli kvitt den opprinnelige funksjonen.

Trinn 5: Koden

/*

FLICKERING CANDLE BRIDGE */ // Deklarer modusvariabelen for å holde tilstanden // gjennom en tilbakestillingsoperasjon _attribute _ ((seksjon (". Noinit"))) usignert int -modus; // Når programmet starter etter en tilbakestilling, initialiseres ikke dette minnet //, men det inneholder verdien // det hadde før tilbakestillingen. Første gang // -programmet kjøres, har det en tilfeldig verdi. / * * Stearinklassen inneholder alt som trengs * for å beregne et lysnivå for * et flimrende lys. */ klasse lys {privat: lang maxtime; lang tid; lang maxlite; lang minlit; lang gjennomsnittlig; lang origmaxtime; lang opprinnelig tid; lang origmaxlite; lang origminlitt; lang origmeanlite; lang deltamaxtime; lang deltid; lang deltamaxlitt; lang deltaminlitt; lang deltameanlitt; lang lforate; lang utjevning; lang start; langt mål; flytefaktor; lang måltid; lang starttid; lang deltid; void newtarget (void); lang onetarget (tomrom); offentlig: stearinlys (lang matte, lang mit, lang mal, lang mil, lang mel, lang eo); langt nivå nå (tomrom); ugyldig initlfo (lang deltamat, lang deltamit, lang deltamal, lang deltamil, lang deltamean, lang hastighet); void setlfo (void); }; stearinlys:: stearinlys (lang matte, lang mit, lang mal, lang mil, lang mel, lang eo): maxtime (matte), 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 lysnivået lyset skal ha akkurat nå. * Funksjonen tar seg av å definere et nytt tilfeldig lysnivå og * tiden det bør ta for å nå dette nivået. Endringen er ikke lineær, * men følger en sigmoidkurve. Når det ikke er på tide å definere et nytt * nivå, returnerer funksjonen ganske enkelt lysnivået. */ langt lys:: levelnow (void) {lang hjelp, nå; flyte t1, t2; nå = millis (); hvis (nå> = måltid) {help = target; newtarget (); returhjelp; } annet {// hjelp = mål * (millis () - starttid) / deltatime + start * (måltid - millis ()) / deltatime; t1 = float (måltid - nå) / deltatime; t2 = 1. - t1; // Dette er sigmoide beregningshjelp = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*mål*3 + t2*t2*t2*mål; returhjelp; }} void candle:: newtarget (void) {lang sum; sum = 0; for (lang i = 0; i <evenout; i ++) sum+= onetarget (); start = mål; target = sum / evenout; starttid = millis (); måltid = starttid + tilfeldig (mintid, maxtime); deltatime = måltid - starttid; } langt lys:: onetarget (void) {if (random (0, 10) lastcheck + 100) {lastcheck = now; / * * Algo for blinkende "after rate milliseconds": * Begynn å sjekke etter rate / 2 milliseconds * I løpet av en rate / 2 millisekunder, gjør * sjansen for et glimt til å være 50 %. * Hvis hastigheten er 10000 ms, vendes mynten i løpet av 5000 ms 50 ganger. * 1/50 = 0,02 * Hvis tilfeldig (10000) starttid + rate / 2) {if (tilfeldig (rate) måltid) returnerer lowlite; retur (start - lowlite) * (måltid - nå) / (måltid - starttid) + lowlite; } void twinkler:: twink (void) {starttime = millis (); måltid = tilfeldig (mintid, maxtime) + starttid; start = tilfeldig (minlite, maxlite); } ugyldig oppsett () {int led; // Les variabelen i den magiske modusen, som skal fortelle // hvilket lysprogram som ble kjørt sist, øk den // og tilbakestill til null hvis overløp. modus ++; modus %= 9; // Dette tar seg av verdien uansett verdien // var den aller første gangen Arduino // kjørte dette programmet. / * * VIKTIG MERKNAD * =============== * * Det viktigste programmet gjør er å sende PWM * -signaler til LED -lys. Her satte jeg pinnene 3 til 9 til * utgangsmodus. På en Arduino Mega2560 gir disse pinnene * fine PWM -signaler. Hvis du har en annen Arduino, sjekk * hvilke pinner (og hvor mange) du kan bruke. Du kan alltid * skrive om koden for å bruke programvare PWM, hvis Arduino * ikke kan levere nok maskinvare PWM -pinner. * */ pinMode (3, UTGANG); pinMode (4, UTGANG); pinMode (5, OUTPUT); pinMode (6, OUTPUT); pinMode (7, OUTPUT); pinMode (8, OUTPUT); pinMode (9, OUTPUT); pinMode (LED_BUILTIN, OUTPUT); analogWrite (LED_BUILTIN, 0); // Bare slå av den irriterende røde lampen på Arduino -stearinlys *-boksen [7]; // forbered deg på å bruke de flimrende lysene, enten du bruker dem eller ikke twinkler *twink [7]; // forbered deg på å bruke de blinkende lysene … if (mode == 8) {for (int i = 3; i <10; i ++) analogWrite (i, 255); mens (sant); // Hver gang dette programmet kjøres, går det inn i // denne typen uendelig sløyfe, til reset // -knappen trykkes. } hvis (modus <2) // flimrer {lang maxtime_; lang tid_; lang maxlite_; lang minlite_; lang meanlite_; lang jevn_; hvis (modus == 0) {maxtime_ = 250; mintime_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; jevn_ = 1; } hvis (modus == 1) {maxtime_ = 400; mintid_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; jevn_ = 1; } for (int i = 0; i <7; i ++) {kan = nytt lys (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } mens (true) // Den endeløse sløyfen for flimrende lys {for (int i = 0; i levelnow ()); }} hvis (modus <4) // lfo lagt til flimringen {if (mode == 2) // samme lfo (30 s) for alle lys {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} if (modus == 3) // varierende lfo: s for lysene {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øyfen for 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 (modus <6) // blinkende lys {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. // Denne delen starter med krøllete parenteser bare // for å sikre at det ikke er motstridende variabelnavn. // Ikke noe annet behov for parenteser, ikke behov for å kontrollere // verdien av modus.{int lolite = 2; int hilite = 255; int mener; int ampl; float fasedelta = 2,5; flyte fase; int forlenget; flytefaktor; lang periode; gjennomsnitt = (lolitt + hilitt) / 2; ampl = hilite - gjennomsnitt; hvis (modus == 6) periode = 1500; annen periode = 3500; faktor = 6,28318530718 / periode; mens (true) {fase = faktor * (millis () % periode); elong = gjennomsnitt + ampl * sin (fase); analogWrite (7, langstrakt); analogWrite (9, langstrakt); fase = faktor * ((millis () + periode / 4) % periode); elong = gjennomsnitt + ampl * sin (fase); analogWrite (3, langstrakt); analogWrite (8, langstrakt); fase = faktor * ((millis () + periode / 2) % periode); elong = gjennomsnitt + ampl * sin (fase); analogWrite (4, langstrakt); analogWrite (5, langstrakt); fase = faktor * ((millis () + 3 * periode / 4) % periode); elong = gjennomsnitt + ampl * sin (fase); analogWrite (6, langstrakt); } // Mens jeg koblet lysene til Arduino, // jeg blandet dem og fikk dem aldri i orden. // Rekkefølgen er viktig for å lage bølgemønstre, // så jeg skrev nettopp dette lille bordet for meg: // // Stearinlys# i broen: 2 3 5 4 7 6 1 // Datapinne på Arduino: 3 4 5 6 7 8 9}} void loop () {// Siden hvert lysprogram er sin egen uendelige loop, // skrev jeg alle loopene i start () delen // og lot ingenting stå for denne loop () delen. }

Trinn 6: Om PWM

Lysdiodene lyser sterkt når de drives med 3 V. Ved bare 1,5 V lyser de ikke i det hele tatt. LED -lys blekner ikke pent med fadespenningen, slik glødelamper gjør. I stedet må de slås på med full spenning og deretter slås av. Når dette skjer 50 ganger i sekundet, skinner de pent med 50 % lysstyrke, mer eller mindre. Hvis de bare får være på 5 ms og av 15 ms, kan de skinne med 25 % lysstyrke. Denne teknikken gjør LED -lyset dimbart. Denne teknikken kalles pulsbreddemodulasjon eller PWM. En mikrokontroller som Arduino har vanligvis datapinner, som kan sende av/på -signaler. Noen av datapinnene har innebygde muligheter for PWM. Men hvis det ikke er nok pins med innebygd PWM, er det vanligvis mulig å bruke dedikerte programmeringsbiblioteker til å lage "programvare PWM -pins".

I prosjektet mitt har jeg brukt en Arduino Mega2560, som har hardware PWM på pinner 3 - 9. Hvis du bruker en Arduino UNO, har du bare seks PWM -pinner. I så fall, hvis du trenger et 7. (eller enda mer) lys, kan jeg anbefale Brett Hagmans programvare PWM -bibliotek, som du finner her.