Jambatan Lilin Berkelipan: 6 Langkah (dengan Gambar)

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:08

Instruksional ini menunjukkan cara mengubah jambatan lilin sederhana dengan cahaya statik menjadi cahaya mood bercahaya yang bagus dengan variasi lampu berkelip, sekelip mata, corak gelombang dan yang lainnya. Saya membeli dari Jualan Selepas Krismas sebuah jambatan lilin dengan harga 8 €. Ia mempunyai 7 lampu led dan beberapa penyesuai dinding 33 V 3 W. Ia bersinar dengan warna putih yang terang dan hangat dan akan sesuai untuk projek ini, di mana saya akan meletakkan Arduino untuk membuat lilin berkedip. Arduino yang paling popular adalah Arduino Uno. Dalam projek ini, saya akan menggunakan Arduino Mega 2560.

Saya akan membuang bekalan kuasa 30 V dan akan menggunakan power bank 5 V sederhana yang dimaksudkan untuk telefon bimbit sebagai bekalan kuasa.

Perkara yang baik untuk diketahui mengenai bank kuasa ialah mereka mempunyai litar dalaman, yang mengubah bateri 3,7 V menjadi 5 V. Oleh kerana prosesnya menggunakan sedikit kuasa, bank kuasa akan mematikan dirinya sendiri, jika tidak digunakan. Sekiranya power bank digunakan untuk alat DIY berasaskan Arduino, alat itu tidak boleh meletakkan dirinya dalam keadaan jimat kuasa dan memulakannya semula setelah beberapa minit. Itu akan mematikan power bank. Jambatan lilin berkelip ini tidak mempunyai mod tidur. Ia menggunakan kuasa yang berterusan, menjadikan power bank tetap aktif, sehingga kabel kuasa dilepaskan.

Video menunjukkan jambatan lilin dalam mod statik dan kelipan penuh. Kerlipan penuh benar-benar menjengkelkan mata, sementara videonya melembutkannya sedikit. Setelah perkakasan diperbaiki, termasuk memotong kabel, menyolder sambungan baru dan menambahkan beberapa komponen, semua corak cahaya yang diinginkan dibuat dengan menulis kod untuk Arduino. Corak yang saya sertakan dalam arahan ini adalah:

• 4 lampu berkelip yang berbeza meniru lilin sebenar
• 2 sekelip mata yang berbeza (berkelip secara rawak lampu statik sebaliknya)
• 2 corak gelombang yang berbeza
• cahaya statik sederhana

Pola pertukaran berlaku melalui butang tekan, elemen antara muka pengguna tunggal. Semakin banyak corak yang diinginkan dan semakin banyak penyesuaian yang diinginkan, semakin banyak butang dan tombol yang perlu ditambah. Tetapi keindahan terletak pada kesederhanaan. Kekurangan bilangan corak yang boleh dipilih. Pilih tetapan terbaik semasa pengekodan dan pengujian, bukan dengan menambahkan banyak kawalan ke perkakasan.

Bekalan

• 1 jambatan lilin LED dengan 7 mentol. Pastikan model DC voltan rendah, baik dengan bateri atau dengan sumber kuasa pemasangan di dinding, yang mengubah 110 - 240 V AC yang mematikan menjadi sekitar 6 - 30 V DC. Oleh itu, selamat untuk meretas jambatan lilin.
• 1 Arduino Mega (mikrokontroler lain akan dilakukan, pastikan anda dapat memprogramnya)
• 1 papan roti prototaip
• wayar pelompat dan wayar lain
• alat pematerian
• multimeter
• 7 perintang, 120 Ω
• 1 butang tekan (saya akan menunjukkan bagaimana anda boleh menggunakan butang terbina dalam Arduino sebagai gantinya)
• IC transistor darlington untuk 7 transistor, ULN2803AP akan dilakukan (Sekiranya anda menggunakan Arduino Uno atau Meaga, anda tidak memerlukan ini)
• Bank kuasa 5 V yang dimaksudkan untuk telefon bimbit

Langkah 1: Kaji Apa yang Anda Perolehi

Ketahui berapa voltan setiap LED beroperasi dan berapa banyak arus mengalir.

1. Buka bahagian bawah jambatan lilin. Cari dua wayar yang menuju ke satu lilin.
2. Tanggalkan beberapa penebat dari kabel yang menunjukkan wayar tembaga tanpa memotong wayar tembaga.
3. Hidupkan lampu (relaks, hanya beberapa volt) dan ukur voltan di atas wayar tembaga yang dinyatakan.
4. Potong kabel di salah satu titik pengukur (tentu saja lampu padam, tentu saja), lepaskan sedikit penebat (3 - 4 mm) di kedua hujungnya. Ukur arus yang dilalui. Apa yang anda lakukan ialah anda menyambungkan semula kabel pemotong dengan multimeter anda, membiarkan semua arus mengalir melalui multimeter anda, yang sekarang memberitahu anda jumlah arus.

Bacaan saya

Voltan di atas satu lilin (langkah 3): 3.1 V

Perhatikan bahawa sumber kuasa ke jambatan lilin adalah 33 V. Jadi tujuh kali 3.1 V hanya 21.7 V. Pada sebilangan lilin mesti ada perintang tambahan. Sekiranya saya mengukur voltan lilin itu, ia mestilah sekitar 11 V.

Arus mengalir ketika lampu lilin (langkah 4): 19 mA

Saya akan menghidupkan segalanya dengan pek bateri 5 V 2 A. Untuk lilin, saya perlu menurunkan voltan dari 5 V hingga 3 V. Saya memerlukan perintang, yang akan menurunkan voltan 2 V pada arus 19 mA.

2 V / 0.019 A = 105 Ω

Kekurangan kuasa adalah:

2 V * 19 mA = 38 mW

Itu boleh diabaikan. Banyak lagi yang boleh meletupkan perintang itu sendiri. Namun, tanpa perintang 105 Ω, saya mungkin meniup LED. Saya mempunyai perintang 100 Ω dan 120 Ω. Saya pergi dengan 120 Ω. Ia memberi lebih banyak perlindungan.

Menguji semua 7 lilin dengan 3 V memberikan cahaya yang terang, kecuali satu lilin, yang hanya memiliki cahaya yang sangat redup, dengan hanya sekitar 0,8 mA yang dapat dilalui. Ini adalah lilin saya dengan perintang tambahan. Ternyata lilin lain tidak mempunyai perintang sama sekali. Lampu LED yang digunakan pada candelier hanya dimaksudkan untuk 3 V! Lilin dengan perintang tambahan harus dibuka dengan menggunakan kekerasan ringan, tetapi tidak ada yang pecah. Perintang ditemui tepat di bawah LED kecil di dalam mentol plastik. Saya terpaksa melepaskannya dan memperbaiki wayar. Agak berantakan, kerana besi pematerian memanaskan beberapa lem panas, yang telah digunakan untuk pemasangan.

Jadi sekarang saya tahu bahawa apa sahaja sumber kuasa yang saya gunakan, walau apa pun voltan, saya harus menurunkan voltan hingga 3 V yang membolehkan 19 mA melaluinya.

Sekiranya saya lebih mengenali teknologi LED, saya akan mengenali jenis LED yang digunakan dan saya tahu ia memerlukan 3 V.

Langkah 2: Beberapa Pematerian

Pada langkah ini saya menyambungkan semua wayar positif (+) dari 5 lilin ke satu wayar. Kemudian saya menambah wayar negatif (-) yang terpisah untuk setiap lilin. Lampu LED hanya menyala apabila '+' dan '-' pergi ke kanan. Oleh kerana anda hanya mempunyai dua hujung kabel yang sama dari setiap lilin, anda harus menguji yang mana satu '+' dan yang mana '-'. Untuk ini, anda memerlukan sumber kuasa 3 V. Saya mempunyai pakej bateri kecil termasuk dua bateri AAA. Bateri duit syiling 3 V berfungsi juga untuk ujian.

Jambatan lilin memerlukan 8 kabel untuk berjalan di antara Arduino dan jambatan. Sekiranya anda menjumpai kabel dengan 8 wayar bertebat, itu pasti bagus. Satu wayar mesti menahan 120 mA, selebihnya hanya maksimum 20 mA. Saya memilih untuk menggunakan 4 kabel dawai berkembar, yang kebetulan saya miliki.

Gambar pertama menunjukkan bagaimana saya menyediakan satu wayar biasa untuk menyambungkan semua wayar '+' dari lilin. Lepaskan penebat wayar biasa untuk setiap lilin. Tambahkan sekeping tiub penebat pengecutan (jalur kuning dalam gambar) untuk setiap sendi dan letakkan di tempat yang betul dari kabel biasa. Pateri wayar '+' dari setiap lilin ke sendi, tutup sendi dengan tiub pengecutan dan mengecilkannya. Sudah tentu, pita pelekat sederhana baik juga, semuanya akan ditutup pada akhirnya.

Gambar kedua menunjukkan wayar '-' yang diperlukan oleh setiap lilin. Kawat '+' biasa menuju terus ke pin 5 V Arduino (atau mungkin melalui papan roti). Setiap wayar '-' menuju ke pin transistor IC sendiri (sekali lagi, mungkin melalui papan roti).

Arduino sering dipanggil papan prototaip. Papan roti juga merupakan sesuatu yang anda gunakan dalam prototaip. Apa yang saya jelaskan dalam arahan ini adalah prototaip. Saya tidak akan mengembangkannya menjadi produk berkilat mewah dengan semua yang tersembunyi dalam kotak plastik yang bagus. Mengambilnya dari prototaip ke tahap seterusnya bermaksud mengganti papan roti dengan papan litar bercetak dan komponen yang dipateri dan bahkan mengganti Arduino dengan hanya cip mikrokontroler sederhana (sebenarnya cip semacam itu adalah otak Arduino). Dan semuanya sesuai di dalam kotak plastik atau di dalam jambatan lilin yang digodam.

Langkah 3: Sambungan

Mengenai Arduinos, diambil dari halaman ini:

• Jumlah arus maksimum setiap pin input / output: 40mA
• Jumlah arus dari semua pin input / output digabungkan: 200mA

Lilin saya menarik 19 mA setiap satu, apabila dikuasakan oleh 3 V. Terdapat tujuh daripadanya, yang menjadikan 133 mA. Oleh itu, saya dapat mengaktifkannya secara langsung dari pin output. Namun, saya mempunyai beberapa IC transistor darlington. Jadi saya fikir, mengapa tidak. Litar saya melakukan perkara dengan cara yang betul: pin data hanya untuk isyarat, bukan untuk kuasa. Sebaliknya saya menggunakan pin 5 V di Arduino untuk menghidupkan lampu LED. Semasa ujian dijalankan, komputer riba saya disambungkan ke Arduino. Semuanya dikuasakan dari USB komputer riba, yang memberikan 5 V. Arduino Mega mempunyai sekering sendiri, yang bertiup pada 500 mA untuk melindungi komputer. Lilin saya menarik maksimum 133 mA. Arduino mungkin lebih kurang. Semuanya berjalan lancar, apabila dikuasakan oleh komputer riba, jadi menggunakan pek bateri 5 V yang disambungkan ke port USB Arduino tidak apa-apa.

Pin data D3 - D9 pergi ke IC ULN2803APGCN. LED beroperasi pada 3 V. Setiap mentol disambungkan ke sumber 5 V dan seterusnya ke perintang 120 Ω. Lebih jauh ke satu saluran IC, yang akhirnya menghubungkan litar ke tanah melalui transistor darlington di IC.

Butang tekan ditambahkan ke litar untuk membolehkan beberapa tindakan pengguna. Jambatan lilin dengan demikian dapat memiliki beberapa program yang dapat dipilih oleh pengguna.

Butang tekan di litar disambungkan ke RESET dan GND. Inilah yang dilakukan oleh butang tetapan semula. Oleh kerana saya tidak merangkum semuanya dalam kotak plastik, saya menggunakan butang reset pada Arduino untuk mengendalikan program. Menambah butang mengikut gambar akan berfungsi sama seperti butang tetapan semula papan. Program ini berfungsi dengan mengingati program ringan apa yang digunakan kali terakhir program dijalankan. Oleh itu, setiap tetapan semula akan maju ke program cahaya seterusnya.

Foto menunjukkan bagaimana kabel baru keluar dari jambatan, bagaimana saya meletakkan IC transistor dan perintang di papan roti dan bagaimana kabel jumper menyambung ke Arduino Mega. Saya memotong 4 wayar jumper lelaki-lelaki menjadi 8 wayar separuh, yang saya solder ke 8 kabel yang keluar dari jambatan lilin. Dengan cara ini saya hanya boleh memasukkan kabel ke papan roti.

Alternatif tanpa transistor

Pada langkah sebelumnya, saya menyiapkan wayar '+' biasa untuk lilin dan memisahkan wayar '-', yang melalui IC transistor ke tanah. Apabila satu pin data naik tinggi, wayar '-' yang sesuai dibumikan melalui transistor dan lampu LED.

Menyambungkan wayar '-' terus ke pin data Arduino juga akan berfungsi, tetapi selalu kita ingat berapa banyak pin data dapat bertahan! Pendekatan ini memerlukan perubahan dalam program saya. Ia memerlukan pin data yang rendah untuk menyalakan lilin. Untuk menggunakan program saya seperti sekarang, anda perlu menukar '+' dan '-' dalam lilin. Mempunyai kabel '-' biasa untuk lilin, yang menuju ke GND di Arduino. Dan wayar berasingan bergerak di antara wayar lilin '+' dan pin data Arduino.

Langkah 4: Program Ringan

Program saya, yang saya sampaikan pada langkah seterusnya, melalui 9 program ringan. Menekan butang akan menghitamkan lampu sebentar, maka program cahaya berikut akan dimulakan. Program-programnya adalah seperti berikut:

1. Kelipan kuat. Lilin berkelip secara rawak. Ini kelihatan sangat menjengkelkan ketika anda memandangnya dari jarak dekat, tetapi mungkin kelihatan baik dari kejauhan dan mungkin di belakang tingkap loteng yang sejuk. Walaupun begitu, jiran anda mungkin memanggil bomba.
2. Kelipan lembut. Nampak sangat bagus. Seperti lilin sebenar di bilik tanpa draf.
3. Kerlipan berubah-ubah. Lilin bergantian dengan lancar antara kelipan kuat dan lembut dalam selang 30-an.
4. Kerlipan berubah-ubah. Seperti # 3, tetapi setiap lilin berbeza mengikut rentaknya antara 30 s dan 60 s.
5. Sekelip mata pantas. Lilin bersinar pada tahap redup statik dan sekelip mata secara rawak. Rata-rata terdapat satu sekelip mata setiap saat.
6. Sekelip perlahan. Seperti # 5, tetapi pada kadar yang jauh lebih perlahan.
7. Gelombang pantas dari lilin atas tengah ke yang lebih rendah.
8. Gelombang perlahan dari lilin atas tengah ke yang lebih rendah.
9. Cahaya terang statik. Saya mesti memasukkan ini, tidak mahu menyingkirkan fungsi asalnya.

Langkah 5: Kod

/*

FLICKERING CANDLE BRIDGE * / // Menyatakan pemboleh ubah mod untuk menahan keadaan // melalui operasi semula _attribut _ ((bahagian (". Noinit"))) mod int yang tidak ditandatangani; // Apabila program dimulakan setelah reset, potongan memori ini tidak diinisialisasi, tetapi menyimpan nilai // yang dimilikinya sebelum reset. Pada kali pertama program // dijalankan, ia mempunyai nilai rawak. / * * Kelas lilin menyimpan semua yang diperlukan * untuk mengira tahap cahaya untuk * lilin yang berkelip. * / lilin kelas {peribadi: panjang waktu; lama pudina; maxlite panjang; minlite panjang; minlite panjang; origmaxtime panjang; origmintime panjang; origmaxlite panjang; origminlite panjang; origmeanlite panjang; deltamaxtime panjang; deltamintime panjang; deltamaxlite panjang; deltaminlite panjang; deltameanlite panjang; lforate panjang; petang yang panjang; permulaan yang panjang; sasaran panjang; faktor terapung; masa sasaran yang panjang; waktu mula yang lama; deltatime panjang; batal newtarget (kekosongan); onetarget panjang (tidak sah); awam: lilin (tikar panjang, long mit, long mal, long mil, long mel, eo panjang); tahap panjang sekarang (tidak sah); void initlfo (deltamat panjang, deltamit panjang, deltamal panjang, deltamil panjang, deltamean panjang, kadar panjang); batal setlfo (batal); }; lilin:: lilin (long mat, long mit, long mal, long mil, long mel, long eo): maxtime (mat), mintime (mit), maxlite (mal), minlite (mil), meanlite (mel), evenout (eo), origmaxtime (tikar), origmintime (mit), origmaxlite (mal), origminlite (mil), origmeanlite (mel) {target = meanlite; newtarget (); } / * * levelnow () mengembalikan tahap cahaya yang seharusnya dimiliki lilin sekarang. * Fungsi menjaga tahap cahaya rawak baru dan * masa yang diperlukan untuk mencapai tahap itu. Perubahannya tidak linear, * tetapi mengikuti lengkung sigmoid. Apabila belum tiba masanya untuk menentukan tahap * baru, fungsi hanya mengembalikan tahap cahaya. * / lilin panjang:: levelnow (batal) {pertolongan panjang, sekarang; apungan t1, t2; sekarang = milis (); jika (sekarang> = targettime) {help = target; newtarget (); pulangkan bantuan; } lain {// help = target * (millis () - starttime) / deltatime + start * (targettime - millis ()) / deltatime; t1 = terapung (waktu sasaran - sekarang) / waktu rehat; t2 = 1. - t1; // Ini adalah bantuan pengiraan sigmoid = t1 * t1 * t1 * start + t1 * t1 * t2 * start * 3 + t1 * t2 * t2 * target * 3 + t2 * t2 * t2 * target; pulangkan bantuan; }} kekosongan lilin:: newtarget (void) {jumlah panjang; jumlah = 0; untuk (panjang i = 0; i <evenout; i ++) jumlah + = onetarget (); permulaan = sasaran; target = jumlah / malam; waktu mula = milis (); targettime = waktu mula + rawak (waktu pudar, waktu maxt); deltatime = waktu sasaran - waktu mula; } lilin panjang:: onetarget (void) {if (rawak (0, 10) pemeriksaan terakhir + 100) {lastcheck = sekarang; / * * Algo untuk sekelip mata "selepas milisaat kedua": * Mula menyemak kadar selepas / 2 milisaat * Selama tempoh kadar / 2 milisaat, buat * peluang sekelip mata menjadi 50%. * Jika kadarnya 10000 ms, selama 5000 ms duit syiling * dibalik 50 kali. * 1/50 = 0.02 * Jika waktu permulaan secara rawak (10000) + kadar / 2) {jika (rawak (kadar) waktu sasaran) kembali rendah; kembali (mula - lowlite) * (targettime - now) / (targettime - starttime) + lowlite; } void twinkler:: twink (void) {starttime = millis (); targettime = rawak (waktu tengah, waktu waktu) + waktu mula; permulaan = rawak (minlite, maxlite); } persediaan tidak sah () {int led; // Baca pemboleh ubah mod sihir, yang harus memberitahu // program cahaya apa yang dijalankan terakhir kali, tingkatkannya // dan tetapkan semula ke sifar jika melimpah. mod ++; mod% = 9; // Ini menjaga apa jua nilai // pertama kali Arduino // menjalankan program ini. / * * CATATAN PENTING * ============== * * Perkara penting yang dilakukan oleh program ini ialah mengeluarkan isyarat PWM * ke lampu LED. Di sini saya menetapkan mod output pin 3 hingga 9 hingga *. Pada Arduino Mega2560, pin ini mengeluarkan * isyarat PWM dengan baik. Sekiranya anda mempunyai Arduino lain, periksa * pin mana (dan berapa banyak) yang boleh anda gunakan. Anda selalu dapat * menulis semula kod untuk menggunakan perisian PWM, jika Arduino * anda tidak dapat memberikan pin PWM perkakasan yang mencukupi. * * / 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); // Matikan lampu merah yang menjengkelkan pada lilin Arduino * tin [7]; // bersiaplah untuk menggunakan lilin yang berkedip, sama ada anda menggunakannya atau tidak twinkler * twink [7]; // bersiap untuk menggunakan lilin sekelip mata… jika (mod == 8) {untuk (int i = 3; i <10; i ++) analogWrite (i, 255); sementara (benar); // Setiap kali program ini dijalankan, ia akan memasuki // gelung tanpa henti seperti ini, sehingga butang reset // ditekan. } jika (mod <2) // kelipan {panjang waktu_; lama pudina_; maxlite panjang_; minlite panjang_; minlite panjang_; panjang genap_; jika (mod == 0) {maxtime_ = 250; pudina_ = 50; maxlite_ = 256; minlite_ = 0; meanlite_ = 128; genap_ = 1; } jika (mod == 1) {maxtime_ = 400; pudina_ = 150; maxlite_ = 256; minlite_ = 100; meanlite_ = 200; genap_ = 1; } untuk (int i = 0; i <7; i ++) {can = lilin baru (maxtime_, mintime_, maxlite_, minlite_, meanlite_, even_); } while (true) // Gelung tanpa henti untuk lilin berkelip {for (int i = 0; i levelnow ()); }} if (mode <4) // lfo ditambahkan ke kerlipan {if (mode == 2) // sama lfo (30 s) untuk semua lilin {untuk (int i = 0; i initlfo (75, 50, 0, 50, 36, 30000);}} if (mode == 3) // bervariasi lfo: s untuk lilin {untuk (int i = 0; i initlfo (75, 50, 0, 50, 36, 20000); boleh [1] -> initlfo (75, 50, 0, 50, 36, 25000); boleh [2] -> initlfo (75, 50, 0, 50, 36, 30000); boleh [3] -> initlfo (75, 50, 0, 50, 36, 35000); boleh [4] -> initlfo (75, 40, 0, 50, 36, 40000); boleh [5] -> initlfo (75, 30, 0, 50, 26, 45000); dapat [6] -> initlfo (75, 20, 0, 50, 16, 50000); boleh [7] -> initlfo (75, 10, 0, 50, 6, 55000);} sementara (true) // Gelung tanpa henti untuk lilin berkelip dengan lfo {longclock panjang = 0; untuk (int i = 0; i levelnow ()); if (millis ()> lastclock + 4000) {lastclock = millis (); untuk (int i = 0; i setlfo ();}}} if (mode <6) // lilin sekelip mata {int speedo; if (mode == 4) speedo = 6000; else speedo = 22000; untuk (int i = 0; i <7; i ++) twink = twinkler baru (300, 295, 255, 250, speedo); sementara (benar) {untuk (int i = 0; i levelnow ()); }} // Gelombang. // Bahagian ini bermula dengan tanda kurung keriting hanya // untuk memastikan tidak ada nama pemboleh ubah yang bertentangan. // Tidak ada keperluan lain untuk tanda kurung, tidak perlu memeriksa // nilai mod.{int lolite = 2; int hilite = 255; int bermaksud; int ampl; float fasedelta = 2.5; fasa apungan; int memanjang; faktor terapung; jangka masa panjang; bermaksud = (lolite + hilite) / 2; ampl = hilite - bermaksud; jika (mod == 6) tempoh = 1500; tempoh lain = 3500; phactor = 6.28318530718 / tempoh; sementara (benar) {fase = phactor * (milis ()% period); elong = mean + ampl * sin (fase); analogWrite (7, memanjang); analogWrite (9, memanjang); fase = faktor * ((milis () + tempoh / 4)% tempoh); elong = mean + ampl * sin (fase); analogWrite (3, memanjang); analogWrite (8, memanjang); fase = faktor * ((milis () + tempoh / 2)% tempoh); elong = mean + ampl * sin (fase); analogWrite (4, memanjang); analogWrite (5, memanjang); fase = faktor * ((milis () + 3 * tempoh / 4)% tempoh); elong = mean + ampl * sin (fase); analogWrite (6, memanjang); } // Semasa menyambungkan wayar lilin ke Arduino, // saya mencantumkannya dan tidak pernah menyusunnya. // Urutannya penting untuk membuat corak gelombang, // jadi saya hanya menulis jadual kecil ini untuk saya: // // Lilin # di jambatan: 2 3 5 4 7 6 1 // Pin data pada Arduino: 3 4 5 6 7 8 9}} gelung void () {// Oleh kerana setiap program cahaya adalah gelung tanpa hadnya sendiri, // Saya menulis semua gelung di bahagian permulaan () // dan tidak meninggalkan apa-apa untuk bahagian gelung ini (). }

Langkah 6: Mengenai PWM

Led bersinar terang ketika dihidupkan dengan 3 V. Dengan hanya menggunakan 1,5 V, mereka tidak menyala sama sekali. Lampu LED tidak pudar dengan baik dengan voltan pudar, seperti lampu pijar. Sebaliknya mereka harus dihidupkan dengan voltan penuh, kemudian dimatikan. Apabila ini berlaku 50 kali sesaat, ia bersinar dengan baik dengan kecerahan 50%, lebih kurang. Sekiranya mereka dibenarkan hanya pada jarak 5 ms dan 15 ms, mereka mungkin bersinar dengan kecerahan 25%. Teknik inilah yang menjadikan cahaya LED boleh dimalapkan. Teknik ini dipanggil modulasi lebar nadi atau PWM. Pengawal mikro seperti Arduino biasanya mempunyai pin data, yang dapat menghantar isyarat hidup / mati. Beberapa pin data mempunyai keupayaan untuk PWM. Tetapi jika tidak ada pin yang cukup dengan PWM terpasang, biasanya menggunakan perpustakaan pengaturcaraan khusus untuk membuat "pin PWM perisian".

Dalam projek saya, saya telah menggunakan Arduino Mega2560, yang mempunyai perkakasan PWM pada pin 3 - 9. Sekiranya anda menggunakan Arduino UNO, anda hanya mempunyai enam pin PWM. Sekiranya anda memerlukan lilin ke-7 (atau lebih), saya boleh mengesyorkan perpustakaan PWM perisian Brett Hagman, yang boleh anda dapatkan di sini.