Tarik Cahaya - Modul Cahaya Menggunakan Neopixel & Pull Up Switch: 6 Langkah (dengan Gambar)

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

Ciri-ciri modul Cahaya

• Arduino Uno
• Perkakasan & kandang yang dibeli dari internet
• Neopixel & Bekalan kuasa yang dipinjam dari Sekolah Reka Bentuk Informatik & Produk
• Modul cahaya dikawal oleh bekalan kuasa
• Semua fungsi dikendalikan melalui interaksi pengguna
• Jenis animasi jalur Neopixel: Jenis hujan, Jenis pancuran, Jenis kilat, Jenis pop, Jenis tidak teratur
• Suis pull up disambungkan ke jalur Neopixel dan animasi berubah apabila jalur Neopixel ditarik

Langkah 1: Sebelum Kita Bermula

Hello Instructables dan Pembuat.

Kami memulakan dan merancang projek interaktif dari segi apa yang akan berlaku sekiranya kami dapat merasakan emosi hujan melalui animasi cahaya. Saya berpendapat bahawa kepekaan pengguna akan dimaksimumkan melalui antara muka yang menarik cahaya secara langsung.

Jangan sampai bekerja

Langkah 2: Bahagian Diperlukan

Berdasarkan satu Modul Cahaya

*** Neopixels dan Power supply digunakan dengan sokongan jabatan kami. ***

Elektronik:

1. Arduino Uno
2. 3 wayar warna (Hitam, Merah, Warna apa pun)
3. Penyambung 3pin (Pautan untuk membeli)
4. Tarik suis 1 (Pautan untuk membeli)
5. tiub mengecut
6. Jalur LED WS2812b yang boleh ditambahkan dengan 74 LED (jalur Neopixel) * 2
7. Bekalan kuasa (5V 350A) 1

*** 50 set diperlukan untuk Arduino, Pull Switch dan NeoPixels. ***

Perkakasan:

1. Bar akrilik 2t (10mm * 1000mm) 1
2. Papan akrilik 5t (60mm * 60mm) 1
3. Foemax 10t (1200mm * 1800mm) 1
4. Semburan hitam
5. Pengikat kabel
6. Tali
7. Papan keras
8. Papan grid

Langkah 3: Kesambungan dan Membangunkan Perkakasan

Pertama, kita memerlukan Keratan Akrilik untuk membuat satu modul pencahayaan.

• Sebagai alat untuk merasakan animasi cahaya, buat modul pencahayaan yang diperbaiki dengan melampirkan 74 LED dalam bentuk jalur neopixel ke bar akrilik setebal 2mm dengan luas 1M. Kami telah menghasilkan dua jenis modul pencahayaan: linear dan spiral khas.
• Untuk jenis linier, jalur neopixel yang ada dapat dipegang dan diikat, tetapi jenis spiral memerlukan operasi manual. Setiap 74 LED dipecah menjadi kepingan, dilekatkan pada spiral akrilik, dan diikat bersama plumbum.

Pasang jalur Neopixel ke akrilik dan pasangkan setiap jalur untuk mengelakkannya tersebar dengan panas, atau ikat dengan tali pancing yang nipis. Bagi jenis linier, sfera yang perlu ditarik ke hujung modul dipasang untuk merancang penampilan estetik dan kami menyelesaikan bola ping pong dengan semburan hitam. Kemudian mereka mengebor lubang kecil di bola ping pong dan menghubungkannya dengan tali. Bahagian terpenting seterusnya, suis dan neopixel, disambungkan seperti yang ditunjukkan. Suis kemudian diikat ke rak siling.

Untuk jenis spiral, ada risiko penarikan modul spiral secara langsung dapat mematahkan akrilik di bawah tekanan, sehingga bagian tarik (Input) dan modul (Output) dipisahkan. Untuk memaksimumkan cahaya yang jatuh, modul dipasang secara menegak di siling, modul lurus dipasang ke udara, lingkaran dipasang terus ke siling. Dan kami menghubungkan bola ping pong dan beralih ke tali pancing sehingga dapat dikendalikan.

Pemotongan akrilik seperti yang ditunjukkan dalam gambar di atas diperlukan untuk menahan suis ke rak. Suis berbentuk persegi 6cm setebal kira-kira 5mm, dengan suis berpusat dan tali leher disisipkan melalui lubang di kedua-dua sisi untuk menahan suis dengan kuat. Lubang bulat di bahagian bawah pusat memperlihatkan tarikan suis, di mana kabel tiga wayar ditarik keluar dan disambungkan ke terminal kabel modul. Begitu juga, melalui lubang di empat penjuru, rak dan akrilik diikat dengan ikatan kabel. Seperti yang dijelaskan di atas, modul linear disambungkan terus ke tarikan, tetapi modul lingkaran menghubungkan pin dan suis secara berasingan.

Langkah 4: Buat Menggunakan 50 Modul Cahaya

Kami telah merancang pengalaman pengguna untuk cahaya yang lebih kaya dengan menggunakan sejumlah 50 modul

Kami mempunyai rak selebar 1, 800mm dan panjang 1, 200mm, dan kami menyambungkan setiap suis dan modul supaya anda dapat mengalami persekitaran hujan dan hujan yang kami rancangkan pada awalnya, dan setiap modul berdiri sendiri untuk membolehkan pelbagai tugas.

Bergantung pada gambar reka bentuk, lubang bulat digerudi ke dalam foemax untuk menyembunyikan pemasangan dan memastikan bahawa kawasan yang disambungkan dari modul LED tidak kelihatan. Oleh kerana jarak dari papan akrilik ke sambungan modul LED di mana suis terpasang kira-kira 1cm, digunakan foemax setebal 1cm.

Bingkai persegi logam digunakan untuk menahan pemasangan bersama dengan skru dan ikatan kabel sambil mengekalkan berat dan keseimbangan keseluruhan. Sekiranya panjang sambungan yang terdedah lebih daripada itu semasa pembuatnya mencuba, papan tebal tidak cekap dan struktur lain disyorkan.

Untuk mempermudah pengalaman pengguna di permukaan mata, pemasangan yang lengkap diletakkan pada sokongan setinggi kira-kira 2m, tetapi berhati-hati adalah sangat sukar untuk memasang modul LED tertanam dengan suis, jadi semua sambungan harus dilepaskan. Kami menaiki tangga dan menghubungkan modul dengan pemasangan terpasang pada sokongan.

Bahagian terpenting dari keseluruhan proses ini adalah memastikan bahawa pekerjaan itu dilakukan dengan selamat dan terjamin sepenuhnya untuk memastikan bahawa pengalaman itu dimungkinkan dalam persekitaran yang selamat

Sebanyak 10 modul arduino dan 50 LED digunakan dan lima modul LED disambungkan setiap arduino untuk pelbagai tugas yang lebih cekap dan lancar. Lihat rangka tindakan yang dilampirkan untuk maklumat lanjut. Pengekodan multi-tugas Neopixel menggunakan suis penuh mengikut rajah reka bentuk akan dibincangkan secara terperinci pada langkah seterusnya.

Langkah 5: Pengkodan & Pendawaian Arduino

Pendawaian

• 50 modul dihubungkan mengikut susun atur langkah 4.
• Setiap modul dibahagikan kepada 10 set 50 modul untuk membolehkan multi-tasking dan memberikan hubungan yang jelas.
• Seperti yang ditunjukkan dalam gambar set 1 di atas, lima modul disambungkan ke arduino tunggal, dan pin 5v neopixel diikat bersama untuk menghubungkan bekalan kuasa.
• GND neopixel dan suis juga diikat bersama dan, untuk memudahkan persepsi, suis dipasang ke pin 2, 3, 4, 5, 6 dan neopixel dipasang ke pin 9, 10, 11, 12, 13.
• Suis dan neopixel masing-masing dihubungkan dengan cara 2-9, 3-10, 4-11, 5-12, 6-13.
• Harus diingat bahawa kerana sambungan salurannya kompleks dan terdapat risiko kebakaran akibat litar pintas, tiub yang menyusut dipanaskan untuk memastikan bahagian yang lemah tidak pecah.

Pengekodan pelbagai tugas Neopixel dengan suis pull up

5 animasi cahaya (Jenis hujan, Jenis pancuran, Jenis kilat, Jenis pop, Jenis tidak tetap)

#sertakan

/ * 사용 하고자 하는 패턴 을 추가 함 * /

corak enum {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; / * 네오 픽셀 을 방향 을 설정 함 * / arah enum {KE DEPAN, REVERSE};

/ * 패턴 의 클래스 를 입력 함 * /

kelas NeoPatterns: public Adafruit_NeoPixel {/ * 패턴 을 추가 하고 업데이트 하기 위한 함수 * / public: pattern ActivePattern; / * 클레스 함수 에 패턴 의 방향 을 입력 * / arah Arah;

/ * 변수 Selang 을 추가 * / Selang panjang yang tidak ditandatangani; / * 변수 LastUpdate 를 추가 * / LastUpdate yang lama tidak ditandatangani; / * 변수 Warna1, Warna2 를 추가 * / uint32_t Warna1, Warna2; / * 변수 TotalSteps 를 추가 * / uint16_t TotalSteps; / * 변수 Indeks 를 추가 * / uint16_t Indeks;

/ * 패턴 을 완료 했을 시 다시 불러오는 함수 * / batal (* OnComplete) (); / * 네오 패턴 에서 네오 픽샐 의 갯수, 핀 번호, 타입, 콜백 을 불러오는 함수 * / NeoPatterns (uint16_t pixels, uint8_t pin, uint8_t type, void (* callback) ()): Adafruit_NeoPixel (piksel, pin, jenis) { OnComplete = panggilan balik; }

/ * 패턴 을 업데이트 하기 위한 케이스 구문 * /

batal Kemas kini () {/ * 패턴 의 시간 설정. 멀티 태스킹 을 구현 하는 구문 * / if ((millis () - lastUpdate)> Selang) {lastUpdate = millis (); / * ActivePattern 의 스위치 구문 * / switch (ActivePattern) {/ * case RAINBOW_CYCLE 에서는 RainbowCycleUpdate 를 실행 하라 * / case RAINBOW_CYCLE: RainbowCycleUpdate (); / * kes RAINBOW_CYCLE 에서 나와라 * / rehat;

/ * kes THEATER_CHASE 에서는 TheaterChaseUpdate 를 실행 하라 * /

kes THEATER_CHASE: TheaterChaseUpdate (); / * kes THEATER_CHASE 에서 나와라 * / rehat;

/ * kes COLOR_WIPE 에서는 ColorWipeUpdate 를 실행 하라 * /

kes COLOR_WIPE: ColorWipeUpdate (); / * kes COLOR_WIPE 에서 나와라 * / rehat; / * case SCANNER 에서는 ScannerUpdate 를 실행 하라 * / case SCANNER: ScannerUpdate (); / * kes SCANNER 에서 나와라 * / rehat;

/ * kes FADE 에서는 FadeUpdate 를 실행 하라 * /

kes FADE: FadeUpdate (); / * kes FADE 에서 나와라 * / rehat;

/ * case TWINKLE 에서는 TwinkleUpdate 를 실행 하라 * /

kes TWINKLE: TwinkleUpdate (); / * kes TWINKLE 에서 나와라 * / rehat;

/ * kes STAR 에서는 StarUpdate 를 실행 하라 * /

kes STAR: StarUpdate (); / * kes STAR 에서 나와라 * / rehat;

/ * kes RAINBOWSPARKLE 에서는 RainbowsparkleUpdate 를 실행 하라 * /

kes RAINBOWSPARKLE: RainbowsparkleUpdate (); / * kes RAINBOWSPARKLE 에서 나와라 * / rehat; / * case METEOR 에서는 MeteorUpdate 를 실행 하라 * / case METEOR: MeteorUpdate (); / * kes METEOR 에서 나와라 * / rehat;

/ * case LIGHT 에서는 LightUpdate 를 실행 하라 * /

case LIGHT: LightUpdate (); / * case CAHAYA 에서 나와라 * / rehat;

/ * kes BLOSSOM 에서는 BlossomUpdate 를 실행 하라 * /

kes BLOSSOM: BlossomUpdate (); / * kes BLOSSOM 에서 나와라 * / rehat; }}}

/ * 패턴 의 방향 을 설정 하는 구문 * /

/ * Indeks 를 증가 시키고 초기화 하는 함수 * /

batal Kenaikan () {/ * 만약 정방향 이면 인덱스 를 증가 시켜라 * / jika (Arah == KEHADIRAN) {Indeks ++; / * 만약 인덱스 가 전체 네오 픽셀 구동 갯수 와 같 거나 많다 면 0 으로 초기화 시켜라 * / jika (Indeks> = TotalSteps) {Indeks = 0; / * 패턴 을 완료 시키는 함수 * / jika (OnComplete! = NULL) {OnComplete (); }}}

/ * 만약 정방향 이 아니면 인덱스 를 감소 시켜라 * / lain-lain {--Index; / * 만약 인덱스 가 전체 네오 픽셀 구동 갯수 와 같 거나 적 다면 전체 구동 갯수 에서 1 을 빼라 * / jika (Indeks <= 0) {Indeks = JumlahLangkah - 1; / * 패턴 을 완료 시키는 함수 * / jika (OnComplete! = NULL) {OnComplete (); }}}}

/ * 반대 방향 으로 움직이게 하는 함수 * /

terbalik terbalik () {/ * 애니메이션 함수 에 Balik 를 썼을 시, 만약 방향 이 정방향 이면 * / jika (Arah == KEHADIRAN) {/ * 방향 은 그 와 반대 이며 전체 구동 갯수 에서 1 일 빼라 * / Arah = REVERSE; Indeks = TotalSteps - 1; } / * 그 외의 방향 이 정방향 이면 인덱스 를 0 으로 설정 해라 * / lain-lain {Arah = KEHADIRAN; Indeks = 0; }}

/ * 애니메이션 을 설정 하는 함수 들 *

* Kitaran Pelangi 의 시간 과 방향 을 입력 * /

batal RainbowCycle (selang uint8_t, arah dir = FORWARD) {/ * 실행 되는 패턴 은 RainbowCycle 임 * / ActivePattern = RAINBOW_CYCLE; / * 시간 은 batal RainbowCycle () 안에 입력 되는 selang 과 같음 * / Selang = selang; / * 총 구동 갯수 는 255 임 * / TotalSteps = 255; / * 인덱스 는 0 으로 설정 함 * / Indeks = 0; / * 방향 은 batal RainbowCycle () 안에 입력 되는 dir = KE DEPAN 과 같음 * / Arah = dir; }

/ * RainbowCycle 를 업데이트 했을 경우 * /

batal RainbowCycleUpdate () {/ * 변수 i 가 네오 픽셀 개수 보다 작 으면 i 를 증가 시켜라 * / untuk (int i = 0; i <numPixels (); i ++) {/ * 변수 i 가 증가 함 과 동시에 RGB 의 무지개 컬러 로 변화 하면서 작동 해라 * / setPixelColor (i, Wheel (((i * 256 / numPixels ()) + Index) & 255)); } / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); }

/ * TeaterChase 의 컬러 와 시간 방향 을 입력 * /

batal TheaterChase (uint32_t color1, uint32_t color2, uint8_t interval, arah dir = FORWARD) {/ * 실행 되는 패턴 은 RTHEATER_CHASE * / ActivePattern = THEATER_CHASE; / * 시간 은 batal TheaterChase () 안에 입력 되는 selang 과 같음 * / Selang = selang; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); / * 컬러 1, 2 를 설정 * / Warna1 = warna1; Warna2 = warna2; / * 인덱스 는 0 으로 설정 함 * / Indeks = 0; / * 방향 은 batal TheaterChase () 안에 입력 되는 dir = KE DEPAN 과 같음 * / Arah = dir; }

/ * TeaterChase 를 업데이트 했을 경우 * /

batal TeaterChaseUpdate () {/ * 변수 i 가 네오 픽셀 개수 보다 작 으면 i 를 증가 시켜라 * / untuk (int i = 0; i <numPixels (); i ++) {/ * 만약 변수 i 에 인덱스 를 더해서 3 으로 나눈 것이 0 과 같다 면 i 를 Warna 로 변환 시켜라 * / jika ((i + Indeks)% 3 == 0) {setPixelColor (i, Color1); } / * 그렇지 않다면 i 를 Warna 로 변환 시켜라 * / lain-lain {setPixelColor (i, Color2); }} / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); }

/ * ColorWipe 의 컬러 와 시간 방향 을 입력 * /

batal ColorWipe (warna uint32_t, selang uint8_t, arah dir = FORWARD) {/ * 실행 되는 패턴 은 COLOR_WIPE * / ActivePattern = COLOR_WIPE; / * 시간 은 batal ColorWipe () 안에 입력 되는 selang 과 같음 * / Selang = selang; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); / * 컬러 1 을 설정 * / Warna1 = warna; / * 인덱스 는 0 으로 설정 함 * / Indeks = 0; / * 방향 은 batal ColorWipe () 안에 입력 되는 dir = KE DEPAN 과 같음 * / Arah = dir; }

/ * ColorWipeUpdate 를 업데이트 했을 경우 * /

batal ColorWipeUpdate () {/ * indeks 를 컬러 1 로 변환 시켜라 * / setPixelColor (Indeks, Warna1); / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); }

/ * Pengimbas 의 컬러 와 시간 을 입력 * /

pengimbas kosong (uint32_t color1, uint8_t interval) {/ * 실행 되는 패턴 은 SCANNER * / ActivePattern = SCANNER; / * 시간 은 pengimbas kosong () selang 안에 입력 되는 selang 과 같음 * / Selang = selang; / * 구동 갯수 는 총 갯수 에서 1 을 빼고 2 를 곱 해라 * / TotalSteps = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Warna1 = warna1; / * 인덱스 는 0 으로 설정 함 * / Indeks = 0; }

/ * PengimbasPemas kini 를 업데이트 했을 경우 * /

kosongkan Pengimbas Kemas kini () {/ * 변수 i 는 영 이고 총 갯수 보다 작을 경우 i 를 증가 시켜라 * / untuk (int i = 0; i <numPixels (); i ++) {/ * 만약 변수 i 가 인덱스 와 같다 면 i 를 color1 로 변환 시켜라 * / if (i == Indeks) {setPixelColor (i, Color1); } / * 그렇지 않다면 변수 i 를 전체 구동 갯수 에서 인덱스 를 뺀값 과 같다 * / lain jika (i == TotalSteps - Indeks) {setPixelColor (i, Color1); } / * 그 밖에는 i 를 디밍 시켜라 i 의 값 만큼 * / else {setPixelColor (i, DimColor (getPixelColor (i))); }} / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); }

/ * Pengimbas 의 컬러 1, 2 와 스텝, 시간, 방향 을 입력 * /

void Fade (uint32_t color1, uint32_t color2, uint16_t step, uint8_t interval, direction dir = FORWARD) {/ * 실행 되는 패턴 은 FADE * / ActivePattern = FADE; / * 시간 은 void Pudar () 안에 입력 되는 selang 과 같음 * / Selang = selang; / * 구동 갯수 는 스텝 값임 * / TotalSteps = langkah; / * 컬러 1, 2 를 설정 * / Warna1 = warna1; Warna2 = warna2; / * 인덱스 는 0 으로 설정 함 * / Indeks = 0; / * 방향 은 void Pudar () 안에 입력 되는 dir = KE DEPAN 과 같음 * / Arah = dir; } / * FadeUpdate 를 업데이트 했을 경우 * / batal FadeUpdate () {/ * 변수 merah 값 은 다음 과 같음 * / uint8_t merah = ((Merah (Warna1) * (TotalSteps - Indeks)) + (Merah (Warna2) * Indeks)) / TotalSteps; / * 변수 hijau 값 은 다음 과 같음 * / uint8_t hijau = ((Hijau (Warna1) * (TotalSteps - Indeks)) + (Hijau (Warna2) * Indeks)) / TotalLangkah; / * 변수 biru 값 은 다음 과 같음 * / uint8_t biru = ((Biru (Warna1) * (TotalSteps - Indeks)) + (Biru (Warna2) * Indeks)) / TotalSteps; / * 위 의 merah, hijau, biru 값 으로 컬러 를 셋팅 함 * / ColorSet (Warna (merah, hijau, biru)); / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); }

/ * 모든 네오 픽셀 을 끄는 구문 * /

batal alloff () {/ * 총 네오 픽셀 갯수 는 74 개 이며 * / int NPIXEL = 74; / * 변수 i 가 증가 하며 모든 네오 픽셀 의 컬러 값 을 0 으로 변환 함 * / untuk (int i = 0; i <NPIXEL; i ++) {setPixelColor (i, 0, 0, 0); }}

/ * Sekelip mata 의 컬러 1 와 시간 을 입력 * /

void Twinkle (uint32_t color1, uint8_t interval) {/ * 실행 되는 패턴 은 TWINKLE * / ActivePattern = TWINKLE; / * 시간 은 void Twinkle () 안에 입력 되는 selang 과 같음 * / Selang = selang; / * 컬러 1 를 설정 * / Warna1 = warna1; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); Indeks = 0; }

/ * TwinkleUpdate 를 업데이트 했을 경우 * /

batal TwinkleUpdate () {/ * 모든 네오 픽셀 의 컬러 를 0 으로 셋팅 * / setAll (0, 0, 0); / * 변수 Pixel 은 rawak 74 * / int Pixel = rawak (74); / * rawak 74 개 에서 2 로나 눈 수 를 랜덤 하게 켜라 * / setPixelColor (Pixel / 2, 50, 100, 255); setPixelColor (Pixel, 250, 255, 250); setPixelColor (Pixel / 2, 200, 250, 255); setPixelColor (Pixel, 255, 255, 255); setPixelColor (Pixel, 250, 230, 250); setPixelColor (Pixel / 2, 150, 200, 255); / * 애니메이션 을 보여주는 함수 * / tunjukkan (); / * 랜덤 하게 끄는 함수 * / setPixelColor (Pixel, 0, 0, 0); / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); }

/ * Bintang 의 컬러 1 값 을 입력 * /

batal Bintang (uint32_t color1) {/ * 실행 되는 패턴 은 STAR * / ActivePattern = STAR; / * 시간 은 batal Bintang () selang 안에 입력 되는 과 같음 * / Selang = Selang; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); / * 컬러 1 을 설정 * / Warna1 = warna1; Indeks = 0; }

/ * StarUpdate 를 업데이트 했을 경우 * /

batal StarUpdate () {/ * 인덱스 와 컬러 를 셋팅 * / setPixelColor (Indeks, Warna1); tunjuk (); / * 변수 i 가 0 이고 구동 갯수 보다 작 으면 i 를 감소 시킴 = 한칸 씩 이동 하는 애니메이션 * / untuk (int i = 0; i <numPixels (); i--) {setPixelColor (i, Color (0, 0, 0)); } / * 애니메이션 을 보여주는 함수 * / Kenaikan (); }

/ * Rainbowsparkle 의 시간 과 방향 을 입력 * /

batal Rainbowsparkle (selang uint8_t, arah dir = FORWARD) {/ * 실행 되는 패턴 은 RAINBOWSPARKLE * / ActivePattern = RAINBOWSPARKLE; / * 시간 은 batal Rainbowsparkle () 안에 입력 되는 selang 과 같음 * / Selang = selang; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); Indeks = 0; / * 방향 은 batal Rainbowsparkle () 안에 입력 되는 arah 과 같음 * / Arah = dir; }

/ * RainbowsparkleUpdate 를 업데이트 했을 경우 * /

batal RainbowsparkleUpdate () {/ * 변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데 * / untuk (int i = 0; i <numPixels (); i ++) {/ * 변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데 * / jika ((i + Indeks)% 2 == 0) {uint32_t c = rawak (255); setPixelColor (i, c); } lain {setPixelColor (i, rawak (255)); }} / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); } / * Meteor 의 시간 과 방향 을 입력 * / batal Meteor (uint32_t color1) {/ * 실행 되는 패턴 은 METEOR * / ActivePattern = METEOR; / * 시간 설정 * / Selang = Selang; / * 총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, * 2 를 한 것과 같음 * / TotalSteps = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Warna1 = warna1; Indeks = 0; }

/ * MeteorUpdate 를 업데이트 했을 경우 * /

batal MeteorUpdate () {untuk (int i = 0; i <numPixels (); i ++) {if (i == Index) {setPixelColor (i, 100, random (255), 255); } lain {setPixelColor (i, DimColor (getPixelColor (i))); }} / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); }

/ * Cahaya 의 시간 과 방향 을 입력 * /

kekosongan cahaya (uint32_t color1) {/ * 실행 되는 패턴 은 LIGHT * / ActivePattern = LIGHT; / * 시간 설정 * / Selang = Selang; / * 총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, * 2 를 한 것과 같음 * / TotalSteps = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Warna1 = warna1; Indeks = 0; }

/ * LightUpdate 를 업데이트 했을 경우 * /

batal LightUpdate () {untuk (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 150, random (200), 40); } lain {setPixelColor (i, DimColor (getPixelColor (i))); }} / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); }

/ * Mekar 의 시간 과 방향 을 입력 * /

batal Blossom (uint32_t color1) {/ * 실행 되는 패턴 은 BLOSSOM * / ActivePattern = BLOSSOM; / * 시간 설정 * / Selang = Selang; / * 총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, * 2 를 한 것과 같음 * / TotalSteps = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Warna1 = warna1; Indeks = 0; }

/ * BlossomUpdate 를 업데이트 했을 경우 * /

batal BlossomUpdate () {untuk (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 255, random (255), 100); } lain {setPixelColor (i, DimColor (getPixelColor (i))); }} / * 애니메이션 을 보여주는 함수 * / tunjukkan (); Kenaikan (); }

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/ * 네오 픽셀 의 켜지 는 위치 와 색 을 지정 해주는 함수 * / set batalSemua (byte merah, bait hijau, bait biru) {untuk (int i = 0; i <numPixels (); i ++) {setPixelColor (i, red, hijau, biru); } tunjukkan (); }

/ * 네오 픽셀 의 디밍, 즉 밝기 를 조절 하는 함수 * /

uint32_t DimColor (warna uint32_t) {// Shift komponen R, G dan B sedikit ke kanan uint32_t dimColor = Warna (Merah (warna) >> 1, Hijau (warna) >> 1, Biru (warna) >> 1); kembali dimColor; }

/ * 모든 네오 픽셀 의 칼라 를 조절 * /

batal ColorSet (warna uint32_t) {untuk (int i = 0; i <numPixels (); i ++) {setPixelColor (i, color); } tunjukkan (); }

/ * 레드 값 을 불러 옴 * /

uint8_t Merah (warna uint32_t) {kembali (warna >> 16) & 0xFF; } / * 그린 값 을 불러 옴 * / uint8_t Hijau (warna uint32_t) {kembali (warna >> 8) & 0xFF; } / * 블루 값 을 불러 옴 * / uint8_t Biru (warna uint32_t) {warna kembali & 0xFF; }

/ * Pelangi 컬러 를 불러 옴 * /

uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; jika (WheelPos <85) {kembali Warna (255 - WheelPos * 3, 0, WheelPos * 3); } lain jika (WheelPos <170) {WheelPos - = 85; kembali Warna (0, WheelPos * 3, 255 - WheelPos * 3); } lain {WheelPos - = 170; mengembalikan Warna (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

/ * jalur 을 불러 오기 위한 함수 / * 사용 하는 스트립 별로 모두 지정 해주어야 함 * /

jalur kosong1Complete (); jalur kosong2Lengkapkan (); jalur kosong3Complete (); jalur kosong4Complete (); jalur kosong5Lengkap ();

/ * 네오 픽셀 의 갯수 설정 * /

#define NUMPIXELS 74 / * 사용 하는 버튼 의 갯수 설정 * / #define B_NUM 5 / * Jalur import1 ~ 5 까지, 갯수 는 74 개 스트립 연결 핀 은 strip1 은 8 ~ strip5 까지 12 * / NeoPatterns strip1 (74, 8, NEO_GRB + NEO_KHZ800, & strip1Complete); Jalur NeoPatterns (74, 9, NEO_GRB + NEO_KHZ800, & strip2Complete); NeoPatterns strip3 (74, 10, NEO_GRB + NEO_KHZ800, & strip3Complete); NeoPatterns strip4 (74, 11, NEO_GRB + NEO_KHZ800, & strip4Complete); NeoPatterns strip5 (74, 12, NEO_GRB + NEO_KHZ800, & strip5Complete); / * 배열 을 사용한 연결 버튼 핀 설정 * / const int buttonPin [B_NUM] = {2, 3, 4, 5, 6}; / * 배열 을 사용 하여 버튼 상태 를 지정 해줌 * / int butangState [B_NUM]; / * 2 번핀 부터 6 번핀 까지 상태 는 순서 대로 RENDAH 임 * / int lastButtonState [B_NUM] = {RENDAH, RENDAH, RENDAH, RENDAH, RENDAH}; / * 2 번핀 부터 6 번핀 까지 버튼 카운터 를 초기화 시킴 * / int buttonCounter [B_NUM] = {0, 0, 0, 0, 0}; / * 2 번핀 부터 6 번핀 까지 최대 버튼 카운터 는 5 임 * / int butangCounterMax = 5; / * 모든 버튼 핀 을 읽 일수 있도록 변수 추가 * / int membaca [B_NUM]; lama tidak ditandatangani LastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; / * 모든 버튼 핀 을 읽는 시간 간격 은 delay50 과 같음 * / debounce panjang yang tidak ditandatanganiDelay = 50;

batal persediaan () {

/ * 복잡 하게 저항 연결 이 필요 없도록 인풋 풀업 방식 의 버튼 설정: GND - 5V (Sambungkan ke nombor Pin) * / untuk (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Serial.begin (9600); / * 스트립 1 ~ 5 를 셋팅 * / strip1.begin (); strip2.begin (); strip3.begin (); strip4.begin (); strip5.begin ();

//strip1. TheaterChase(strip1. Color(255, 0, 255), strip1. Color (255, 50, 0), 20, FORWARD);

}

/ * 버튼 카운터 변수 값 은 5 임 * /

kaunter int = 5; gelung void () {/ * 버튼 수 보다 i 가 작 으면 i 를 증가 시키고 * / untuk (int i = 0; i debounceDelay) {if (membaca ! = butangState ) {buttonState = membaca ; butangCounter ++; / * 버튼 카운팅 이 위에서 설정 한 Max 값 5 를 넘으면 0 으로 초기화 시켜라. * / If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = membaca ; } / * 모든 스트립 을 업데이트 함. * / Strip1. Kemas kini (); jalur2. Kemas kini (); jalur3. Kemas kini (); jalur4. Kemas kini (); jalur5. Kemas kini ();

///// SWITCH_2 ////////////////////////////////////////// ////////////////////////////////////////////////// /////////////////////////////////////////

/ * 버튼 배열 의 0 번째 즉. 2 번핀 에 연결된 버튼 을 활용 하여 애니메이션 이 구동 되도록 하는 스위치 케이스 구문 * / suis (butangCounter [0]) {

/ * 첫번째 버튼 을 활동 시키면 구동 되는 애니메이션 * /

kes 0: strip1. ActivePattern = BLOSSOM; / * 해당 애니메이션 의 시간 을 설정 * / strip1. Selang = 20; / * 구동 되는 네오 픽셀 의 갯수 를 설정 * / strip1. TotalSteps = strip1.numPixels (); rehat; / * 두번째 버튼 을 활동 시키면 구동 되는 애니메이션 * / case 1: strip1. ActivePattern = RAINBOWSPARKLE; jalur1. Selang = 50; strip1. TotalSteps = strip1.numPixels (); rehat; / * 세번째 버튼 을 활동 시키면 구동 되는 애니메이션 * / case 2: strip1. ActivePattern = SCANNER; jalur1. Selang = 10; strip1. TotalSteps = (strip1.numPixels () - 1) * 2; rehat; / * 네번째 버튼 을 활동 시키면 구동 되는 애니메이션 * / case 3: strip1. ActivePattern = TWINKLE; jalur1. Selang = 1; strip1. TotalSteps = strip1.numPixels (); rehat; / * 다섯 번째 버튼 을 활동 시키면 구동 되는 애니메이션 * / case 4: strip1. ActivePattern = METEOR; jalur1. Selang = 10; strip1. TotalSteps = strip1.numPixels (); rehat; } Serial.print (buttonCounter [0]); Cetakan bersiri (","); Serial.println (buttonCounter [1]);

///// SWITCH_3 //////////////////////////////////////////// ////////////////////////////////////////////////// /////////////////////////////////////////

suis (buttonCounter [1]) {case 0: strip2. ActivePattern = STAR; jalur2. Selang = 50; strip2. TotalSteps = strip2.numPixels (); rehat; kes 1: strip2. ActivePattern = RAINBOWSPARKLE; jalur2. Selang = 100; strip2. TotalSteps = strip2.numPixels (); rehat; kes 2: strip2. ActivePattern = SCANNER; jalur2. Selang = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; rehat; kes 3: strip2. ActivePattern = TWINKLE; jalur2. Selang = 5; strip2. TotalSteps = strip2.numPixels (); rehat; kes 4: strip2. ActivePattern = METEOR; jalur2. Selang = 40; strip2. TotalSteps = strip2.numPixels (); rehat; } Serial.print (buttonCounter [0]); Cetakan bersiri (","); Serial.println (buttonCounter [1]);

///// SWITCH_4 //////////////////////////////////////////// ////////////////////////////////////////////////// /////////////////////////////////////////

suis (buttonCounter [2]) {case 0: strip3. ActivePattern = STAR; jalur3. Selang = 50; strip3. TotalSteps = strip3.numPixels (); rehat; kes 1: strip3. ActivePattern = RAINBOWSPARKLE; jalur3. Selang = 100; strip3. TotalSteps = strip3.numPixels (); rehat; kes 2: strip3. ActivePattern = SCANNER; jalur3. Selang = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; rehat; kes 3: strip3. ActivePattern = TWINKLE; jalur3. Selang = 5; strip3. TotalSteps = strip3.numPixels (); rehat; kes 4: strip3. ActivePattern = METEOR; jalur3. Selang = 25; strip3. TotalSteps = strip3.numPixels (); rehat; } Serial.print (buttonCounter [0]); Cetakan bersiri (","); Serial.println (buttonCounter [1]);

///// SWITCH_5 //////////////////////////////////////////// ////////////////////////////////////////////////// /////////////////////////////////////////

suis (buttonCounter [3]) {case 0: strip4. ActivePattern = STAR; jalur4. Selang = 50; strip4. TotalSteps = strip4.numPixels (); rehat; kes 1: strip4. ActivePattern = RAINBOWSPARKLE; jalur4. Selang = 100; strip4. TotalSteps = strip4.numPixels (); rehat; kes 2: strip4. ActivePattern = SCANNER; jalur4. Selang = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; rehat; kes 3: strip4. ActivePattern = TWINKLE; jalur4. Selang = 5; strip4. TotalSteps = strip4.numPixels (); rehat; kes 4: strip4. ActivePattern = METEOR; jalur4. Selang = 25; strip4. TotalSteps = strip4.numPixels (); rehat; } Serial.print (buttonCounter [0]); Cetakan bersiri (","); Serial.println (buttonCounter [1]);

///// SWITCH_6 //////////////////////////////////////////// ////////////////////////////////////////////////// /////////////////////////////////////////

suis (buttonCounter [4]) {case 0: strip5. ActivePattern = STAR; jalur5. Selang = 50; strip5. TotalSteps = strip5.numPixels (); rehat; kes 1: strip5. ActivePattern = RAINBOWSPARKLE; jalur5. Selang = 100; strip5. TotalSteps = strip5.numPixels (); rehat; kes 2: strip5. ActivePattern = SCANNER; jalur5. Selang = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; rehat; kes 3: strip5. ActivePattern = TWINKLE; jalur5. Selang = 5; strip5. TotalSteps = strip5.numPixels (); rehat; kes 4: strip5. ActivePattern = METEOR; jalur5. Selang = 25; strip5. TotalSteps = strip5.numPixels (); rehat; } Serial.print (buttonCounter [0]); Cetakan bersiri (","); Serial.println (buttonCounter [1]); }

// strip1 Penyelesaian Panggilan

void strip1Complete () {strip1. Color1 = strip1. Wheel (rawak (255)); strip1. Color2 = strip1. Wheel (rawak (255)); jalur1. Index = 0; }

// strip2 Penyelesaian Panggilan

batal strip2Complete () {strip2. Color1 = strip2. Wheel (rawak (255)); strip2. Color2 = strip2. Wheel (rawak (255)); jalur2. Index = 0; }

// strip3 Penyelesaian Panggilan

kekosongan strip3Complete () {strip3. Color1 = strip3. Wheel (rawak (255)); strip3. Color2 = strip3. Wheel (rawak (255)); jalur3. Index = 0; }

// Panggilan Balas Penyelesaian strip4

void strip4Complete () {strip4. Color1 = strip4. Wheel (rawak (255)); strip4. Color2 = strip4. Wheel (rawak (255)); jalur4. Index = 0; }

// strip5 Penyelesaian Panggilan Balik

batal strip5Complete () {strip5. Color1 = strip5. Wheel (rawak (255)); strip5. Color2 = strip5. Wheel (rawak (255)); jalur5. Index = 0; }

Langkah 6: Hasil dan Membuat Filem

Terima kasih kerana berminat dengan projek kami walaupun tidak mencukupi.