Pohon Spiral LED: 4 Langkah (dengan Gambar)

2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:54

Saya suka semua jenis strip LED. Saya membuat cahaya pelangi yang bagus dengan mereka. Bahkan yang tidak dapat dialamatkan pun berguna. Saya telah membuat lampu luar ruangan payung pasar yang terang dengan menempelkannya ke rusuk unbrella sehingga ketika pohon spiral saya meledak, saya memutuskan untuk membungkus panjang strip yang dipimpin di sekitarnya.

Langkah 1: Pengontrol

Saya memutuskan untuk menggunakan LED RGB yang tidak dapat dialamatkan. Ini berarti saya dapat memiliki efek yang diprogram tetapi semua led berubah warna secara bersamaan. Ini juga berarti pengontrol akan dibutuhkan. Saya bisa menggunakan arduino uno dan melakukan tes awal menggunakan perisai RGB tetapi akhirnya menggunakan papan tunggal khusus dengan chip Atmega328 yang telanjang. Hanya perlu mengganti pemrogram target dan memprogram chip secara langsung.

Saya memiliki banyak papan ini yang tersisa dari proyek lampu lainnya. Jangan ragu untuk menggunakan pengontrol terprogram sebaris yang murah seperti yang saya lakukan di payung saya.

Saya akhirnya menggunakan demo crossfade lambat sebagai dasar untuk pohon.

/** Kode cross-fading 3 LED, merah, hijau dan biru (RGB) * Untuk membuat fade, Anda perlu melakukan dua hal: * 1. Jelaskan warna yang ingin ditampilkan * 2. Cantumkan urutan yang Anda inginkan mereka memudar * * MENJELASKAN WARNA: * Warna hanyalah array tiga persentase, 0-100, * mengendalikan LED merah, hijau dan biru * * Merah adalah LED merah penuh, biru dan hijau mati * int merah = { 100, 0, 0 } * Putih redup adalah ketiga LED pada 30% * int redupPutih = {30, 30, 30} * dll. * * Beberapa warna umum disediakan di bawah ini, atau buat sendiri * * DAFTAR ORDER: * Di bagian utama program, Anda perlu membuat daftar pesanan * Anda ingin menampilkan warna, mis. * crossFade(merah); * crossFade (hijau); * crossFade (biru); * * Warna-warna itu akan muncul dalam urutan itu, memudar dari * satu warna ke warna berikutnya * * Selain itu, ada 5 pengaturan opsional yang dapat Anda sesuaikan: * 1. Warna awal diatur ke hitam (jadi warna pertama memudar in), tetapi * Anda dapat mengatur warna awal menjadi warna lain * 2. Loop internal berjalan untuk 1020 interaksi; variabel 'tunggu' * menetapkan perkiraan durasi satu crossfade. Secara teori, * 'menunggu' 10 ms harus membuat crossFade ~10 detik. Dalam praktik *, fungsi lain yang dijalankan kode ini memperlambat * hingga ~11 detik di papan saya. YMMV. * 3. Jika 'repeat' disetel ke 0, program akan berulang tanpa batas. * jika diatur ke angka, itu akan mengulang beberapa kali, * kemudian berhenti pada warna terakhir dalam urutan. (Atur 'kembali' ke 1, * dan buat warna terakhir hitam jika Anda ingin memudar di akhir.) * 4. Ada variabel 'tahan' opsional, yang menghentikan program * untuk milidetik 'tahan' saat warna selesai, * tetapi sebelum warna berikutnya dimulai. * 5. Atur flag DEBUG ke 1 jika Anda ingin output debug * dikirim ke monitor serial. * * Bagian dalam program tidak rumit, tetapi * sedikit rewel -- cara kerja bagian dalam dijelaskan * di bawah loop utama. * * April 2007, Tanah Liat Shirky *

/ Keluaran

int grnPin = 9; // LED hijau, terhubung ke pin digital 10 int redPin = 10; // LED merah, terhubung ke pin digital 9 int bluPin = 11; // LED Biru, terhubung ke pin digital 11

// Array warna

int hitam[3] = { 0, 0, 0 }; int putih[3] = { 100, 100, 100 }; int merah[3] = { 100, 0, 0 }; int hijau[3] = { 0, 100, 0 }; int biru[3] = { 0, 0, 100 }; int kuning[3] = { 40, 95, 0 }; int dimPutih[3] = { 30, 30, 30 }; // dll.

// Setel warna awal

int redVal = hitam[0]; int grnVal = hitam[1]; int bluVal = hitam[2];

int tunggu = 3; // 10ms penundaan crossFade internal; meningkat untuk memudar lebih lambat

int tahan = 0; // Tahan opsional saat warna selesai, sebelum crossFade berikutnya int DEBUG = 0; // penghitung DEBUG; jika disetel ke 1, akan menulis nilai kembali melalui serial int loopCount = 60; // Seberapa sering DEBUG harus melaporkan? int ulangi = 0; // Berapa kali kita harus mengulang sebelum berhenti? (0 tanpa berhenti) int j = 0; // Penghitung lingkaran untuk pengulangan

// Inisialisasi variabel warna

int prevR = redVal; int prevG = grnVal; int prevB = bluVal;

// Siapkan output LED

void setup() { pinMode(redPin, OUTPUT); // menetapkan pin sebagai output pinMode(grnPin, OUTPUT); pinMode(bluPin, OUTPUT);

if (DEBUG) { // Jika kita ingin melihat nilai untuk debugging…

Serial.begin(9600); // …mengatur keluaran serial } }

// Program utama: daftar urutan crossfades

void loop() { crossFade(merah); crossFade(hijau); crossFade(biru); crossFade(kuning);

if (repeat) { // Apakah kita mengulang beberapa kali?

j + = 1; if (j >= repeat) { // Apakah kita sudah sampai? keluar(j); // Jika demikian, berhenti. } } }

/* DI BAWAH GARIS INI ADALAH MATEMATIKA -- ANDA TIDAK PERLU MENGUBAH INI UNTUK DASAR

* * Program ini bekerja seperti ini: * Bayangkan sebuah crossfade yang menggerakkan LED merah dari 0-10, * hijau dari 0-5, dan biru dari 10 ke 7, dalam * sepuluh langkah. * Kami ingin menghitung 10 langkah dan menambah atau * mengurangi nilai warna dalam peningkatan bertahap yang merata. * Bayangkan a + menunjukkan menaikkan nilai sebesar 1, dan a - * sama dengan menurunkannya. 10 langkah fade kita akan terlihat 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 turun dari 10 menjadi 7 dalam tiga langkah. * * Dalam program nyata, persentase warna dikonversi ke nilai * 0-255, dan ada 1020 langkah (255*4). * * Untuk mengetahui seberapa besar langkah yang harus ada di antara satu tanda centang naik atau * turun dari salah satu nilai LED, kami memanggil calhitungStep(), * yang menghitung kesenjangan absolut antara nilai awal dan akhir, * dan kemudian membagi celah itu dengan 1020 untuk menentukan ukuran langkah * di antara penyesuaian nilai. */

int calStep(int prevValue, int endValue) {

int langkah = endValue - prevValue; // Berapa jarak keseluruhannya? if (langkah) { // Jika bukan nol, langkah = 1020/langkah; // bagi dengan 1020 } kembalikan langkah; }

/* Fungsi selanjutnya adalah countVal. Ketika nilai loop, i, * mencapai ukuran langkah yang sesuai untuk salah satu * warna, itu menambah atau mengurangi nilai warna itu sebesar 1. * (R, G, dan B masing-masing dihitung secara terpisah.) */

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

if ((langkah) && i % langkah == 0) { // Jika langkah bukan nol dan waktunya untuk mengubah nilai, if (langkah > 0) { // menambah nilai jika langkah positif… val += 1; } else if (langkah 255) { val = 255; } else if (val < 0) { val = 0; } nilai kembali; }

/* crossFade() mengonversi warna persentase menjadi a

* Rentang 0-255, lalu loop 1020 kali, periksa untuk melihat apakah * nilai perlu diperbarui setiap kali, lalu tulis * nilai warna ke pin yang benar. */

void crossFade(int warna[3]) {

// Konversi ke 0-255 int R = (warna[0] * 255) / 100; int G = (warna[1] * 255) / 100; int B = (warna[2] * 255) / 100;

int langkahR = hitungLangkah(sebelumnya, R);

int langkahG = hitungLangkah(sebelumnya, G); int langkahB = hitungLangkah(sebelumnyaB, B);

for (int i = 0; i <= 1020; i++) { redVal = menghitungVal(langkahR, redVal, i); grnVal = menghitungVal(langkahG, grnVal, i); bluVal = menghitungVal(langkahB, bluVal, i);

analogWrite(redPin, redVal); // Tulis nilai saat ini ke pin LED

analogWrite(grnPin, grnVal); analogWrite(bluPin, bluVal);

tunda (tunggu); // Jeda selama 'tunggu' milidetik sebelum melanjutkan perulangan

if (DEBUG) { // Jika kita menginginkan serial output, print di

if (i == 0 atau i % loopCount == 0) { // awal, dan setiap loopCount kali Serial.print("Loop/RGB: #"); Serial.print(i); Serial.print(" | "); Serial.print(redVal); Serial.print(" / "); Serial.print(grnVal); Serial.print(" / "); Serial.println(bluVal); } DEBUG += 1; } } // Perbarui nilai saat ini untuk loop berikutnya prevR = redVal; sebelumnya = grnVal; sebelumnyaB = bluVal; penundaan (tahan); // Jeda untuk opsional 'tunggu' milidetik sebelum melanjutkan loop }

Langkah 2: Membungkus Pohon

Saya menggunakan strip tahan air karena ini akan berada di luar ruangan. Mereka menempel sendiri tetapi saya segera menindaklanjuti dengan ikatan kawat untuk memastikan mereka tetap bertahan. Retas sederhana dan mudah. Kemampuan daya feedthrough strip membuatnya mudah untuk memberi makan catu daya ke bawah dan mengeluarkan daya dari atas ke bintang.

Langkah 3: Jangan Lupakan Bintang di Atas

Untuk bintang saya menggunakan sepasang chip 10W untuk mendapatkan perhatian. Saya menyoldernya ke lembaran tembaga sebagai heatsink. Saya bisa menggunakan lebih banyak strip karena ada sedikit yang tersisa.

Langkah 4: Mencobanya

Percobaan pertama kecepatannya terlalu cepat….

Setelah saya menenangkannya, itu terlihat cukup bagus.