Memperbaiki Arduino LED Mood Cube (Simple) (Termasuk Video): 4 Langkah

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

Setelah melihat projek LED mood kecil yang dibuat oleh 'earl, saya memutuskan untuk melakukan versi LED Mood Cube yang lebih baik. Versi saya akan lebih rumit daripada yang asli, kerana ia akan sedikit lebih besar daripada yang asli, mempunyai dua warna lebih banyak dibandingkan dengan kubus asli (ditambah kuning dan putih), mempunyai jumlah putaran warna yang tidak terbatas, dll. Ini semestinya merupakan projek yang baik untuk mempraktikkan penggunaan lampu LED lebih lanjut bagi mereka yang memahami konsep menyambungkan lampu LED dengan wayar.

Langkah 1: Bahan

Berikut adalah beberapa bahan yang anda perlukan untuk membuat Mood Cube ini:

• Papan roti
• Arduino - (Saya mempunyai Leonardo di sini)
• Bekalan kuasa Arduino / kabel USB
• Papan roti
• Jumper Wires (Banyak dari mereka, saya menggunakan 29 wayar)
• LED merah x 2
• LED Biru x 2
• LED hijau x 2
• LED Kuning x 2
• LED putih x 1
• 9 perintang
• Kotak cukup besar untuk memenuhi papan roti (saya menggunakan kotak kasut)
• Pisau utiliti
• Kertas

Langkah 2: Kod

Beberapa penjelasan untuk kod yang diberikan di sini:

Kredit kod tersebut diberikan kepada sumber asal projek saya kerana penyunting projek membuat kod ini. Saya hanya memperbaikinya dengan menjadikannya lebih kompleks. Dalam beberapa kod, anda mungkin melihat // 改 pada akhirnya. Ini bermaksud bahawa kod ini diedit oleh saya, jadi ia berbeza dengan sumber asal saya.

Saya juga mempunyai versi kod pada Arduino Creator.

/ * Kod untuk memudar 3 LED, merah, hijau dan biru (RGB) Untuk membuat pudar, anda perlu melakukan dua perkara: 1. Huraikan warna yang ingin anda paparkan 2. Senaraikan urutan yang anda mahu ia luntur

MENJelaskan WARNA:

Warna hanyalah susunan tiga peratus, 0-100, mengawal LED merah, hijau dan biru

Merah adalah LED merah sepenuhnya, biru dan hijau mati

int red = {100, 0, 0} Dim red white adalah ketiga LED pada 30% int dimWhite = {30, 30, 30} dll.

Beberapa warna biasa disediakan di bawah, atau buat sendiri

SENARAI PESANAN:

Di bahagian utama program, anda perlu menyenaraikan urutan yang ingin anda warnakan, mis. crossFade (merah); crossFade (hijau); crossFade (biru);

Warna-warna itu akan muncul dalam urutan itu, semakin pudar

satu warna dan seterusnya

Selain itu, terdapat 5 tetapan pilihan yang dapat anda sesuaikan:

1. Warna awal ditetapkan menjadi hitam (jadi warna pertama memudar), tetapi anda boleh menetapkan warna awal menjadi warna lain 2. Gelung dalaman berjalan selama 1020 interaksi; pemboleh ubah 'tunggu' menetapkan jangka masa jangka masa satu crossfade. Secara teori, 'tunggu' 10 ms harus membuat crossFade ~ 10 saat. Dalam praktiknya, fungsi lain yang dilakukan kod ini perlahan sehingga ~ 11 saat di papan saya. YMMV. 3. Sekiranya 'ulangan' diatur ke 0, program akan dilambung selama-lamanya. jika diatur ke angka, ia akan mengulangi bilangan kali, kemudian berhenti pada warna terakhir dalam urutan. (Tetapkan 'kembali' ke 1, dan buat warna terakhir menjadi hitam jika anda mahu ia memudar pada akhir.) 4. Terdapat pemboleh ubah 'tahan' pilihan, yang menghentikan program untuk 'tahan' milisaat ketika warna lengkap, tetapi sebelum warna seterusnya bermula. 5. Tetapkan bendera DEBUG ke 1 jika anda mahu output debugging dihantar ke monitor bersiri.

Program dalaman tidak rumit, tetapi mereka

agak cerewet - cara kerja dalaman dijelaskan di bawah gelung utama.

April 2007, Clay Shirky

*

/ Pengeluaran

int ylwPin = 5; // LED Kuning, disambungkan ke pin digital 5 // 改 int redPin = 6; // LED Merah, disambungkan ke pin digital 6 // 改 int grnPin = 7; // LED hijau, disambungkan ke pin digital 7 // blu int bluPin = 8; // LED Biru, disambungkan ke pin digital 8 // 改 int whiPin = 9; // LED putih, disambungkan ke pin digital 9 // 改 int ylwPin2 = 10; // LED Kuning, disambungkan ke pin digital 10 // 改 int redPin2 = 11; // LED Merah, disambungkan ke pin digital 11 // 改 int grnPin2 = 12; // LED hijau, disambungkan ke pin digital 12 // blu int bluPin2 = 13; // LED biru, disambungkan ke pin digital 13 // 改

// Susunan warna

int hitam [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // 改 int putih [9] = {100, 100, 100, 100, 100, 100, 100, 100, 100}; // 改 int merah [9] = {0, 0, 100, 0, 0, 0, 100, 0, 0}; // 改 int hijau [9] = {0, 100, 0, 0, 0, 0, 0, 100, 0}; // 改 int biru [9] = {0, 0, 0, 100, 0, 0, 0, 0, 100}; // 改 int kuning [9] = {100, 0, 0, 0, 0, 100, 0, 0, 0}; // 改 int ungu [9] = {0, 50, 0, 50, 0, 0, 50, 0, 50}; // 改 int oren [9] = {50, 50, 0, 0, 0, 50, 50, 0, 0}; // 改 int pink [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // 改 // dll.

// Tetapkan warna awal

int redVal = hitam [0]; int grnVal = hitam [1]; int bluVal = hitam [2]; int ylwVal = hitam [3]; // 改 int whiVal = hitam [4]; // 改

int menunggu = 15; // Kelewatan crossFade dalaman 10ms; tambah untuk pudar yang lebih perlahan // 改

int tahan = 1; // Tahan pilihan apabila warna selesai, sebelum crossFade seterusnya // 改 int DEBUG = 1; // Kaunter DEBUG; jika ditetapkan ke 1, akan menulis kembali nilai melalui int int loopCount = 60; // Berapa kerapkah laporan DEBUG? ulangan int = 0; // Berapa kali kita mesti melancarkan sebelum berhenti? (0 tanpa henti) // 改 int j = 0; // Loop counter untuk diulang

// Memulakan pemboleh ubah warna

int prevR = redVal; int prevG = grnVal; int prevB = bluVal; int prevY = ylwVal; int prevW = whiVal; // 改

// Siapkan output LED

batal persediaan () {pinMode (redPin, OUTPUT); // menetapkan pin sebagai output pinMode (grnPin, OUTPUT); pinMode (bluPin, OUTPUT); pinMode (ylwPin, OUTPUT); // 改 pinMode (whiPin, OUTPUT); // 改 pinMode (grnPin2, OUTPUT); // 改 pinMode (bluPin2, OUTPUT); // 改 pinMode (ylwPin2, OUTPUT); // 改 pinMode (redPin2, OUTPUT); // 改

if (DEBUG) {// Sekiranya kita ingin melihat nilai untuk debug…

Serial.begin (9600); // … sediakan siri ouput}}

// Program utama: senaraikan urutan crossfades

gelung kosong () {crossFade (merah); crossFade (hijau); crossFade (biru); crossFade (kuning); crossFade (putih); crossFade (merah jambu); crossFade (ungu); crossFade (oren);

jika (ulangi) {// Adakah kita mengulangi sebilangan kali yang terbatas?

j + = 1; if (j> = ulangi) {// Adakah kita masih ada? jalan keluar (j); // Jika ya, berhenti. }}}

/ * DI BAWAH LINE INI ADALAH MATI - ANDA TIDAK PERLU MENGUBAH INI UNTUK DASAR

Program ini berfungsi seperti ini:

Bayangkan crossfade yang menggerakkan LED merah dari 0-10, hijau dari 0-5, dan biru dari 10 hingga 7, dalam sepuluh langkah. Kami ingin mengira 10 langkah dan meningkatkan atau menurunkan nilai warna dengan kenaikan yang sama rata. Bayangkan a + menunjukkan kenaikan nilai dengan 1, dan a - sama dengan menurunkannya. Pudar 10 langkah kami akan kelihatan seperti:

1 2 3 4 5 6 7 8 9 10

R + + + + + + + + + + G + + + + + B - - -

Merah naik dari 0 hingga 10 dalam sepuluh langkah, hijau dari

0-5 dalam 5 langkah, dan biru jatuh dari 10 hingga 7 dalam tiga langkah.

Dalam program sebenar, peratusan warna ditukar menjadi

Nilai 0-255, dan terdapat 1020 langkah (255 * 4).

Untuk mengetahui seberapa besar langkah yang harus ada antara satu up- atau

turunkan salah satu daripada nilai LED, kami memanggil calculepep (), yang mengira jurang mutlak antara nilai awal dan akhir, dan kemudian membahagikan jurang itu dengan 1020 untuk menentukan ukuran langkah antara penyesuaian nilai. * /

int calculateStep (int prevValue, int endValue) {

int step = endValue - prevValue; // Apakah jurang keseluruhan? if (langkah) {// Sekiranya bukan sifar, langkah = 1020 / langkah; // bahagikan dengan 1020} langkah kembali; }

/ * Fungsi seterusnya adalah calculVal. Apabila nilai gelung, i, mencapai ukuran langkah yang sesuai untuk salah satu warna, ia meningkatkan atau menurunkan nilai warna itu dengan 1. (R, G, dan B masing-masing dikira secara berasingan.) * /

int calculateVal (langkah int, int val, int i) {

if ((step) && i% step == 0) {// Sekiranya langkah tidak sifar dan waktunya untuk menukar nilai, jika (langkah> 0) {// tambah nilai jika langkah positif… val + = 1; } lain jika (langkah 255) {val = 255; } lain jika (val <0) {val = 0; } pulangan val; }

/ * crossFade () menukar warna peratusan menjadi a

Julat 0-255, kemudian gelung 1020 kali, periksa untuk melihat apakah nilainya perlu dikemas kini setiap kali, kemudian tuliskan nilai warna ke pin yang betul. * /

void crossFade (warna int ) {// 改

// Tukar ke 0-255 int R = (warna [0] * 255) / 100; int G = (warna [1] * 255) / 100; int B = (warna [2] * 255) / 100; int Y = (warna [3] * 255) / 100; // 改 int W = (warna [4] * 255) / 100; // 改

int stepR = hitungLangkah (prevR, R);

int stepG = hitungLangkah (prevG, G); int stepB = hitungLangkah (prevB, B); int stepY = hitungLangkah (prevY, Y); // 改 int stepW = hitungLangkah (prevW, W); // 改

untuk (int i = 0; i <= 1020; i ++) {redVal = calculVal (stepR, redVal, i); grnVal = calculVal (stepG, grnVal, i); bluVal = calculVal (stepB, bluVal, i); ylwVal = hitungVal (stepY, ylwVal, i); // 改 whiVal = calculVal (stepW, whiVal, i); // 改

analogWrite (redPin, redVal); // Tuliskan nilai semasa ke pin LED

analogWrite (grnPin, grnVal); analogWrite (bluPin, bluVal); analogWrite (ylwPin, ylwVal); // 改 analogWrite (whiPin, whiVal); // 改 analogWrite (grnPin2, grnVal); // 改 analogWrite (bluPin2, bluVal); // 改 analogWrite (ylwPin2, ylwVal); // 改 analogWrite (redPin2, redVal); // 改

kelewatan (tunggu); // Jeda untuk 'tunggu' milisaat sebelum meneruskan gelung

if (DEBUG) {// Jika kita ingin output bersiri, cetak di

if (i == 0 atau i% loopCount == 0) {// permulaan, dan setiap loopCount kali Serial.print ("Loop / RGBYW: #"); Cetakan bersiri (i); Cetakan bersiri ("|"); Serial.print (redVal); Cetakan bersiri ("/"); Serial.print (grnVal); Cetakan bersiri ("/"); Serial.println (bluVal); Cetakan bersiri ("/"); Serial.println (ylwVal); // 改 Serial.print ("/"); // 改 Serial.println (whiVal); // 改 Serial.print ("/"); // 改} DEBUG + = 1; }} // Kemas kini nilai semasa untuk gelung seterusnya prevR = redVal; prevG = grnVal; prevB = bluVal; prevY = ylwVal; // 改 prevW = whiVal; // 改 kelewatan (tahan); // Jeda untuk pilihan 'tunggu' milisaat sebelum meneruskan gelung}

Langkah 3: Sediakan

1. Dapatkan papan roti.

2. Demo wayar penyambung supaya lampu LED dapat bersinar:

   1. Letakkan LED di papan roti. Letakkan hujung yang lebih panjang di sebelah kiri dan hujung yang lebih pendek di sebelah kanan.
   2. Letakkan satu hujung wayar pelompat di tempat yang berada di barisan yang sama dengan hujung LED yang lebih panjang. Letakkan hujung yang lain ke bahagian Digital PWM. Kod tersebut menetapkan LED kuning untuk disambungkan ke 10 dan 5, merah ke 6 dan 11, biru ke 8 dan 13, hijau ke 7 dan 12, dan akhirnya LED putih hingga 9.
   3. Letakkan satu hujung perintang pada baris yang sama dengan hujung LED yang lebih pendek. Letakkan hujung yang lain di tempat berhampiran.
   4. Letakkan hujung wayar pelompat lain dengan baris yang sama dengan hujung perintang yang tidak berada pada baris yang sama dengan hujung LED yang lebih pendek. Letakkan hujung wayar yang lain pada baris muatan negatif.
   5. Letakkan hujung wayar pelompat lain pada baris cas negatif dan letakkan hujungnya yang lain pada GND.
3. Ulangi Langkah 2 sebanyak 8 kali kerana anda mahu 9 LED bersinar

4. Letakkan papan roti di dalam kotak. Beberapa peringatan di sini:

   1. Saya menggunakan bekalan kuasa. Buat lubang kecil untuk wayar anda menggunakan pisau utiliti untuk melewati kotak dan sambungkan ke papan roti.
   2. Pastikan kotak sebagai satu sisi yang terbuka. Kotak kasut sudah mempunyai satu sisi yang terbuka. Sekiranya kotak ditutup sepenuhnya, potong satu sisi kotak untuk membuat ruang terbuka.
   3. Tutup bahagian dengan apa-apa dengan kertas. Ini untuk lampu LED menyinari kertas.