Vilkuv küünlasild: 6 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:47

See õpetlik näide näitab, kuidas muuta staatilise valgusega lihtne küünlasild mõnusaks helendavaks meeleoluvalguseks koos lõputute varieeruvate virvendavate tulede, vilkuvate lainete ja muude asjadega. Ostsin After Christmas Salesist küünla silla 8 € eest. Sellel on 7 LED -valgustit ja umbes 33 V 3 W seinaadapter. See särab särava ja sooja valge värviga ning sobib suurepäraselt selle projekti jaoks, kuhu panen küünlaid virvendama panema Arduino. Kõige populaarsem Arduino on Arduino Uno. Selles projektis kasutan Arduino Mega 2560.

Loobun 30 V toiteallikast ja kasutan toiteallikana lihtsat 5 V toitepanka, mis on mõeldud mobiiltelefonidele.

Toitepankade kohta on hea teada, et neil on sisemine vooluahel, mis muudab aku 3,7 V väärtuseks 5 V. Kuna protsess kasutab natuke energiat, lülitub toitepank ise välja, kui seda ei kasutata. Kui toitepanka kasutatakse Arduino -põhiste DIY -vidinate jaoks, ei saa see vidin lihtsalt energiasäästlikku unerežiimi panna ja mõne minuti pärast uuesti alustada. See lülitab toitepanga välja. Sellel virvendaval küünlasillal pole unerežiimi. See kasutab pidevalt voolu, hoides toitepanga aktiivsena, kuni toitekaabel on lahti tõmmatud.

Videol on näha küünlasild staatilises režiimis ja täies väreluses. Täielik virvendus on silmadele tõesti üsna tüütu, samas kui video silub seda natuke. Pärast riistvara parandamist, sealhulgas kaablite lõikamist, uute ühenduste jootmist ja mõnede komponentide lisamist, luuakse Arduino jaoks koodi kirjutades kõik soovitud valgusmustrid. Sellesse juhendisse lisatud mustrid on järgmised:

• 4 erinevat vilkuvat valgust, mis imiteerivad tõelisi küünlaid
• 2 erinevat vilkumist (muidu staatiliste tulede juhuslik vilkumine)
• 2 erinevat lainekuju
• lihtne staatiline valgus

Mustrite vahetamine toimub ühe kasutajaliidese elemendi, nupu abil. Mida rohkem mustreid soovitakse ja mida rohkem reguleeritavust soovitakse, seda rohkem nuppe ja nuppe tuleb lisada. Kuid ilu peitub lihtsuses. Hoidke valitud mustrite arv madalal. Valige kodeerimise ja testimise ajal parimad seaded, mitte lisades riistvarale palju juhtelemente.

Tarvikud

• 1 LED -küünla sild 7 pirniga. Veenduge, et see oleks madalpinge alalisvoolumudel, kas patareide või seinale paigaldatava toiteallikaga, mis muudab surmava 110–240 V vahelduvvoolu umbes 6–30 V alalisvooluks. Seega on täiesti ohutu küünlasilda häkkida.
• 1 Arduino Mega (mis tahes muu mikrokontroller teeb seda, veenduge, et saate selle programmeerida)
• 1 leivaplaadi prototüüpimine
• hüppaja juhtmed ja muu traat
• jootmisvahend
• multimeeter
• 7 takistit, 120 Ω
• 1 nupp (näitan, kuidas saate selle asemel kasutada sisseehitatud nuppu Arduino)
• Darlingtoni transistori IC 7 transistori jaoks, ULN2803AP teeb seda (kui kasutate Arduino Unot või Meagat, pole seda tegelikult vaja)
• 5 V toitepank, mis on mõeldud mobiiltelefonidele

Samm: uurige, mis teil on

Uurige, millisel pingel iga LED töötab ja kui palju voolu voolab.

1. Avage küünla silla põhi. Leidke kaks juhtmest, mis lähevad ühe küünla juurde.
2. Eemaldage kaablitelt mõni isolatsioon, mis paljastab vasktraadid ilma vasktraate lõikamata.
3. Lülitage tuled sisse (lõdvestuge, see on vaid mõni volt) ja mõõtke ilmnenud vasktraatide pinget.
4. Katkestage kaabel mõnes mõõtepunktis (sel hetkel tuled muidugi kustuvad), eemaldage mõlemast otsast mõni isolatsioon (3-4 mm). Mõõda läbiv vool. See, mida teete, on see, et ühendate lõigatud kaabli uuesti oma multimeetriga, lastes kogu voolul oma multimeetrist läbi voolata, mis näitab nüüd vooluhulka.

Minu lugemised

Pinge üle ühe küünla (samm 3): 3,1 V

Pange tähele, et küünla silla toiteallikas oli 33 V. Seega seitse korda 3,1 V on ainult 21,7 V. Mõnel küünlal peab olema lisatakisti. Kui ma oleksin seda küünla pinget mõõtnud, pidi see olema mingi 11 V.

Küünla süttimisel voolav vool (4. samm): 19 mA

Toitan kõike 5 V 2 A akuga. Küünalde jaoks pean pinge langetama 5 V -lt 3 V. Vajan takistit, mis langetab pinge 2 V 19 mA voolu juures.

2 V / 0,019 A = 105 Ω

Võimsuse hajumine on:

2 V * 19 mA = 38 mW

See on tühine. Palju rohkem võib takisti ennast puhuda. Kuid ilma 105 Ω takisti korral võin LED -i puhuda. Mul on 100 Ω ja 120 Ω takistid. Ma kasutan 120 Ω. See annab rohkem kaitset.

Kõigi 7 küünla katsetamine 3 V -ga andis ereda valguse, välja arvatud üks küünal, millel oli ainult väga nõrk valgus, ainult 0,8 mA. See oli minu küünal koos lisatakistiga. Selgus, et teistel küünaldel ei olnud üldse takistit. Lühtris kasutatavad LED -tuled on mõeldud lihtsalt 3 V jaoks! Küünal koos lisatakistusega tuli avada kerge vägivalla abil, kuid midagi ei purunenud. Takisti leiti plastikust küünlapirni sees oleva pisikese LED -i alt. Pidin selle lahti jootma ja juhtmed lahjendama. See oli natuke segane, kuna jootekolb soojendas kokkupanekuks kasutatud kuuma liimi.

Nüüd tean, et olenemata toiteallikast, olenemata pingest, pean pinge langetama 3 V -ni, võimaldades 19 mA läbida.

Kui oleksin LED -tehnoloogiaga rohkem tuttav, oleksin ära tundnud kasutatava LED -i tüübi ja oleksin teadnud, et see vajab 3 V.

Samm: mõni jootmine

Selles etapis ühendan kõik positiivsed (+) juhtmed 5 küünalt ühe juhtmega. Seejärel lisan iga küünla jaoks eraldi negatiivse (-) traadi. LED-tuli süttib ainult siis, kui „+” ja „-” liiguvad paremale. Kuna teil on igast küünlast ainult kaks identset kaabliotsa, peate proovima, milline neist on „+” ja milline „-”. Selleks vajate 3 V toiteallikat. Mul oli väike akupakett, mis sisaldas kahte AAA patareid. 3 V mündipatarei sobib suurepäraselt ka testimiseks.

Küünlasild vajab Arduino ja silla vahel sõitmiseks 8 kaablit. Kui leiate 8 isoleeritud juhtmega kaabli, oleks see suurepärane. Üks juhe peab mahutama 120 mA, ülejäänud - ainult 20 mA. Ma otsustasin kasutada 4 kahejuhtmelist kaablit, mis mul juhtumisi oli.

Esimesel pildil on näha, kuidas ma valmistasin ette ühe ühise juhtme, et ühendada kõik '+' juhtmed küünalde küljest. Eemaldage iga küünla jaoks ühise juhtme isolatsioon. Lisage iga liigendi jaoks kahandatud isolatsioonitoru tükk (pildil olev kollane riba) ja asetage see ühise kaabli õigesse kohta. Jootke '+' traat igast küünlast selle ühenduskohani, katke ühenduskoht kokkutõmbumistoruga ja kahandage. Muidugi sobib ka lihtne kleeplint, kõik kaetakse lõpuks.

Teisel pildil on '-' juhtmed, mida iga küünal vajab. Tavaline „+” juhe läheb otse Arduino 5 V kontakti (või võib -olla läbi leivalaua). Iga "-" juhe läheb oma transistori IC-i tihvti juurde (jällegi ilmselt läbi leivalaua).

Arduinot nimetatakse sageli prototüüpimisplaadiks. Leivalaud on ka midagi, mida kasutate prototüüpides. See, mida ma selles juhendis kirjeldan, on prototüüp. Ma ei arenda sellest uhket läikivat toodet, kus kõik on peidetud ilusatesse plastkarpidesse. Prototüübilt järgmisele tasemele viimine tähendaks leivaplaadi asendamist trükkplaadi ja joodetud komponentidega ning isegi Arduino asendamist lihtsalt lihtsa mikrokontrolleri kiibiga (tegelikult on selline kiip Arduino aju). Ja las kõik mahub plastkorpusesse või häkkinud küünlasilla sisse.

Samm: ühendused

Arduinose kohta, mis on võetud siit lehelt:

• Maksimaalne vool sisendi/väljundi kohta: 40mA
• Kõikide sisend-/väljundpistikute voolude summa kokku: 200mA

Minu küünlad tõmbavad igaüks 19 mA, kui toide on 3 V. Neid on seitse, mis teeb 133 mA. Nii et ma saaksin neid otse väljundtihvtidest toita. Siiski on mul varuks darlingtoni transistori IC -sid. Seega mõtlesin, et miks mitte. Minu vooluahel teeb seda õigesti: andmeklemmid on mõeldud ainult signaalide, mitte toite jaoks. Selle asemel kasutan LED -tulede toiteks Arduino 5 V kontakti. Testimisel on mul sülearvuti ühendatud Arduinoga. Kõik saab toite sülearvuti USB -st, mis annab 5 V. Arduino Megal on oma kaitse, mis arvuti kaitseks puhub 500 mA. Minu küünlad tõmbavad maksimaalselt 133 mA. Arduino ilmselt palju vähem. Sülearvuti toites töötab kõik hästi, seega on Arduino USB -porti ühendatud 5 V akupatarei kasutamine hea.

Andmepoldid D3 - D9 lähevad IC ULN2803APGCN -i. LED -id töötavad 3 V. Iga pirn on ühendatud 5 V allikaga ja edasi 120 Ω takistiga. Edasi IC ühele kanalile, mis lõpuks ühendab vooluahela maapinnaga läbi darlingtoni transistori IC -s.

Ahelale lisatakse nupp, mis võimaldab kasutajal teatud toiminguid teha. Küünlasillal võiks seega olla mõni kasutaja poolt valitud programm.

Ahelas olev nupp on ühendatud RESET ja GND -ga. See on täpselt see, mida sisseehitatud lähtestamisnupp teeb. Kuna ma ei kata kõike plastkorpusesse, kasutan programmi juhtimiseks Arduino lähtestusnuppu. Nupu lisamine pildi järgi toimib täpselt nagu tahvli lähtestamise nupp. Programm töötab, mäletades, millist valgusprogrammi programmi eelmisel korral kasutati. Seega liigub iga lähtestamine järgmise valgusprogrammi juurde.

Fotodel on näha, kuidas uued kaablid sillast välja tulevad, kuidas panin transistori IC ja takistid leivalauale ning kuidas hüppaja juhtmed ühenduvad Arduino Mega. Lõikasin 4 mees-mees hüppajajuhtme 8 pooljuhtmeks, mille jootsin küünla sillast väljuvate 8 kaabli külge. Nii saan kaablid lihtsalt leivalaua külge kleepida.

Alternatiiv ilma transistoriteta

Eelmises etapis valmistasin küünalde jaoks ette ühise '+' traadi ja eraldi '-' juhtmed, mis lähevad läbi transistori IC maapinnale. Kui üks andmestik läheb kõrgele, maandub vastav '-' traat läbi selle transistori ja LED-tuled.

Ka juhtmete '-' ühendamine otse Arduino andmeklemmidega toimiks, kuid pidage alati meeles, kui palju voolu andmeklapid taluvad! See lähenemisviis vajaks minu programmi muutmist. Küünalde sisselülitamiseks oleks vaja nööpnõelad madalale minna. Minu programmi kasutamiseks sellisena, nagu see on, peate küünlates vahetama "+" ja "-". Küünalde jaoks on ühine '-' traat, mis läheb Arduino GND-le. Ja eraldi juhtmed kulgevad küünla '+' juhtme ja Arduino andmestiku vahel.

4. samm: valgusprogrammid

Minu programm, mida esitan järgmises etapis, läbib 9 valgusprogrammi. Nupu vajutamine kustutab tuled hetkeks, seejärel käivitub järgmine valgusprogramm. Programmid on järgmised:

1. Tugev virvendus. Küünlad vilguvad juhuslikult. See tundub väga tüütu, kui vaatate neid lähedalt, kuid võib hea välja näha kaugelt ja võib -olla härmas pööninguakna taga. Kuid teie naaber võib kutsuda tuletõrje.
2. Pehme virvendus. Näeb väga hea välja. Nagu tõelised küünlad tuuletõmbuseta ruumis.
3. Mitmekesine virvendus. Küünlad vahelduvad sujuvalt tugeva ja pehme väreluse vahel umbes 30 s intervalliga.
4. Mitmekesine virvendus. Nagu #3, kuid iga küünal varieerub omas tempos vahemikus 30–60 s.
5. Kiire sära. Küünlad säravad staatiliselt hämaral tasemel ja vilguvad juhuslikult. Keskmiselt vilgub üks sekund iga päev.
6. Aeglane sära. Nagu number 5, kuid palju aeglasemalt.
7. Kiire laine keskmisest ülemisest küünlast alumisteni.
8. Aeglane laine keskmisest ülemisest küünlast alumisteni.
9. Staatiline ere valgus. Ma pidin selle lisama, ei tahtnud algsest funktsioonist lahti saada.

Samm: kood

/*

FLICKERING CANDLE BRIDGE */ // Deklareerige režiimi muutuja olekut hoidma // lähtestamistoimingu kaudu _atribuut _ ((jaotis (". Umbesit"))) allkirjastamata int režiim; // Kui programm käivitub pärast lähtestamist, siis seda mälutükki // ei lähtestata, vaid see hoiab väärtust //, mis tal oli enne lähtestamist. // programmi esmakordsel käivitamisel on sellel juhuslik väärtus. / * * Küünlaklassi mahub kõik vajalik * vilkuva küünla valgustugevuse arvutamiseks *. */ klassi küünal {privaatne: pikk maxtime; pikk piparmünt; pikk maksliit; pikk minliit; pikk keskliit; pikk algupäev; pikk algusaeg; pikk origmaxlite; pikk origminliit; pikk origmeanlite; pikk deltamaxtime; pikk deltamintime; pikk deltamaksliit; pikk deltaminliit; pikk deltameanliit; pikk lforaat; pikk ühtlus; pikk algus; pikk sihtmärk; ujukifaktor; pikk sihtimine; pikk algusaeg; pikk kõlblikkusaeg; tühine uus sihtmärk (tühine); pikk sihtmärk (tühine); avalik: küünal (pikk matt, long mit, long mal, long mil, long mel, long eo); pikk lood (tühi); tühine initlfo (pikk deltamat, pikk deltamiit, pikk deltamaal, pikk deltamiil, pikk deltamean, pikk määr); void setlfo (tühine); }; küünal:: küünal (long matt, long mit, long mal, long mil, long mel, long eo): maxtime (matt), mintime (mit), maxlite (mal), minlite (mil), meanlite (mel), evenout (eo), origmaxtime (matt), origmintime (mit), origmaxlite (mal), origminlite (mil), origmeanlite (mel) {target = meanlite; newtarget (); } / * * levelnow () tagastab valguse taseme, mis küünal peaks parasjagu olema. * Funktsioon hoolitseb uue juhusliku valgusastme ja * selle taseme saavutamiseks kuluva aja määramise eest. Muutus ei ole lineaarne, vaid järgib sigmoidkõverat. Kui ei ole aeg uue * taseme määramiseks, tagastab funktsioon lihtsalt valguse taseme. */ pikk küünal:: levelnow (void) {pikk abi, kohe; ujuk t1, t2; nüüd = millis (); if (nüüd> = sihtaeg) {help = target; newtarget (); abi tagastamine; } else {// abi = sihtmärk * (millis () - algusaeg) / deltatime + algus * (sihtaeg - millis ()) / deltatime; t1 = ujuk (sihtaeg - praegu) / deltatime; t2 = 1. - t1; // See on sigmoidide arvutamise abi = t1*t1*t1*start + t1*t1*t2*start*3 + t1*t2*t2*target*3 + t2*t2*t2*target; abi tagastamine; }} tühi küünal:: newtarget (tühine) {pikk summa; summa = 0; (pikk i = 0; i <ühtlane; i ++) summa+= onetarget (); algus = sihtmärk; sihtmärk = summa / ühtlane; algusaeg = millis (); targettime = algusaeg + juhuslik (mintime, maxtime); deltatime = targettime - algusaeg; } pikk küünal:: onetarget (void) {if (random (0, 10) lastcheck + 100) {lastcheck = now; / * * Algus sädelevate "pärast kiiruse millisekundeid" jaoks: * Alustage kontrollimist pärast kiirust / 2 millisekundit * Kiiruse / 2 millisekundi jooksul tehke * sära võimalus 50 %. * Kui kiirus on 10000 ms, pööratakse münti 5000 ms jooksul * 50 korda. * 1/50 = 0,02 * Kui juhuslik (10000) algusaeg + määr / 2) {kui (juhuslik (määra) sihtaeg) tagastab lowlite; return (algus - lowlite) * (targettime - kohe) / (targettime - starttime) + lowlite; } tühine twinkler:: twink (tühine) {algusaeg = millis (); sihtaeg = juhuslik (mintime, maxtime) + algusaeg; algus = juhuslik (minliit, maksliit); } void setup () {int led; // Lugege maagilise režiimi muutujat, mis peaks ütlema, // mis valgusprogrammi viimati käivitati, suurendage seda // ja ülekuumenemise korral nullige. režiim ++; režiim %= 9; // See hoolitseb mis tahes väärtuse eest // oli Arduino esimene kord seda programmi käivitanud. / * * TÄHTIS MÄRKUS * ============== * * Selle programmi peamine asi on PWM * signaalide edastamine LED -tuledele. Siin määran tihvtide 3 kuni 9 väljundrežiimi. Arduino Mega2560 -l väljastavad need tihvtid * kenasti PWM -signaale. Kui teil on mõni muu Arduino, kontrollige *, milliseid tihvte (ja kui palju) saate kasutada. Kui teie Arduino * ei suuda piisavalt riistvara PWM -tihvte pakkuda, saate alati * koodi ümber kirjutada, et kasutada tarkvara PWM. * */ pinMode (3, VÄLJUND); pinMode (4, VÄLJUND); pinMode (5, VÄLJUND); pinMode (6, VÄLJUND); pinMode (7, VÄLJUND); pinMode (8, VÄLJUND); pinMode (9, VÄLJUND); pinMode (LED_BUILTIN, OUTPUT); analogWrite (LED_BUILTIN, 0); // Lülitage lihtsalt Arduino küünla *purgi tüütu punane LED välja [7]; // valmistuda virvendavate küünalde kasutamiseks, olenemata sellest, kas kasutad neid või mitte twinkler *twink [7]; // valmistuma sädelevate küünalde kasutamiseks… if (mode == 8) {for (int i = 3; i <10; i ++) analogWrite (i, 255); samas (tõsi); // Iga kord, kui see programm töötab, läheb see // sellisesse lõputusse ahelasse, kuni vajutatakse reset // nuppu. } if (režiim <2) // vilkuv {pikk maxtime_; pikk mintime_; pikk maxlite_; pikk minlite_; pikk keskmine_; pikk isegi_; kui (režiim == 0) {maxtime_ = 250; mintime_ = 50; maxlite_ = 256; minlite_ = 0; keskmine_liit_ = 128; paaris_ = 1; } kui (režiim == 1) {maxtime_ = 400; mintime_ = 150; maxlite_ = 256; minlite_ = 100; keskmine_lite_ = 200; paaris_ = 1; } jaoks (int i = 0; i <7; i ++) {can = uus küünal (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (true) // Lõputu silmus virvendavate küünalde jaoks {for (int i = 0; i levelnow ()); }} if (mode <4) // lfo lisatakse värelevale {if (mode == 2) // sama lfo (30 s) kõigi küünalde jaoks {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} if (mode == 3) // varieeruv lfo: s küünalde jaoks {for (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); saab [1]-> initlfo (75, 50, 0, 50, 36, 25000); saab [2]-> initlfo (75, 50, 0, 50, 36, 30000); saab [3]-> initlfo (75, 50, 0, 50, 36, 35000); saab [4]-> initlfo (75, 40, 0, 50, 36, 40000); saab [5]-> initlfo (75, 30, 0, 50, 26, 45000); saab [6]-> initlfo (75, 20, 0, 50, 16, 50000); saab [7]-> initlfo (75, 10, 0, 50, 6, 55000);} samas (tõsi) // Lõputu silmus küünlate virvendamiseks lfo {long lastclock = 0; for (int i = 0; i levelnow ()); if (millis ()> lastclock + 4000) {lastclock = millis (); for (int i = 0; i setlfo ();}}} if (režiim <6) // vilkuvad küünlad {int speedo; if (mode == 4) speedo = 6000; else speedo = 22000; for (int i = 0; i <7; i ++) twink = uus twinkler (300, 295, 255, 250, speedo); samas (true) {for (int i = 0; i levelnow ()); } } // Lained. // See jaotis algab lokkisulgudega lihtsalt //, et tagada vastandlike muutujate nimede puudumine. // Sulgude jaoks pole muud vajadust, pole vaja // režiimi väärtust kontrollida.{int loliit = 2; int hilite = 255; int tähendab; int ampl; ujuk fasedelta = 2,5; ujukikaas; int elong; ujukifaktor; pikk periood; keskmine = (loliit + hiliit) / 2; ampl = hilite - keskmine; kui (režiim == 6) periood = 1500; muu periood = 3500; faktor = 6,28318530718 / periood; samas (tõene) {fase = faktor * (millis () % periood); piklik = keskmine + ampl * sin (fase); analogWrite (7, piklik); analogWrite (9, piklik); fase = faktor * ((millis () + periood / 4) % periood); piklik = keskmine + ampl * sin (fase); analogWrite (3, piklik); analogWrite (8, piklik); fase = faktor * ((millis () + periood / 2) % periood); piklik = keskmine + ampl * sin (fase); analogWrite (4, piklik); analogWrite (5, piklik); fase = faktor * ((millis () + 3 * periood / 4) % periood); piklik = keskmine + ampl * sin (fase); analogWrite (6, piklik); } // Küünlajuhtmete ühendamisel Arduinoga // panin need segamini ja ei saanud kordagi. // Lainemustrite loomiseks on järjekord oluline, // nii et ma kirjutasin just selle väikese tabeli minu jaoks: // // Küünal# sillal: 2 3 5 4 7 6 1 // Andmepulk Arduino kohta: 3 4 5 6 7 8 9}} void loop () {// Kuna iga valgusprogramm on oma lõpmatu tsükkel, // kirjutasin kõik silmused sektsiooni algusesse () // ja ei jätnud selle lõigu () sektsiooni jaoks midagi. }

6. samm: PWM -i kohta

LED -id säravad eredalt, kui toiteallikaks on 3 V. Kasutades ainult 1,5 V, ei sütti need üldse. LED -tuled ei kao hääbuva pingega kenasti, nagu hõõglambid. Selle asemel tuleb need täispingega sisse lülitada ja seejärel välja lülitada. Kui seda juhtub 50 korda sekundis, säravad nad kenasti 50 % heledusega, enam -vähem. Kui neil on lubatud olla ainult 5 ms ja välja lülitatud 15 ms, võivad nad särada 25 % heledusega. See tehnika muudab LED -valguse hämardatavaks. Seda tehnikat nimetatakse impulsi laiuse modulatsiooniks või PWM -iks. Arduino -laadsel mikrokontrolleril on tavaliselt andmestikud, mis võivad sisse/välja signaale saata. Mõnel andmestikul on PWM -i jaoks sisseehitatud võimalused. Kuid kui sisseehitatud PWM -iga pole piisavalt tihvte, on tavaliselt tarkvara PWM -tihvtide loomiseks võimalik kasutada spetsiaalseid programmeerimisteeke.

Oma projektis olen kasutanud Arduino Mega2560, mille tihvtidel 3 - 9. on riistvara PWM. Kui kasutate Arduino UNO -d, on teil ainult kuus PWM -tihvti. Sellisel juhul, kui vajate 7. (või isegi rohkem) küünalt, võin soovitada Brett Hagmani tarkvara PWM raamatukogu, mille leiate siit.