Chiroqni torting - Neopixel va tortish tugmasi yordamida yorug'lik moduli: 6 qadam (rasmlar bilan)

2024 Muallif: John Day | [email protected]. Oxirgi o'zgartirilgan: 2024-01-30 13:26

Light modulining xususiyatlari

• Arduino Uno
• Uskuna va korpus Internetdan sotib olingan
• Neopixel va quvvat manbai informatika va mahsulot dizayni maktabidan olingan
• Yorug'lik moduli quvvat manbai bilan boshqariladi
• Barcha funktsiyalar foydalanuvchilarning o'zaro ta'siri orqali boshqariladi
• Neopixel tasmasining animatsion turlari: yomg'ir turi, dush turi, uchqun chaqmoq turi, pop turi, tartibsizlik turi
• Yuk ko'tarish tugmasi Neopixel tasmasiga ulanadi va Neopixel tasmasi tortilganda animatsiya o'zgaradi

1 -qadam: Boshlashdan oldin

Salom, ko'rsatma beruvchilar va ishlab chiqaruvchilar.

Biz yorug'lik animatsiyasi orqali yomg'ir tuyg'usini his qila oladigan bo'lsak nima bo'lishini nazarda tutadigan interaktiv dizayn loyihasini boshladik. Men yorug'likni to'g'ridan -to'g'ri tortadigan interfeys orqali foydalanuvchining sezgirligi maksimal darajada oshadi deb o'yladim.

Ishga kirmasin

2 -qadam: kerakli qismlar

Bitta yorug'lik moduliga asoslangan

*** Bizning bo'limimiz ko'magida neopiksel va quvvat manbai ishlatilgan.

Elektronika:

1. Arduino Uno
2. 3 rangli sim (qora, qizil, har qanday rang)
3. 3 pinli ulagich (sotib olish uchun havola)
4. 1 -tugmani torting (sotib olish havolasi)
5. qisqaruvchi quvur
6. WS2812b qo'shimcha LED tasmasi, 74 LEDli (Neopixel tasmasi)*2
7. Quvvat manbai (5V 350A) 1

*** Arduino, Pull Switch va NeoPixels uchun 50 ta to'plam kerak. ***

Uskuna:

1. Akril bar 2t (10mm*1000mm) 1
2. Akril taxta 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Qora buzadigan amallar
5. Kabel taqish
6. Ip
7. Qattiq taxta
8. Tarmoqli taxta

3 -qadam: ulanish va uskunani yaratish

Birinchidan, bitta yorug'lik modulini yaratish uchun bizga akril kesish kerak.

• Yorug'lik animatsiyasini boshdan kechirish vositasi sifatida 1M maydonli 2 mm qalinlikdagi akril barga neopixel tasmasi ko'rinishidagi 74 ta LEDni ulash orqali o'rnatiladigan yorug'lik modulini tayyorlang. Biz ikkita turdagi yorug'lik modullarini ishlab chiqdik: odatiy chiziqli va spiral.
• Chiziqli turlar uchun mavjud neopikselli chiziqlar ushlab turilishi va mahkamlanishi mumkin, lekin spiral turlari qo'lda ishlashni talab qiladi. 74 ta LEDning har biri bo'laklarga bo'linadi, spiral akrilga biriktiriladi va qo'rg'oshin bilan biriktiriladi.

Neopixel tasmasini akrilga mahkamlang va har bir tasmani issiqlik bilan yoyilmasligi uchun mahkamlang yoki ingichka baliq chizig'i bilan bog'lang. Agar chiziqli turdagi bo'lsa, estetik ko'rinishni yaratish uchun modulning oxiriga tortilishi kerak bo'lgan shar o'rnatildi va biz stol usti pong -pongini qora purkagich bilan tugatdik. Keyin ular stol tennisi to'pida kichik teshik ochdilar va uni arqon bilan bog'ladilar. Keyingi eng muhim qism, kalit va neopiksel, ko'rsatilganidek ulanadi. Keyin kalit shiftdagi tokchaga mahkamlanadi.

Spiral turida spiral modulni to'g'ridan -to'g'ri tortish akrilni bosim ostida sindirish xavfi mavjud, shuning uchun tortishish qismi (kirish) va modul (chiqish) ajratilgan. Yorug'likning tushishini maksimal darajada oshirish uchun modullar shipga vertikal ravishda o'rnatildi, chiziqli modullar havoga o'rnatildi, spirallar to'g'ridan -to'g'ri shipga o'rnatildi. Biz stol tennisi to'pi va kalitni baliq ovlash liniyasiga uladik, shunda u ishga tushishi mumkin edi.

Kalitni tokchaga mahkamlash uchun yuqoridagi rasmda ko'rsatilgandek akril kesish kerak. 6 sm uzunlikdagi kvadrat shaklidagi kalitning qalinligi taxminan 5 mm, kaliti markazda va kalitni mahkam bog'lab qo'yish uchun ikkala tomonning teshiklari orqali simi bog'ichi o'rnatilgan. Markazning pastki qismidagi dumaloq teshik kalitning tortilishini ochib beradi, uning ostida uchta simli kabel chiqariladi va modulning simi terminaliga ulanadi. Va shunga o'xshab, to'rt burchakdagi teshik orqali tokcha va akril simi rishtalari bilan mahkamlanadi. Yuqorida aytib o'tilganidek, chiziqli modul to'g'ridan -to'g'ri tortishga ulanadi, lekin spiral modul pin va kalitni alohida ulaydi.

4 -qadam: 50 ta yorug'lik moduli yordamida yarating

Biz jami 50 ta modulni joylashtirish orqali yanada boy yorug'lik uchun foydalanuvchi tajribasini ishlab chiqdik

Bizda 1, 800 mm uzunlikdagi va 1, 200 mm uzunlikdagi javon bor edi va biz har bir kalit va modulni uladik, shunda siz biz rejalashtirgan yomg'ir va yomg'ir muhitini boshdan kechirishingiz mumkin edi va bizda har bir modul yolg'iz turar edi..

Dizayn chizilganiga qarab, o'rnatishni yashirish va LED modulining ulangan maydoni ko'rinmasligiga ishonch hosil qilish uchun foemaxga dumaloq teshik ochilgan. Akril taxtadan kalit o'rnatiladigan LED modul ulanishigacha bo'lgan masofa taxminan 1 sm bo'lgani uchun qalinligi 1 sm bo'lgan foemaks ishlatilgan.

Metall kvadrat ramka umumiy og'irlik va muvozanatni saqlagan holda o'rnatishni vintlar va kabellar bilan ushlab turish uchun ishlatilgan. Agar ochiq ulanishlar uzunligi ishlab chiqaruvchi harakat qilgandan ko'ra ko'proq bo'lsa, qalinroq taxta samarasiz va boshqa tuzilmalar tavsiya etiladi.

Foydalanuvchining tajribasini ko'z darajasida osonlashtirish uchun tugallangan o'rnatish taxminan 2 m balandlikdagi tayanchga o'rnatiladi, lekin ehtiyot bo'lish kerakki, o'rnatilgan LED modulini kalit bilan o'rnatish juda qiyin, shuning uchun barcha ulanishlarni olib tashlash kerak. Biz zinapoyaga ko'tarildik va modulni tayanchga o'rnatilgan o'rnatish bilan bog'ladik.

Bu jarayonning eng muhim qismi - bu ish xavfsiz va to'liq ta'minlangan bo'lib, tajriba xavfsiz muhitda amalga oshirilishi uchun

Hammasi bo'lib 10 ta arduino va 50 ta LED moduli ishlatilgan va har bir arduino uchun beshta LED modul ulangan bo'lib, ular yanada samarali va muammosiz ishlay oladilar. Tafsilotlar uchun biriktirilgan sxemaga qarang. Dizayn diagrammasi bo'yicha to'liq kalit yordamida Neopixel ko'p vazifali kodlash keyingi bosqichda batafsil muhokama qilinadi.

5 -qadam: Arduino kodlash va simlarni ulash

Ulanish

• 50 -modul 4 -qadam sxemasiga muvofiq ulangan.
• Har bir modul ko'p vazifalarni bajarish va aniq ulanishni ta'minlash uchun 50 ta modulning 10 to'plamiga bo'lingan.
• Yuqoridagi 1 -rasmda ko'rsatilgandek, beshta modul bitta arduinoga ulangan va quvvat manbaini ulash uchun bir vaqtning o'zida 5V neopixel pinlari bog'langan.
• Neopixellar va kalitlarning GND -lari ham bir -biriga bog'lab qo'yilgan va sezish qulayligi uchun kalitlar 2, 3, 4, 5, 6 -pinlarga, neopiksellar esa 9, 10, 11, 12, 13 -pinlarga ulangan..
• Kommutatorlar va neopiksellar mos ravishda 2-9, 3-10, 4-11, 5-12, 6-13 usulda ulangan.
• Ta'kidlash joizki, chiziqlarning ulanishi murakkab va qisqa tutashuv tufayli yong'in xavfi mavjud bo'lganligi sababli, qisqaruvchi trubka zaif qismlar sinmasligi uchun qizdirilgan.

Yuk ko'tarish tugmasi bilan ko'p vazifali Neopixel kodlash

5 ta yorug'lik animatsiyasi (yomg'ir turi, dush turi, uchqun chaqmoq turi, pop turi, tartibsizlik turi)

#qo'shing

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

enum naqsh {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 픽셀 을 방향 방향 을 설정 함*/ enum yo'nalishi {OLGA, TERISH};

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

NeoPatterns klassi: umumiy Adafruit_NeoPixel { /* 패턴 을 추가 하고 하고 업데이트 하기 위 위 public* public: model ActivePattern; /*클레스 함수 에 패턴 패턴 의 방향 을 입력*/ yo'nalish Yo'nalish;

/*변수 Interval 을 추가*/ unsigned long Interval; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 Rang1, Rang2 를 추가*/ uint32_t Rang1, Rang2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Indeks 를 추가*/ uint16_t indeksi;

/*패턴 을 완료 했을 했을 시 다시 불러오는 함수*/ void (*OnComplete) (); /*네오 패턴 에서 네오 네오 픽샐 의 갯수, 핀 번호, 타입, 타입 을 불러오는 함수*/ NeoPatterns (uint16_t piksel, uint8_t pin, uint8_t turi, void (*qayta qo'ng'iroq qilish) ()): Adafruit_NeoPixel (piksel, pin, tur) { OnComplete = qayta qo'ng'iroq qilish; }

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

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

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

ish THEATER_CHASE: TheaterChaseUpdate (); /*ish THEATER_CHASE 에서 나와라*/ tanaffus;

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

COLOR_WIPE holati: ColorWipeUpdate (); /*sumkasi COLOR_WIPE 에서 나와라*/ tanaffus; /*case SCANNER 에서는 ScannerUpdate 를 실행 하라*/ case SCANNER: ScannerUpdate (); /*case SCANNER 에서 나와라*/ break;

/*FADE holati, FadeUpdate dasturi 실행 하라 하라*/

FADE holati: FadeUpdate (); /*case FADE 에서 나와라*/ break;

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

ish TWINKLE: TwinkleUpdate (); /*case TWINKLE 에서 나와라*/ break;

/*ishi STAR, StarUpdate 를 실행 하라*/

ish STAR: StarUpdate (); /*ishi STAR 에서 나와라*/ tanaffus;

/*RAINBOWSPARKLE holati ain RainbowsparkleUpdate 를 실행 하라*/

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

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

Case LIGHT: LightUpdate (); /*case LIGHT 에서 나와라*/ tanaffus;

/*BLOSSOM holatida, BlossomUpdate -da yoki*

ish BLOSSOM: BlossomUpdate (); /*ish BLOSSOM 에서 나와라*/ tanaffus; }}}

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

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

void Increment () { /*만약 정방향 이면 인덱스 를 를 시켜라 /* / if (Yo'nalish == FORWARD) {Indeks ++; /*만약 인덱스 가 전체 네오 네오 구동 갯수 와 같 같 거나 면 0 으로 초기화*/ if (Indeks> = TotalSteps) {Indeks = 0; /*패턴 을 완료 시키는 함수*/ if (OnComplete! = NULL) {OnComplete (); }}}

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

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

void Reverse () { /*애니메이션 함수 에 Teskari 를 썼을 시, 만약 방향 이 정방향* / if (Yo'nalish == OLGA) { /*방향 은 그 와 반대 이며 전체 구동 갯수 에서 1 일 빼라* / Yo'nalish = REVERSE; Indeks = TotalSteps - 1; } /*그 외의 방향 이 이 정방향 이면 인덱스 를 0 으로 설정 해라* / else {Direction = FORWARD; Indeks = 0; }}

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

*Kamalak tsikli 의 시간 과 방향 을 입력/*/

void RainbowCycle (uint8_t interval, yo'nalish dir = FORWARD) { /*실행 되는 패턴 은 RainbowCycle 임* / ActivePattern = RAINBOW_CYCLE; /*시간 은 void RainbowCycle () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 갯수 255 임*/ TotalSteps = 255; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void RainbowCycle () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

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

void RainbowCycleUpdate () { /*변수 i 가 네오 픽셀 개수 보다 작 으면 를 증가* /for (int i = 0; i <numPixels (); i ++) { /*변수 i 가 증가 함 동시에 RGB 의 의 컬러 로 변화 하면서 작동 작동 * / setPixelColor (i, Wheel (((i * 256 / numPixels ()) + Indeks) & 255))); } / *애니메이션 을 보여주는 함수 * / show (); Kattalashtirish (); }

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

void TheaterChase (uint32_t color1, uint32_t color2, uint8_t interval, yo'nalish dir = FORWARD) { /*실행 되는 패턴 은 RTHEATER_CHASE* / ActivePattern = THEATER_CHASE; /*시간 은 void TheaterChase () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1, 2 를 설정*/ Rang1 = rang1; Rang2 = rang2; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void TheaterChase () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

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

void TheaterChaseUpdate () { /*변수 i 가 네오 픽셀 개수 보다 작 으면 i 를 시켜라* /for (int i = 0; i <numPixels (); i ++) { /*만약 변수 i 에 인덱스 를 더해서 3 으로 나눈 것이 0 과 같다 면 i 를 Rang 로 변환 시켜라*/ if ((i + Indeks) % 3 == 0) {setPixelColor (i, Color1); } /*그렇지 않다면 i 를 Rang 로 변환 시켜라* / else {setPixelColor (i, Color2); }} / *애니메이션 을 보여주는 함수 * / show (); Kattalashtirish (); }

/*ColorWipe -ni o'chirish yoki o'chirish*/

void ColorWipe (uint32_t rang, uint8_t interval, yo'nalish dir = OLGA) { /*실행 되는 패턴 은 COLOR_WIPE* / ActivePattern = COLOR_WIPE; /*시간 은 void ColorWipe () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Color1 = rang; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void ColorWipe () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

/*ColorWipeUpdate -ni tanlang*/

void ColorWipeUpdate () { /*indeksi 1 -sonli ma'lumot**setPixelColor (Indeks, Color1); / *애니메이션 을 보여주는 함수 */ show (); Kattalashtirish (); }

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

bo'sh skaner (uint32_t color1, uint8_t interval) { /*실행 되는 패턴 패턴 은 SCANNER* / ActivePattern = SCANNER; /*시간 은 void Scanner () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*구동 갯수 는 총 총 갯수 1 을 빼고 2 를 곱 해라*/ TotalSteps = (numPixels () - 1)*2; /*컬러 1 을 설정*/ Rang1 = rang1; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; }

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

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

/*Skaner 의 1, 2 와, 시간, 시간, 방향 을 입력*/

void Fade (uint32_t color1, uint32_t color2, uint16_t qadamlar, uint8_t interval, yo'nalish dir = FORWARD) { /*실행 되는 패턴 패턴 AD FADE* / ActivePattern = FADE; /*시간 은 void Fade () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*구동 갯수 는 는 스텝/*/ TotalSteps = qadamlar; /*컬러 1, 2 를 설정*/ Rang1 = rang1; Rang2 = rang2; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void Fade () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 red 값 은 다음 과 같음* / uint8_t red = ((Qizil (Rang1)*(TotalSteps - Indeks)) + (Qizil (Rang2)*Indeks)) / TotalSteps; / * 변수 yashil 값 은 다음 다음 과 * / uint8_t green = ((Yashil (Rang1) * (TotalSteps - Indeks)) + (Yashil (Rang2) * Indeks)) / TotalSteps; / * 변수 ko'k 값 은 다음 과 과 * / uint8_t blue = ((Moviy (Rang1) * (TotalSteps - Indeks)) + (Moviy (Rang2) * Indeks)) / TotalSteps; /*위 의 qizil, yashil, ko'k 값 으로 컬러 를 셋팅 함 함*/ ColorSet (Rang (qizil, yashil, ko'k)); / *애니메이션 을 보여주는 함수 */ show (); Kattalashtirish (); }

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

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

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

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

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

void TwinkleUpdate () { /*모든 네오 픽셀 의 의 컬러 0 으로 셋팅* / setAll (0, 0, 0); /*변수 Pixel 은 tasodifiy 74*/ int Pixel = tasodifiy (74); /*tasodifiy 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); / *애니메이션 을 보여주는 함수 */ show (); / *랜덤 하게 끄는 함수 */ setPixelColor (Piksel, 0, 0, 0); / *애니메이션 을 보여주는 함수 */ show (); Kattalashtirish (); }

/*Yulduzli 의 1 값 을 입력 입력*/

void Star (uint32_t color1) { /*실행 되는 패턴 은 STAR* / ActivePattern = STAR; /*시간 은 void Star () 안에 입력 되는 interval 과 같음*/ Interval = Interval; /*총 구동 갯수 는 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Rang1 = rang1; Indeks = 0; }

/*StarUpdate -ni o'chirish yoki o'chirish*/

void StarUpdate () { /*인덱스 와 컬러 를 를* / setPixelColor (Indeks, Rang1); ko'rsatish (); /*변수 i 가 0 이고 구동 갯수 보다 작 으면 i 를 감소 시킴 = 한칸 씩 이동 하는 애니메이션*/ for (int i = 0; i <numPixels (); i--) {setPixelColor (i, Rang (0, 0, 0)); } / *애니메이션 을 보여주는 함수 * / Kattalashtirish (); }

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

void Rainbowsparkle (uint8_t interval, yo'nalish dir = FORWARD) { /*실행 되는 패턴 패턴 RAINBOWSPARKLE* / ActivePattern = RAINBOWSPARKLE; /*시간 은 void Rainbowsparkle () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Indeks = 0; /*방향 은 vain Rainbowsparkle () 안에 입력 되는 yo'nalish 과 같음*/ Yo'nalish = dir; }

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

void RainbowsparkleUpdate () { /*변수 i 가 0 이고 구동 보다 보다 작 으면 값 을 증가 하는데* /for (int i = 0; i <numPixels (); i ++) { /*변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 증가*/ if ((i + Indeks) % 2 == 0) {uint32_t c = tasodifiy (255); setPixelColor (i, c); } boshqa {setPixelColor (i, tasodifiy (255)); }} / *애니메이션 을 보여주는 함수 * / show (); Kattalashtirish (); } /*Meteor 의 시간 과 방향 을 입력* / void Meteor (uint32_t color1) { /*실행 되는 패턴 패턴 METEOR* / ActivePattern = METEOR; /*시간 설정*/ Interval = Interval; / *총 구동 갯수 는 는 numPixels 갯수 에서 1 일뺀 후, *2 한 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Rang1 = rang1; Indeks = 0; }

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

void MeteorUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == Index) {setPixelColor (i, 100, tasodifiy (255), 255); } boshqa {setPixelColor (i, DimColor (getPixelColor (i))))); }} / *애니메이션 을 보여주는 함수 * / show (); Kattalashtirish (); }

/*Yorug'lik 의 시간 과 방향 을 입력 입력*/

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

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

void LightUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 150, tasodifiy (200), 40); } boshqa {setPixelColor (i, DimColor (getPixelColor (i))))); }} / *애니메이션 을 보여주는 함수 * / show (); Kattalashtirish (); }

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

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

/*BlossomUpdate -ni yangilang*/*

voss BlossomUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 255, tasodifiy (255), 100); } boshqa {setPixelColor (i, DimColor (getPixelColor (i))))); }} / *애니메이션 을 보여주는 함수 * / show (); Kattalashtirish (); }

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

/ *네오 픽셀 의 켜지 는 는 위치 와 색 을 지정 해주는 함수 */ void setAll (qizil bayt, yashil yashil, bayt ko'k) {uchun (int i = 0; i <numPixels (); i ++) {setPixelColor (i, qizil), yashil, ko'k); } ko'rsatish (); }

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

uint32_t DimColor (uint32_t rangi) {// R, G va B komponentlarini bir oz o'ngga siljiting uint32_t dimColor = Rang (Qizil (rang) >> 1, Yashil (rang) >> 1, Moviy (rang) >> 1); qaytarish dimColor; }

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

void ColorSet (uint32_t color) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, rang); } ko'rsatish (); }

/*레드 값 을 불러 옴*/

uint8_t Qizil (uint32_t rang) {qaytish (rang >> 16) & 0xFF; } /*그린 값 을 불러 불러 /* / uint8_t Yashil (uint32_t rang) {qaytish (rang >> 8) & 0xFF; } /*블루 값 을 불러 불러 /* / uint8_t Moviy (uint32_t rang) {qaytish rangi & 0xFF; }

/*Kamalak 컬러 를 불러 옴*/

uint32_t Wheel (WheelPos bayt) {WheelPos = 255 - WheelPos; if (WheelPos <85) {Qaytish Rangi (255 - WheelPos * 3, 0, WheelPos * 3); } if if (WheelPos <170) {WheelPos -= 85; Qaytish rangi (0, WheelPos * 3, 255 - WheelPos * 3); } boshqa {WheelPos -= 170; Qaytish rangi (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

/*tasma 을 불러 오기 위 위 위 위 위 함수***** / /**

bo'sh chiziq 1Complete (); void strip2Complete (); void strip3Complete (); void strip4Complete (); bo'sh tasma5Complete ();

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

#define NUMPIXELS 74 /*사용 하는 버튼 의 갯수 갯수 설정* / #define B_NUM 5 /*Import strip1 ~ 5 까지, 74 개 스트립 연결 핀 은 strip1 은 8 ~ strip5 까지 12* / NeoPatterns strip1 (74, 8, NEO_GRB + NEO_KHZ800, & strip1Complete); NeoPatterns strip2 (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 tasmasi5 (74, 12, NEO_GRB + NEO_KHZ800, & strip5Complete); /*배열 을 사용한 연결 버튼 핀 설정*/ const int buttonPin [B_NUM] = {2, 3, 4, 5, 6}; /*배열 을 사용 하여 하여 버튼 상태 를 지정 해줌*/ int tugmasiState [B_NUM]; /*2 번핀 부터 6 번핀 까지 상태 는 순서 대로 LOW 임*/ int lastButtonState [B_NUM] = {LOW, LOW, LOW, LOW, LOW}; /*2 번핀 부터 6 번핀 까지 버튼 카운터 를 초기화 초기화*/ int tugmasiCounter [B_NUM] = {0, 0, 0, 0, 0}; /*2 번핀 부터 6 번핀 까지 최대 버튼 카운터 는 5 임*/ int tugmasiCounterMax = 5; /*모든 버튼 핀 을 을 읽 일수 있도록 변수/*/ int o'qish [B_NUM]; imzosiz uzoq lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 을 읽는 시간 간격 은 delay 50 과**/ imzosiz uzoq debounceDelay = 50;

bo'sh o'rnatish () {

/*복잡 하게 저항 연결 이 이 없도록 인풋 풀업 풀업 방식 방식 G: GND - 5V (Pin raqamiga ulanish)*/ for (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 임*/

int hisoblagich = 5; void loop () { /*버튼 수 보다 i 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (o'qish ! = buttonState ) {buttonState = o'qish ; buttonCounter ++; /*버튼 카운팅 이 위에서 위에서 한 한 Max Max 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = o'qish ; } /*모든 스트립 을 업데이트 함.* / Strip1. Update (); strip2. Update (); strip 3. Yangilash (); strip4. Update (); strip 5. Yangilash ();

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

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

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

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

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

switch (buttonCounter [1]) {0 holat: strip2. ActivePattern = STAR; chiziq 2. Interval = 50; strip2. TotalSteps = strip2.numPixels (); tanaffus; 1 -holat: strip2. ActivePattern = RAINBOWSPARKLE; chiziq 2. Interval = 100; strip2. TotalSteps = strip2.numPixels (); tanaffus; 2 -holat: strip2. ActivePattern = SCANNER; chiziq 2. Interval = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; tanaffus; 3 -holat: strip2. ActivePattern = TWINKLE; chiziq 2. Interval = 5; strip2. TotalSteps = strip2.numPixels (); tanaffus; 4 -holat: strip2. ActivePattern = METEOR; chiziq 2. Interval = 40; strip2. TotalSteps = strip2.numPixels (); tanaffus; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [2]) {0 holat: strip3. ActivePattern = STAR; strip 3. Interval = 50; strip3. TotalSteps = strip3.numPixels (); tanaffus; 1 -holat: strip3. ActivePattern = RAINBOWSPARKLE; strip 3. Interval = 100; strip3. TotalSteps = strip3.numPixels (); tanaffus; 2 -holat: strip3. ActivePattern = SCANNER; strip 3. Interval = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; tanaffus; 3 -holat: strip3. ActivePattern = TWINKLE; strip 3. Interval = 5; strip3. TotalSteps = strip3.numPixels (); tanaffus; 4 -holat: strip3. ActivePattern = METEOR; strip 3. Interval = 25; strip3. TotalSteps = strip3.numPixels (); tanaffus; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [3]) {0 holat: strip4. ActivePattern = STAR; chiziq 4. Interval = 50; strip4. TotalSteps = strip4.numPixels (); tanaffus; 1 -holat: strip4. ActivePattern = RAINBOWSPARKLE; chiziq 4. Interval = 100; strip4. TotalSteps = strip4.numPixels (); tanaffus; 2 -holat: strip4. ActivePattern = SCANNER; chiziq 4. Interval = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; tanaffus; 3 -holat: strip4. ActivePattern = TWINKLE; tasma 4. Interval = 5; strip4. TotalSteps = strip4.numPixels (); tanaffus; 4 -holat: strip4. ActivePattern = METEOR; strip4. Interval = 25; strip4. TotalSteps = strip4.numPixels (); tanaffus; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [4]) {0 holat: strip5. ActivePattern = STAR; chiziq 5. Interval = 50; strip5. TotalSteps = strip5.numPixels (); tanaffus; 1 -holat: strip5. ActivePattern = RAINBOWSPARKLE; chiziq 5. Interval = 100; strip5. TotalSteps = strip5.numPixels (); tanaffus; 2 -holat: strip5. ActivePattern = SCANNER; chiziq 5. Interval = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; tanaffus; 3 -holat: strip5. ActivePattern = TWINKLE; tasma 5. Interval = 5; strip5. TotalSteps = strip5.numPixels (); tanaffus; 4 -holat: strip5. ActivePattern = METEOR; chiziq 5. Interval = 25; strip5. TotalSteps = strip5.numPixels (); tanaffus; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Qayta qo'ng'iroqni tugatish

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

// strip2 Qayta qo'ng'iroqni tugatish

void strip2Complete () {strip2. Color1 = strip2. Teker (tasodifiy (255)); strip2. Color2 = strip2. Wheel (tasodifiy (255)); strip2. Index = 0; }

// strip3 Qayta qo'ng'iroqni tugatish

void strip3Complete () {strip3. Color1 = strip3. Teker (tasodifiy (255)); strip3. Color2 = strip3. Wheel (tasodifiy (255)); strip3. Index = 0; }

// strip4 tugallangan qayta qo'ng'iroq

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

// strip5 tugallangan qayta qo'ng'iroq

void strip5Complete () {strip5. Color1 = strip5. Teker (tasodifiy (255)); strip5. Color2 = strip5. Teker (tasodifiy (255)); strip5. Index = 0; }

6 -qadam: natija va film yaratish

Loyihamizga bo'lgan qiziqishingiz uchun rahmat, lekin bu etarli emas.