Flikkerende kersbrug: 6 stappe (met prente)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:25

Hierdie instruksies wys hoe u 'n eenvoudige kersbrug met statiese lig kan omskep in 'n aangename gloeiende bui met eindelose variasies van flikkerende ligte, flikkerende, golfpatrone en nog baie meer. Ek het 'n kersbrug vir 8 € by After Christmas Sales gekoop. Dit het 7 led -ligte en 'n muuradapter van 33 V 3 W. Dit skitter met 'n helder en warm wit kleur en is perfek vir hierdie projek, waar ek 'n Arduino sal sit om die kerse te laat flikker. Die gewildste Arduino is die Arduino Uno. In hierdie projek gebruik ek 'n Arduino Mega 2560.

Ek gaan die 30 V -kragtoevoer laat vaar en gebruik 'n eenvoudige 5V -kragbank wat bedoel is vir selfone as die kragtoevoer.

'N Goeie ding om te weet oor kragbanke is dat hulle 'n binnekring het, wat die battery van 3,7 V na 5 V. transformeer. Omdat die proses 'n bietjie krag gebruik, sluit die kragbank homself as dit nie gebruik word nie. As die kragbank gebruik word vir Arduino -gebaseerde DIY -gadgets, kan die gadget nie net 'n energiebesparende slaap plaas nie en na 'n paar minute weer begin. Dit sal die kragbank afskakel. Hierdie flikkerende kersbrug het geen slaapmodus nie. Dit gebruik voortdurend krag en hou die kragbank aktief totdat die kragkabel afgetrek word.

Die video wys die kersbrug in statiese modus en in volle flikkering. Die volle flikkering is regtig irriterend vir die oë, terwyl die video dit 'n bietjie glad maak. Nadat die hardeware herstel is, insluitend die sny van kabels, die soldeer van nuwe verbindings en die toevoeging van 'n paar komponente, word al die gewenste ligpatrone geskep deur die kode vir die Arduino te skryf. Die patrone wat ek in hierdie instruksies insluit, is:

• 4 verskillende flikkerligte wat ware kerse naboots
• 2 verskillende blinkers (ewekansige flikkering van andersins statiese ligte)
• 2 verskillende golfpatrone
• eenvoudige statiese lig

Wisselpatrone vind plaas deur 'n drukknop, die element van die enkele gebruikerskoppelvlak. Hoe meer patrone 'n mens wil hê en hoe meer aanpasbaarheid jy wil hê, hoe meer knoppies en knoppe moet jy byvoeg. Maar die skoonheid lê in eenvoud. Hou die aantal selekteerbare patrone af. Kies die beste instellings tydens kodering en toetsing, nie deur baie kontroles by die hardeware te voeg nie.

Voorrade

• 1 LED kersbrug met 7 gloeilampe. Maak seker dat dit 'n laespanning -GS -model is, hetsy met batterye of met 'n muurbron, wat die dodelike 110 - 240 V AC na ongeveer 6 - 30 V DC verander. Dit is dus heeltemal veilig om die kersbrug te kap.
• 1 Arduino Mega (enige ander mikrobeheerder sal dit doen, maak seker dat u dit kan programmeer)
• 1 prototipe broodbord
• jumper drade en ander draad
• soldeergereedskap
• multimeter
• 7 weerstande, 120 Ω
• 1 drukknop (ek sal wys hoe u die ingeboude knoppie op 'n Arduino in plaas daarvan kan gebruik)
• ULN2803AP is 'n darlington -transistor -IC vir 7 transistors (as u 'n Arduino Uno of Meaga gebruik, het u dit nie regtig nodig nie)
• 'N 5 V -kragbank bedoel vir selfone

Stap 1: Ondersoek wat u gekry het

Ontdek watter spanning elke LED werk en hoeveel stroom daardeur vloei.

1. Maak die onderkant van die kersbrug oop. Soek die twee drade wat na een kers gaan.
2. Verwyder isolasie van die kabels wat die koperdrade openbaar sonder om die koperdrade af te sny.
3. Skakel die ligte aan (ontspan, dit is slegs 'n paar volt) en meet die spanning oor die geopende koperdrade.
4. Sny die kabel by een van die meetpunte (op hierdie punt gaan die ligte natuurlik af), verwyder isolasie (3 - 4 mm) aan beide kante. Meet die stroom wat deurloop. Wat u doen, is dat u die snykabel weer met u multimeter verbind, sodat alle stroom deur u multimeter kan vloei, wat u nou die hoeveelheid stroom vertel.

My lesings

Die spanning oor een kers (stap 3): 3,1 V

Let daarop dat die kragbron na die kersbrug 33 V. Dus is sewe keer 3,1 V slegs 21,7 V. Op sommige van die kerse moet daar 'n ekstra weerstand wees. As ek die kersspanning gemeet het, moes dit ongeveer 11 V. wees

Die stroom wat deurloop wanneer kers brand (stap 4): 19 mA

Ek gaan alles met 'n 5 V 2 A battery pak. Vir die kerse moet ek die spanning van 5 V na 3 V. laat sak.

2 V / 0,019 A = 105 Ω

Die krag wat verdwyn is:

2 V * 19 mA = 38 mW

Dit is weglaatbaar. Baie meer kan die weerstand self blaas. Maar sonder 'n weerstand van 105 Ω kan ek die LED blaas. Ek het 100 Ω en 120 Ω weerstande. Ek gaan met 120 Ω. Dit bied meer beskerming.

Deur al 7 kerse met 3 V te toets, het 'n helder lig verkry, behalwe vir een kers wat slegs 'n baie swak lig gehad het, met slegs 0,8 mA. Dit was my kers met die ekstra weerstand. Dit blyk dat die ander kerse glad nie weerstande het nie. Die LED -ligte wat in die kandelaar gebruik word, is eenvoudig bedoel vir 3 V! Die kers met die ekstra weerstand moes met ligte geweld oopgemaak word, maar niks het gebreek nie. Die weerstand is net onder die klein LED in die plastiek kersbol gevind. Ek moes dit losmaak en die drade losmaak. Dit was 'n bietjie deurmekaar, aangesien die soldeerbout 'n paar warm gom wat vir die samestelling gebruik is, opgewarm het.

Dus, nou weet ek dat ek, ongeag die kragbron wat ek gebruik, wat ook al die spanning is, die spanning tot 3 V moet laat daal sodat 19 mA kan deurloop.

As ek meer bekend was met LED -tegnologie, sou ek die tipe LED herken het en sou ek geweet het dat dit 3 V.

Stap 2: 'n bietjie soldeer

In hierdie stap verbind ek alle positiewe (+) drade van die 5 kerse aan een draad. Dan voeg ek 'n aparte negatiewe (-) draad by vir elke kers. 'N LED-lig brand slegs as die'+'en'-'regs draai. Aangesien u slegs twee identiese kabeluiteinde van elke kers het, moet u toets watter een '+' is en watter '-' is. Hiervoor benodig u 'n 3 V -kragbron. Ek het 'n klein batterypakket gehad met twee AAA -batterye. 'N 3 V -muntbattery werk ook uitstekend om te toets.

Die kersbrug benodig 8 kabels om tussen die Arduino en die brug te loop. As u 'n kabel met 8 geïsoleerde drade vind, is dit wonderlik. Een draad moet 120 mA hou, die res van hulle dra hoogstens 20 mA. Ek het gekies om 4 dubbele draadkabels te gebruik, wat ek toevallig gehad het.

Die eerste prentjie toon hoe ek 'n gewone draad voorberei het om alle '+' drade van die kerse te verbind. Verwyder die isolasie van die gewone draad vir elke kers. Voeg 'n stuk krimpisolasiebuis (die geel strook in die prentjie) by elke voeg en plaas dit op die regte plek van die gemeenskaplike kabel. Soldeer die '+' draad van elke kers aan die las, bedek die las met die krimpbuis en krimp dit. Natuurlik is eenvoudige kleeflint ook goed, alles word uiteindelik bedek.

Die tweede beeld toon die '-' drade wat elke kers benodig. Die gewone '+' draad gaan direk na die 5 V -pen van die Arduino (of miskien deur die broodbord). Elke '-' draad gaan na sy eie pen van die transistor IC (weer, waarskynlik deur die broodbord).

'N Arduino word dikwels 'n prototipe bord genoem. 'N Broodbord is ook iets wat u in prototipes gebruik. Wat ek in hierdie instruksies beskryf, is 'n prototipe. Ek sal dit nie tot 'n deftige, blink produk ontwikkel nie, met alles wat in 'n mooi plastiekhouer weggesteek is. Om dit van die prototipe na die volgende vlak te neem, sou beteken dat die broodbord vervang moet word met 'n printplaat en gesoldeerde komponente en selfs die Arduino vervang word deur slegs 'n eenvoudige mikrokontroller -chip (eintlik is die chip die brein van die Arduino). En dat alles in 'n plastiekhouer of in die gehakte kersbrug pas.

Stap 3: Die verbindings

Oor Arduinos, geneem vanaf hierdie bladsy:

• Totale maksimum stroom per input/output pin: 40mA
• Som van strome uit alle ingangs-/uitsetpenne saam: 200mA

My kerse trek 19 mA elk, as hulle aangedryf word deur 3 V. Daar is sewe daarvan, wat 133 mA maak. Ek kon hulle dus direk vanaf die uitvoerpenne dryf. Ek het egter 'n paar darlington transistor IC's. So ek het gedink, hoekom nie. My kring doen die ding op die regte manier: datapennetjies is slegs vir seine, nie vir krag nie. In plaas daarvan gebruik ek die 5 V -pen op die Arduino om die LED -ligte aan te dryf. Ek het my skootrekenaar aan die Arduino gekoppel as ek toets uitgevoer het. Alles word aangedryf deur die skootrekenaar -USB, wat 5 V. gee. Die Arduino Mega het 'n eie lont wat op 500 mA blaas om die rekenaar te beskerm. My kerse trek hoogstens 133 mA. Die Arduino is waarskynlik baie minder. Alles loop goed, as dit deur die skootrekenaar aangedryf word, dus dit is goed om 'n 5 V -battery te gebruik wat op die USB -poort van die Arduino gekoppel is.

Die datapennetjies D3 - D9 gaan na die IC ULN2803APGCN. Die LED's werk op 3 V. Elke gloeilamp is gekoppel aan die 5 V bron en verder aan 'n 120 Ω weerstand. Verder na een kanaal van die IC, wat uiteindelik die stroombaan met die grond verbind deur 'n darlington -transistor in die IC.

'N Drukknoppie word by die kring gevoeg om gebruikersaksie moontlik te maak. Die kersbrug kan dus 'n paar programme wat deur die gebruiker gekies kan word, hê.

Die drukknoppie in die kring is gekoppel aan RESET en GND. Dit is presies wat die ingeboude reset -knoppie doen. Aangesien ek nie alles in 'n plastiekkas omhul nie, gebruik ek die reset -knoppie op die Arduino om die program te beheer. As u 'n knoppie volgens die prentjie byvoeg, werk dit presies soos die knoppie vir die herstel van die bord. Die program werk deur te onthou watter ligte program die vorige keer gebruik is. Elke reset gaan dus deur na die volgende ligprogram.

Die foto's wys hoe die nuwe kabels uit die brug kom, hoe ek die transistor IC en die weerstande op die broodbord gelê het en hoe die jumper -drade aansluit by die Arduino Mega. Ek het 4 manlike-manlike draaddrade in 8 halwe drade gesny, wat ek aan die 8 kabels wat uit die kersbrug kom, gesoldeer het. Op hierdie manier kan ek net die kabels in die broodbord steek.

Alternatief sonder transistors

In die vorige stap het ek 'n gewone '+' draad vir die kerse voorberei en aparte '-' drade, wat deur die transistor IC na die grond gaan. As een datapennetjie hoog word, word die ooreenstemmende '-' draad deur die transistor gegrond en die LED-ligte.

Om die '-' drade direk aan die datapennetjies van die Arduino te koppel, sal ook werk, maar let altyd op hoeveel stroom die datapennetjies kan weerstaan! Hierdie benadering sal 'n verandering in my program nodig hê. Die datapennetjies moet laag word om die kerse aan te skakel. Om my program te gebruik soos dit is, moet u '+' en '-' in die kerse skakel. Het 'n gewone '-' draad vir die kerse, wat na GND op die Arduino gaan. En die afsonderlike drade loop tussen die '+' draad van die kers en 'n gegewenspen van die Arduino.

Stap 4: Die ligprogramme

My program, wat ek in die volgende stap aanbied, gaan deur 9 ligte programme. Deur op die knoppie te druk, word die ligte vir 'n sekonde gedoof, dan begin die volgende ligprogram. Die programme is soos volg:

1. Sterk flikker. Die kerse flikker lukraak. Dit lyk baie irriterend as jy hulle van naby af aanstaar, maar dit kan goed lyk op 'n afstand en miskien agter 'n ysige soldervenster. U buurman kan egter die brandweer bel.
2. Sagte flikker. Lyk baie goed. Soos regte kerse in 'n kamer sonder trek.
3. Wisselend flikker. Die kerse wissel saggies tussen sterk en sagte flikkerings met tussenposes van 30 sekondes.
4. Wisselend flikker. Soos nommer 3, maar elke kers wissel in sy eie tempo tussen 30 en 60 sekondes.
5. Vinnige glinster. Die kerse skyn op 'n statiese gedempte vlak en flikker willekeurig. Gemiddeld glinster elke sekonde.
6. Stadige glinster. Soos nommer 5, maar teen 'n baie stadiger tempo.
7. Vinnig waai van die middelste kers na die onderste.
8. Stadige golf van middelste boonste kers na die onderste.
9. Statiese helder lig. Ek moes dit insluit, wou nie van die oorspronklike funksie ontslae raak nie.

Stap 5: Die kode

/*

FLICKERING CANDLE BRIDGE */ // Verklaar die modus veranderlike om die toestand te hou // deur middel van 'n reset operasie _attribute _ ((afdeling (". Noinit"))) ongetekende int mode; // As die program begin na 'n herstelling, word hierdie geheue nie geïnisialiseer nie, maar bevat dit die waarde // wat dit voor die herstel gehad het. Die heel eerste keer dat die // program uitgevoer word, bevat dit 'n ewekansige waarde. / * * Die kersklas bevat alles wat nodig is * vir die berekening van 'n ligvlak vir * 'n flikkerende kers. */ klas kers {private: lang maxtime; lang tyd; lang maxliet; lang minliet; lang meanliet; lang origmaxtime; lang oorspronklike tyd; lang origmaxlite; lang origminliet; lang origmeanlite; lang deltamaxtime; lang deltamintime; lang deltamaxliet; lang deltaminliet; lang deltameanliet; lang lforate; lang uitstappie; lang begin; lang teiken; dryffaktor; lang doelwit; lang aanvangstyd; lang deltatyd; leegte nuwe teiken (leeg); lang doel (leeg); publiek: kers (lang mat, lang mit, lang mal, lang mil, lang mel, lang eo); lang vlak nou (leeg); leegte initlfo (lang deltamat, lang deltamit, lang deltamal, lang deltamil, lang deltamean, lang koers); void setlfo (void); }; kers:: kers (lang mat, 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 () gee die ligvlak wat die kers nou moet hê, terug. * Die funksie sorg vir die definisie van 'n nuwe ewekansige ligvlak en * die tyd wat dit moet neem om die vlak te bereik. Die verandering is nie lineêr nie, maar volg 'n sigmoïde kromme. As dit nie tyd is om 'n nuwe * vlak te definieer nie, gee die funksie eenvoudig die ligvlak terug. */ lang kers:: levelnow (void) {lang hulp, nou; dryf t1, t2; nou = millis (); as (nou> = doelwit) {help = target; newtarget (); terugkeer hulp; } anders {// help = target * (millis () - starttime) / deltatime + start * (target time - millis ()) / deltatime; t1 = float (doelwit - nou) / deltatime; t2 = 1. - t1; // Dit is die sigmoïde berekeninghulp = t1*t1*t1*begin + t1*t1*t2*begin*3 + t1*t2*t2*teiken*3 + t2*t2*t2*teiken; terugkeer hulp; }} leegte kers:: newtarget (void) {lang som; som = 0; vir (lang i = 0; i <evenout; i ++) som+= onetarget (); begin = teiken; target = som / ewewig; begintyd = millis (); doelwit = begintyd + ewekansig (mintime, maksimum tyd); deltatime = doelwit - begintyd; } lang kers:: onetarget (void) {if (random (0, 10) lastcheck + 100) {lastcheck = now; / * * Die afwyking van 'na -tempo -millisekondes': * Begin na -koers kyk / 2 millisekondes * Gedurende 'n tempo / 2 -millisekondes, maak * die kans dat 'n vonkel 50 %is. * As die koers 10000 ms is, word die muntstuk gedurende 50 ms * 50 keer omgedraai. * 1/50 = 0,02 * As ewekansige (10000) aanvang + koers / 2) {as (ewekansige (koers) doelwit) terugkeer lowlite; terugkeer (begin - lowlite) * (doel tyd - nou) / (doel tyd - begin tyd) + lowlite; } leemte twinkler:: twink (leegte) {starttime = millis (); doelwit = ewekansig (mintime, maxtime) + aanvangstyd; begin = random (minlite, maxlite); } ongeldige opstelling () {int led; // Lees die veranderlike van die magiese modus, wat moet vertel // watter ligte program die laaste keer uitgevoer is, verhoog dit // en stel dit terug na nul as dit oorloop. modus ++; modus %= 9; // Dit sorg vir watter waarde ookal // was die heel eerste keer dat die Arduino // hierdie program uitgevoer het. / * * BELANGRIKE NOTA * =============== * * Die belangrikste ding wat hierdie program doen, is om PWM * seine na LED -ligte uit te gee. Hier stel ek die penne 3 op 9 in die * afvoermodus. Op 'n Arduino Mega2560 lewer hierdie penne * mooi PWM -seine af. As u 'n ander Arduino het, kyk * watter penne (en hoeveel) u kan gebruik. U kan altyd die kode * herskryf om PWM -sagteware te gebruik, as u Arduino * nie genoeg PWM -penne vir hardeware kan verskaf nie. * */ pinMode (3, UITGANG); pinMode (4, UITGANG); pinMode (5, UITGANG); pinMode (6, UITGANG); pinMode (7, UITGANG); pinMode (8, UITGANG); pinMode (9, UITGANG); pinMode (LED_BUILTIN, OUTPUT); analogWrite (LED_BUILTIN, 0); // Skakel net die irriterende rooi led op die Arduino -kers *blik [7]; // berei u voor om die flikkerende kerse te gebruik, of u dit nou gebruik of nie twinkler *twink [7]; // berei u voor om die flikkerende kerse te gebruik … if (mode == 8) {vir (int i = 3; i <10; i ++) analogWrite (i, 255); terwyl (waar); // Elke keer as hierdie program loop, gaan dit in // hierdie soort eindelose lus totdat die reset // -knoppie ingedruk word. } as (modus <2) // flikker {lang maxtime_; lang tydsduur_; lang maxlite_; lang minlite_; lang meanlite_; lank selfs_; as (modus == 0) {maxtime_ = 250; minuut_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; gelyk_ = 1; } as (modus == 1) {maxtime_ = 400; mintime_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; gelyk_ = 1; } vir (int i = 0; i <7; i ++) {kan = nuwe kers (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } terwyl (waar) // Die eindelose lus vir flikkerende kerse {vir (int i = 0; i levelnow ()); }} if (mode <4) // lfo bygevoeg tot die flikker {if (mode == 2) // dieselfde lfo (30 s) vir alle kerse {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} if (mode == 3) // wisselende lfo: s vir die kerse {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);} terwyl (waar) // Die eindelose lus vir flikkerende kerse met 'n 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) // flikkerende kerse {int speedo; if (mode == 4) speedo = 6000; anders speedo = 22000; vir (int i = 0; i <7; i ++) twink = nuwe twinkler (300, 295, 255, 250, speedo); terwyl (waar) {vir (int i = 0; i levelnow ()); }}} // Golwe. // Hierdie afdeling begin met krulhakies net // om te verseker dat daar geen teenstrydige veranderlike name is nie. // Geen behoefte aan hakies nie, hoef nie gekontroleer te word nie // die waarde van die modus.{int lolite = 2; int hilite = 255; int beteken; int ampl; float fasedelta = 2.5; float fase; int elong; dryffaktor; lang tydperk; gemiddelde = (loliet + hiliet) / 2; ampl = hilite - gemiddelde; as (modus == 6) periode = 1500; anders periode = 3500; faktor = 6.28318530718 / periode; terwyl (waar) {fase = faktor * (millis () % periode); elong = gemiddelde + ampl * sin (fase); analogWrite (7, langwerpig); analogWrite (9, langwerpig); fase = faktor * ((millis () + periode / 4) % periode); elong = gemiddelde + ampl * sin (fase); analogWrite (3, langwerpig); analogWrite (8, langwerpig); fase = faktor * ((millis () + periode / 2) % periode); elong = gemiddelde + ampl * sin (fase); analogWrite (4, langwerpig); analogWrite (5, langwerpig); fase = faktor * ((millis () + 3 * periode / 4) % periode); elong = gemiddelde + ampl * sin (fase); analogWrite (6, langwerpig); } // Terwyl ek die kersdrade met die Arduino verbind het, // het ek hulle gemeng en nooit in orde gekry nie. // Die volgorde is belangrik vir die skep van golfpatrone, // daarom het ek net hierdie klein tafel vir my geskryf: // // Kers# in die brug: 2 3 5 4 7 6 1 // Dataspeld op Arduino: 3 4 5 6 7 8 9}} void lus () {// Aangesien elke ligprogram sy eie oneindige lus is, // het ek al die lusse in die begin () afdeling // geskryf en niks vir hierdie lus () afdeling gelaat nie. }

Stap 6: Oor PWM

Die LED's skyn helder as hulle met 3 V. aangedryf word. Met slegs 1,5 V brand hulle glad nie. LED -ligte vervaag nie mooi met die vervaagspanning nie, net soos gloeilampe. In plaas daarvan moet hulle met volle spanning aangeskakel word en dan afgeskakel word. As dit 50 keer per sekonde gebeur, skyn dit min of meer met 'n helderheid van 50 %. As hulle slegs 5 ms en 15 ms af is, kan dit skyn met 'n helderheid van 25 %. Hierdie tegniek maak LED -lig dimbaar. Hierdie tegniek word polswydte modulasie of PWM genoem. 'N Mikrokontroleerder soos Arduino het gewoonlik datapennetjies wat aan/af seine kan stuur. Sommige van die datapennetjies het ingeboude vermoëns vir PWM. Maar as daar nie genoeg penne met ingeboude PWM is nie, is dit gewoonlik moontlik om spesiale programmeerbiblioteke te gebruik om 'sagteware PWM -penne' te skep.

In my projek het ek 'n Arduino Mega2560 gebruik, met hardeware PWM op penne 3 - 9. As u 'n Arduino UNO gebruik, het u slegs ses PWM -penne. As u in die geval 'n 7de (of selfs meer) kers nodig het, kan ek die sagteware PWM -biblioteek van Brett Hagman aanbeveel, wat u hier kan vind.