Flickering Candle Bridge: 6 Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:12

Ang itinuturo na ito ay nagpapakita kung paano i-on ang isang simpleng tulay ng kandila na may static na ilaw sa isang magandang kumikinang na ilaw ng ilaw na may walang katapusang pagkakaiba-iba ng mga kumikislap na ilaw, kislap, mga pattern ng alon at kung anu-ano pa. Bumili ako mula sa After Christmas Sales ng isang kandila tulay para sa 8 €. Mayroon itong 7 led light at ilang 33 V 3 W wall adapter. Nagniningning ito ng isang maliwanag at maligamgam na puting kulay at magiging perpekto para sa proyektong ito, kung saan ilalagay ko ang isang Arduino upang gawing kurap ang mga kandila. Ang pinakatanyag na Arduino ay ang Arduino Uno. Sa proyektong ito, gagamit ako ng isang Arduino Mega 2560.

Pupunta ako sa kanal ng 30 V power supply at gagamit ng isang simpleng 5 V power bank na para sa mga mobile phone bilang power supply.

Ang isang magandang bagay na dapat malaman tungkol sa mga power bank ay mayroon silang panloob na circuit, na binabago ang baterya 3.7 V hanggang 5 V. Dahil ang proseso ay gumagamit ng ilang lakas, ang power bank ay nagsasara mismo, kung hindi ito ginagamit. Kung ang power bank ay ginagamit para sa mga gadget ng DIY na nakabatay sa Arduino, ang gadget ay hindi maaaring ilagay lamang sa pag-save ng kuryente sa pagtulog at magsimulang muli pagkalipas ng ilang minuto. Isasara nito ang power bank. Ang kumikislap na kandila na tulay ay walang mode sa pagtulog. Gumagamit ito ng patuloy na lakas, pinapanatili ang power bank na aktibo, hanggang sa makuha ang power cable.

Ipinapakita ng video ang tulay ng kandila sa static mode at sa buong pagkutitap. Ang buong kisap-mata ay talagang nakakainis para sa mga mata, habang ang video ay nagpapakinis ng kaunti. Matapos naayos ang hardware, kabilang ang pagputol ng mga cable, paghihinang ng mga bagong koneksyon at pagdaragdag ng ilang mga bahagi, ang lahat ng nais na mga pattern ng ilaw ay nilikha sa pamamagitan ng pagsulat ng code para sa Arduino. Ang mga pattern na isinasama ko sa itinuturo na ito ay:

• 4 na magkakaibang mga kumikislap na ilaw na gumagaya sa totoong mga kandila
• 2 magkakaibang kisap (random na pag-flash ng kung hindi man static na ilaw)
• 2 magkakaibang mga pattern ng alon
• simpleng static light

Ang mga pattern ng paglipat ay nangyayari sa pamamagitan ng isang pindutan ng push, ang solong elemento ng interface ng gumagamit. Ang mas maraming mga pattern na nais ng isa at mas maraming kakayahang maiangkop ang nais ng isa, mas maraming mga pindutan at mga knobs na dapat idagdag. Ngunit ang kagandahan ay nakasalalay sa pagiging simple. Panatilihing pababa ang bilang ng mga mapipiling pattern. Piliin ang pinakamahusay na mga setting habang naka-coding at sumusubok, hindi sa pamamagitan ng pagdaragdag ng maraming mga kontrol sa hardware.

Mga gamit

• 1 LED candle bridge na may 7 bombilya. Siguraduhin na ito ay isang mababang boltahe na modelo ng DC, alinman sa mga baterya o may isang mapagkukunang kuryente sa pag-mount ng pader, na nagbabago sa nakamamatay na 110 - 240 V AC sa ilang 6 - 30 V DC. Kaya't perpektong ligtas na i-hack ang tulay ng kandila.
• 1 Arduino Mega (gagawin ng anumang iba pang microcontroller, siguraduhin lamang na mai-program mo ito)
• 1 prototyping breadboard
• jumper wires at iba pang kawad
• kasangkapan sa paghihinang
• multimeter
• 7 resistors, 120 Ω
• 1 push button (ipapakita ko kung paano mo magagamit ang built in na button sa isang Arduino sa halip)
• Isang darlington transistor IC para sa 7 transistors, gagawin ng ULN2803AP (Kung gagamit ka ng Arduino Uno o Meaga, hindi mo talaga ito kailangan)
• Ang isang 5 V power bank ay inilaan para sa mga mobile phone

Hakbang 1: Suriing Ano ang Nakuha

Alamin kung anong boltahe ang nagpapatakbo ng bawat LED at kung magkano ang kasalukuyang dumadaloy.

1. Buksan ang ilalim ng tulay ng kandila. Hanapin ang dalawang wires na pupunta sa isang kandila.
2. Alisin ang ilang pagkakabukod mula sa mga cable na inilalantad ang mga wire ng tanso nang hindi pinuputol ang mga wire na tanso.
3. I-on ang mga ilaw (magpahinga, ilan lamang ang volts) at sukatin ang boltahe sa mga isiniwalat na wire ng tanso.
4. Gupitin ang cable sa isa sa mga puntos ng pagsukat (sa puntong ito ang mga ilaw ay patay, syempre), alisin ang ilang pagkakabukod (3 - 4 mm) sa magkabilang dulo. Sukatin ang kasalukuyang pagdaan. Ang ginagawa mo ay muling ikonekta mo ang cut cable sa iyong multimeter, pinapayagan ang lahat ng kasalukuyang daloy sa pamamagitan ng iyong multimeter, na nagsasabi sa iyo ngayon ng dami ng kasalukuyang.

Ang mga binasa ko

Ang boltahe sa isang kandila (hakbang 3): 3.1 V

Tandaan na ang pinagmulan ng kuryente sa tulay ng kandila ay 33 V. Kaya't pitong beses na 3.1 V ay 21.7 lamang V. Sa ilan sa mga kandila dapat mayroong isang labis na risistor. Kung nasukat ko ba ang boltahe ng kandila, dapat na mayroong 11 V.

Ang kasalukuyang dumadaloy kapag ang mga ilaw ng kandila (hakbang 4): 19 mA

Papalakasin ko ang lahat gamit ang isang 5 V 2 Isang baterya. Para sa mga kandila, kailangan kong ihulog ang boltahe mula 5 V hanggang 3 V. Kailangan ko ng isang risistor, na ibabagsak ang boltahe 2 V sa isang kasalukuyang 19 mA.

2 V / 0.019 A = 105 Ω

Ang lakas na kumakalat ay:

2 V * 19 mA = 38 mW

Bale-wala yun. Marami pang maaaring pumutok ang risistor mismo. Gayunpaman, nang walang resistor na 105 Ω maaari kong pumutok ang LED. Mayroon akong 100 Ω at 120 Ω resistors. Sumasama ako sa 120 Ω. Nagbibigay ito ng higit na proteksyon.

Ang pagsubok sa lahat ng 7 kandila na may 3 V ay nagbigay ng isang maliwanag na ilaw, maliban sa isang kandila, na mayroon lamang isang napakalabo na ilaw, na may lamang 0.8 mA na dumaan. Ito ang aking kandila kasama ang sobrang resistor. Ito ay naka-out na ang iba pang mga kandila ay wala talagang resistors. Ang mga ilaw na LED na ginamit sa chandelier ay simpleng sinadya para sa 3 V! Ang kandila na may labis na risistor ay dapat buksan gamit ang banayad na karahasan, ngunit walang nasira. Ang risistor ay natagpuan sa ilalim lamang ng maliit na LED sa loob ng plastik na bombilya. Kailangan kong sirain ito nang malayo at i-resolder ang mga wire. Ito ay medyo magulo, dahil ang soldering iron ay nagpainit ng isang mainit na pandikit, na ginamit para sa pagpupulong.

Kaya ngayon alam ko na kung ano ang ginagamit kong mapagkukunan ng kuryente, anuman ang boltahe, kailangan kong ibagsak ang boltahe pababa sa 3 V na nagpapahintulot sa 19 mA na dumaan.

Kung naging pamilyar ako sa teknolohiya ng LED, makikilala ko ang uri ng LED na ginamit at malalaman ko na kailangan ito ng 3 V.

Hakbang 2: Ilang Paghihinang

Sa hakbang na ito ikonekta ko ang lahat ng positibo (+) na mga wire mula sa 5 kandila sa isang kawad. Pagkatapos ay nagdagdag ako ng isang hiwalay na negatibong (-) wire para sa bawat kandila. Ang isang ilaw na LED ay ilaw lamang kapag ang '+' at '-' pumunta sa kanan. Dahil mayroon kang dalawang magkaparehong mga dulo ng cable mula sa bawat kandila, kailangan mong subukan kung alin ang '+' at alin ang '-'. Para sa mga ito kailangan mo ng isang mapagkukunang 3 V kapangyarihan. Mayroon akong isang maliit na pakete ng baterya kasama ang dalawang mga baterya ng AAA. Ang isang 3 V coin na baterya ay gumagana nang mahusay para sa pagsubok.

Ang tulay ng kandila ay nangangailangan ng 8 mga kable upang tumakbo sa pagitan ng Arduino at ng tulay. Kung makakita ka ng isang cable na may 8 insulated wires, mahusay iyon. Ang isang kawad ay dapat na humawak ng 120 mA, ang natitira sa kanila ay nagdadala lamang ng 20 mA ng higit. Pinili kong gumamit ng 4 na dobleng wire cable, na nagkataon na mayroon ako.

Ipinapakita ng unang imahe kung paano ako naghanda ng isang karaniwang kawad upang ikonekta ang lahat ng mga wire na '+' mula sa mga kandila. Tanggalin ang ilang pagkakabukod ng karaniwang kawad para sa bawat kandila. Magdagdag ng isang piraso ng shrink insulation tube (ang dilaw na strip sa imahe) para sa bawat magkasanib at ilagay ito sa tamang lugar ng karaniwang cable. Ihihinang ang wire na '+' mula sa bawat kandila patungo sa pinagsamang ito, takpan ang magkasanib na tubo ng pag-urong at paliitin ito. Siyempre, ang simpleng adhesive tape ay mabuti, masyadong, ang lahat ay tatakpan sa huli.

Ipinapakita ng pangalawang imahe ang '-' mga wire na kailangan ng bawat kandila. Ang karaniwang '+' wire ay dumidiretso sa 5 V pin ng Arduino (o marahil sa pamamagitan ng breadboard). Ang bawat '-' wire ay papunta sa sarili nitong pin ng transistor IC (muli, marahil sa pamamagitan ng breadboard).

Ang isang Arduino ay madalas na tinatawag na isang prototyping board. Ang isang breadboard ay ginagamit mo rin sa mga prototype. Ang inilalarawan ko sa itinuturo na ito ay isang prototype. Hindi ko ito bubuo sa isang marangyang makintab na produkto na may lahat ng nakatago sa magagandang mga plastik na kaso. Ang pagkuha nito mula sa prototype sa susunod na antas ay nangangahulugang pagpapalit ng breadboard ng isang naka-print na circuit board at mga soldered na bahagi at kahit na pinapalitan ang Arduino ng isang simpleng chip na microcontroller (talagang ang naturang chip ay ang utak ng Arduino). At ang pagkakaroon ng lahat ng bagay sa isang plastic case o sa loob ng na-hack na tulay ng kandila.

Hakbang 3: Ang Mga Koneksyon

Tungkol sa Arduinos, kinuha mula sa pahinang ito:

• Kabuuang max kasalukuyang bawat input / output pin: 40mA
• Kabuuan ng mga alon sa labas ng lahat ng mga input / output pin na pinagsama: 200mA

Ang aking mga kandila ay gumuhit ng 19 mA bawat isa, kapag pinalakas ng 3 V. Mayroong pito sa kanila, na gumagawa ng 133 mA. Kaya't maaari kong paandarin ang mga ito nang direkta mula sa mga output pin. Gayunpaman, mayroon akong ilang ekstrang darlington transistor ICs. Kaya naisip ko, bakit hindi. Ginagawa ng aking circuit ang bagay sa wastong paraan: ang mga data pin ay para lamang sa mga signal, hindi para sa lakas. Sa halip ay ginagamit ko ang 5 V pin sa Arduino para sa pagpapatakbo ng mga ilaw na LED. Kapag tumatakbo ang pagsubok, nakakonekta ang aking laptop sa Arduino. Ang lahat ay pinalakas mula sa laptop USB, na nagbibigay ng 5 V. Ang Arduino Mega ay may piyus ng sarili nitong, na pumutok sa 500 mA upang maprotektahan ang computer. Ang aking mga kandila ay gumuhit ng 133 mA nang higit pa. Ang Arduino ay marahil mas mababa. Ang lahat ay tumatakbo nang maayos, kapag pinalakas ng laptop, kaya't ang paggamit ng isang 5 V na baterya pack na nakakonekta sa USB port ng Arduino ay mabuti lang.

Ang mga pin ng data D3 - D9 pumunta sa IC ULN2803APGCN. Ang mga LED ay tumatakbo sa 3 V. Ang bawat bombilya ay konektado sa 5 V na mapagkukunan at higit pa sa isang resistor na 120 Ω. Dagdag sa isang channel ng IC, na sa wakas ay nagkokonekta sa circuit sa lupa sa pamamagitan ng darlington transistor sa IC.

Ang isang pindutan ng push ay idinagdag sa circuit upang paganahin ang ilang pagkilos ng gumagamit. Ang tulay ng kandila ay maaaring magkaroon ng ilang mga mapipiling programa ng gumagamit.

Ang push button sa circuit ay konektado sa RESET at GND. Ito mismo ang ginagawa ng built-reset na pindutan. Dahil hindi ko na-encapsulate ang lahat sa isang plastic case, ginagamit ko ang pindutan ng pag-reset sa Arduino para sa pagkontrol sa programa. Ang pagdaragdag ng isang pindutan ayon sa imahe ay gagana nang eksakto tulad ng pindutan ng pag-reset ng board. Gumagana ang programa sa pamamagitan ng pag-alala kung anong ilaw na programa ang ginamit noong huling pagpapatakbo ng programa. Kaya, ang bawat pag-reset ay isusulong sa susunod na light program.

Ipinapakita ng mga larawan kung paano lumabas ang mga bagong kable sa tulay, kung paano ko inilatag ang transistor IC at ang mga resistors sa breadboard at kung paano kumonekta ang mga jumper wires sa Arduino Mega. Pinutol ko ang 4 na male-male jumper wires sa 8 kalahating wire, na hinangin ko sa 8 mga kable na lumalabas sa tulay ng kandila. Sa ganitong paraan ay mailalagay ko lang ang mga kable sa breadboard.

Alternatibong walang transistors

Sa nakaraang hakbang, naghanda ako ng isang karaniwang '+' wire para sa mga kandila at paghiwalayin '-' mga wire, na dumaan sa transistor IC sa lupa. Kapag ang isang data pin ay mataas, ang kaukulang '-' wire ay napapaloob sa pamamagitan ng transistor nito at ng mga LED light.

Ang pagkonekta ng '-' wires nang direkta sa mga pin ng data ng Arduino ay gagana rin, ngunit laging isip kung gaano karaming kasalukuyang mga data pin ang maaaring tumayo! Ang pamamaraang ito ay mangangailangan ng pagbabago sa aking programa. Kakailanganin nito ang mga pin ng data upang bumaba upang mabuksan ang mga kandila. Upang magamit ang aking programa na ito, kailangan mong ilipat ang '+' at '-' sa mga kandila. Magkaroon ng isang karaniwang '-' wire para sa mga kandila, na pupunta sa GND sa Arduino. At ang magkakahiwalay na mga wire ay tumatakbo sa pagitan ng '+' wire ng kandila at isang data pin ng Arduino.

Hakbang 4: Ang Mga Magaan na Program

Ang aking programa, na ipinakita ko sa susunod na hakbang, ay dumaan sa 9 na magaan na mga programa. Ang pagtulak sa pindutan ay maitim ang mga ilaw sa isang segundo, pagkatapos magsimula ang sumusunod na ilaw na programa. Ang mga programa ay ang mga sumusunod:

1. Malakas na pagkutitap. Ang mga kandila ay kumikislap nang sapalaran. Mukhang nakakainis ito kapag tinitigan mo sila mula sa malayo, ngunit maaaring magmukhang maganda mula sa isang distansya at marahil sa likod ng isang frosty attic window. Bagaman, maaaring tawagan ng iyong kapwa ang bumbero.
2. Malambot na pagkutitap. Mukhang napakahusay. Tulad ng mga totoong kandila sa isang silid na walang draft.
3. Nag-iiba-iba ang pagkutitap. Ang mga kandila ay kahalili nang maayos sa pagitan ng malakas at malambot na pagkutitap sa ilang mga 30 s na agwat.
4. Nag-iiba-iba ang pagkutitap. Tulad ng # 3, ngunit ang bawat kandila ay magkakaiba sa sarili nitong bilis sa pagitan ng 30 s at 60 s.
5. Mabilis na kislap. Ang mga kandila ay lumiwanag sa isang static na dimmed level at sapalarang kumikislap. Sa average mayroong isang kisap bawat segundo.
6. Mabagal na twinkle. Tulad ng # 5, ngunit sa isang mas mabagal na rate.
7. Mabilis na alon mula sa gitnang tuktok na kandila hanggang sa mas mababang mga bago.
8. Mabagal na alon mula sa gitnang tuktok na kandila hanggang sa mas mababang mga bago.
9. Static maliwanag na ilaw. Kailangan kong isama ito, hindi nais na mapupuksa ang orihinal na pagpapaandar.

Hakbang 5: Ang Code

/*

FLICKERING CANDLE BRIDGE * / // Ideklara ang variable ng mode upang hawakan ang estado // sa pamamagitan ng isang pag-reset na operasyon _attribute _ ((section (". Noinit"))) unsigned int mode; // Kapag nagsimula ang programa pagkatapos ng isang pag-reset, ang piraso ng // memorya na ito ay hindi inisyal, ngunit humahawak sa halaga // mayroon ito bago i-reset. Ang pinakaunang pagkakataon na pinatakbo ang // program, nagtataglay ito ng isang random na halaga. / * * Hawak ng klase ng kandila ang lahat ng kinakailangan * para sa pagkalkula ng isang antas ng ilaw para sa * isang kumikislap na kandila. * / klase ng kandila {pribado: mahabang maxtime; mahabang mintime; mahabang maxlite; mahabang minlite; mahabang meanlite; mahabang origmaxtime; mahabang oras; mahabang Origmaxlite; mahabang Origminlite; mahabang Origmeanlite; mahabang deltamaxtime; mahabang deltamintime; mahabang deltamaxlite; mahabang deltaminlite; mahabang deltameanlite; mahabang lforate; mahabang gabi; mahabang pagsisimula; mahabang target; float phactor; mahabang targettime; mahabang oras ng pagsisimula; mahabang deltatime; walang bisa ang newtarget (walang bisa); mahabang onetarget (walang bisa); pampubliko: kandila (mahabang banig, mahabang mit, mahabang mal, mahabang mil, mahabang mel, mahabang eo); mahabang antas (walang bisa); void initlfo (mahabang deltamat, mahabang deltamit, mahabang deltamal, mahabang deltamil, mahabang deltamean, mahabang rate); walang bisa setlfo (walang bisa); }; kandila:: kandila (mahabang banig, mahabang mit, mahabang mal, mahabang mil, mahabang mel, mahabang eo): maxtime (banig), mintime (mit), maxlite (mal), minlite (mil), meanlite (mel), evenout (eo), Origmaxtime (banig), Origmintime (mit), Origmaxlite (mal), Origminlite (mil), Origmeanlite (mel) {target = meanlite; newtarget (); } / * * levelnow () ibabalik ang antas ng ilaw na dapat mayroon ang kandila ngayon. * Inaalagaan ng pagpapaandar ang pagtukoy ng isang bagong antas ng random na ilaw at * ang oras na dapat gawin upang maabot ang antas na iyon. Ang pagbabago ay hindi linear, * ngunit sumusunod sa isang sigmoid curve. Kapag hindi pa oras para sa pagtukoy ng isang bagong * antas, ibabalik lamang ng pagpapaandar ang antas ng ilaw. * / mahabang kandila:: levelnow (walang bisa) {mahabang tulong, ngayon; lumutang t1, t2; ngayon = millis (); kung (ngayon> = targettime) {help = target; newtarget (); ibalik ang tulong; } iba pa {// help = target * (millis () - starttime) / deltatime + start * (targettime - millis ()) / deltatime; t1 = float (targettime - now) / deltatime; t2 = 1. - t1; // Ito ang tulong sa pagkalkula ng sigmoid = t1 * t1 * t1 * simulan + t1 * t1 * t2 * simulan * 3 + t1 * t2 * t2 * target * 3 + t2 * t2 * t2 * target; ibalik ang tulong; }} void candle:: newtarget (void) {mahabang kabuuan; kabuuan = 0; para sa (mahaba i = 0; i <evenout; i ++) kabuuan + = onetarget (); simulan = target; target = sum / evenout; oras ng pagsisimula = millis (); targettime = starttime + random (mintime, maxtime); deltatime = targettime - oras ng pagsisimula; } mahabang kandila:: onetarget (walang bisa) {kung (random (0, 10) lastcheck + 100) {lastcheck = now; / * * Ang algo para sa twinkling "pagkatapos ng rate milliseconds": * Simulang suriin pagkatapos ng rate / 2 milliseconds * Sa isang panahon ng rate / 2 milliseconds, gawin * ang pagkakataon ng isang kisap upang maging 50%. * Kung ang rate ay 10000 ms, sa panahon ng 5000 ms ang barya ay * flip 50 beses. * 1/50 = 0.02 * Kung random (10000) starttime + rate / 2) {kung (random (rate) targettime) ibalik ang lowlite; return (start - lowlite) * (targettime - now) / (targettime - starttime) + lowlite; } void twinkler:: twink (void) {starttime = millis (); targettime = random (mintime, maxtime) + oras ng pagsisimula; simulan = random (minlite, maxlite); } void setup () {int led; // Basahin ang variable ng magic mode, na dapat sabihin // kung anong light program ang pinatakbo noong huling oras, dagdagan ito // at i-reset sa zero kung overflow. mode ++; mode% = 9; // Pinangangalagaan nito ang anuman ang halaga // ay ang kauna-unahang pagkakataon na pinatakbo ng Arduino // ang program na ito. / * * MAHALAGA NA TANDAAN * ================= * * * Ang mahahalagang bagay na ginagawa ng program na ito ay ang paglabas ng mga signal ng PWM * sa mga LED light. Dito ko itinakda ang mga pin na 3 hanggang 9 hanggang * mode ng output. Sa isang Arduino Mega2560, ang mga pin na ito ay naglalabas * nang maayos na mga signal ng PWM. Kung mayroon kang ibang Arduino, suriin ang * aling mga pin (at kung ilan) ang maaari mong gamitin. Maaari mong palaging * muling isulat ang code upang magamit ang software PWM, kung ang iyong Arduino * ay hindi maaaring magbigay ng sapat na mga pin ng 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); // Patayin lamang ang nakakainis na pula na humantong sa kandila ng Arduino * lata [7]; // maghanda na gamitin ang mga kumikislap na kandila, gagamitin mo man o hindi twinkler * twink [7]; // ihanda na gamitin ang mga kumikislap na kandila … kung (mode == 8) {para sa (int i = 3; i <10; i ++) analogWrite (i, 255); habang (totoo); // Sa tuwing tatakbo ang program na ito, pupunta ito sa // ang ganitong uri ng walang katapusang loop, hanggang sa mapindot ang pag-reset // na pindutan. } kung (mode <2) // pagkutitap {mahabang maxtime_; mahabang mintime_; mahabang maxlite_; mahabang minlite_; mahabang meanlite_; mahaba pantay_; kung (mode == 0) {maxtime_ = 250; mintime_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; pantay_ = 1; } kung (mode == 1) {maxtime_ = 400; mintime_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; pantay_ = 1; } para sa (int i = 0; i <7; i ++) {maaari = bagong kandila (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } habang (totoo) // Ang walang katapusang loop para sa mga kumikislap na kandila {para sa (int i = 0; i levelnow ()); }} kung (mode <4) // lfo idinagdag sa pagkutitap {if (mode == 2) // same lfo (30 s) para sa lahat ng kandila {para (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} kung (mode == 3) // iba-ibang lfo: s para sa mga kandila {para (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); maaari [1] -> initlfo (75, 50, 0, 50, 36, 25000); maaari [2] -> initlfo (75, 50, 0, 50, 36, 30000); maaari [3] -> initlfo (75, 50, 0, 50, 36, 35000); maaari [4] -> initlfo (75, 40, 0, 50, 36, 40000); maaari [5] -> initlfo (75, 30, 0, 50, 26, 45000); maaari [6] -> initlfo (75, 20, 0, 50, 16, 50000); maaari [7] -> initlfo (75, 10, 0, 50, 6, 55000);} habang (true) // Ang walang katapusang loop para sa mga kumikislap na kandila na may lfo {long lastclock = 0; para sa (int i = 0; i levelnow ()); kung (millis ()> lastclock + 4000) {lastclock = millis (); para sa (int i = 0; i setlfo ();}}} kung (mode <6) // twinkling candles {int speedo; if (mode == 4) speedo = 6000; iba pa speedo = 22000; para sa (int i = 0; i <7; i ++) twink = bagong twinkler (300, 295, 255, 250, speedo); habang (totoo) {para sa (int i = 0; i levelnow ()); }} // Mga alon. // Ang seksyon na ito ay nagsisimula sa mga kulot na bracket lamang // upang matiyak na walang magkasalungat na mga variable na pangalan. // Walang ibang pangangailangan para sa mga braket, hindi na kailangan para sa pagsuri // ang halaga ng mode.{int lolite = 2; int hilite = 255; int ibig sabihin; int ampl; float fasedelta = 2.5; float fase; int elong; float phactor; mahabang panahon; ibig sabihin = (lolite + hilite) / 2; ampl = hilite - ibig sabihin; kung (mode == 6) panahon = 1500; ibang panahon = 3500; phactor = 6.28318530718 / panahon; habang (totoo) {fase = phactor * (millis ()% period); elong = ibig sabihin + ampl * sin (fase); analogWrite (7, elong); analogWrite (9, elong); fase = phactor * ((millis () + period / 4)% period); elong = ibig sabihin + ampl * sin (fase); analogWrite (3, elong); analogWrite (8, elong); fase = phactor * ((millis () + period / 2)% period); elong = ibig sabihin + ampl * sin (fase); analogWrite (4, elong); analogWrite (5, elong); fase = phactor * ((millis () + 3 * period / 4)% period); elong = ibig sabihin + ampl * sin (fase); analogWrite (6, elong); } // Habang kumokonekta sa mga wire ng kandila sa Arduino, // Nakuha ko ang mga ito at hindi ko naayos ang mga ito. // Ang pagkakasunud-sunod ay mahalaga para sa paglikha ng mga pattern ng alon, // kaya isinulat ko lang sa akin ang maliit na talahanayan na ito: // // Candle # sa tulay: 2 3 5 4 7 6 1 // Data pin sa Arduino: 3 4 5 6 7 8 9}} void loop () {// Dahil ang bawat light program ay sarili nitong walang katapusang loop, // Sinulat ko ang lahat ng mga loop sa seksyon ng pagsisimula () // at walang iniwan para sa seksyong loop () na ito. }

Hakbang 6: Tungkol sa PWM

Ang mga leds ay lumiwanag nang maliwanag kapag pinapatakbo ng 3 V. Gamit lamang ang 1.5 V hindi sila nag-iilaw. Ang mga ilaw na LED ay hindi kumukupas nang maayos sa pagkupas ng boltahe, tulad ng ginagawa ng mga ilaw na maliwanag na maliwanag. Sa halip dapat silang buksan ng buong boltahe, pagkatapos ay i-off. Kapag nangyari ito ng 50 beses bawat segundo, maganda ang kanilang ningning na may 50% ningning, higit pa o mas kaunti. Kung pinapayagan silang maging sa 5 ms lamang at mas mababa sa 15 ms, maaari silang lumiwanag na may 25% ningning. Ang diskarteng ito ay kung bakit ang LED light dimmable. Ang pamamaraan na ito ay tinatawag na pulse width modulation o PWM. Ang isang microcontroller tulad ng Arduino ay karaniwang may mga data pin, na maaaring magpadala ng mga signal na on / off. Ang ilan sa mga pin ng data ay nakabuo ng mga kakayahan para sa PWM. Ngunit kung walang sapat na mga pin na may built in PWM, karaniwang posible na gumamit ng nakatuon na mga silid-aklatan sa programa upang lumikha ng "mga software PWM pin".

Sa aking proyekto, gumamit ako ng isang Arduino Mega2560, na mayroong hardware PWM sa mga pin 3 - 9. Kung gumagamit ka ng isang Arduino UNO, mayroon ka lamang anim na PWM na mga pin. Sa kasong iyon, kung kailangan mo ng isang ika-7 (o kahit na higit pa) kandila, maaari kong inirerekumenda ang software ng PWM library ni Brett Hagman, na maaari mong makita dito.