Povucite svjetlo - Modul svjetla pomoću neopiksela i prekidača za povlačenje prema gore: 6 koraka (sa slikama)

2024 Autor: John Day | [email protected]. Zadnja promjena: 2024-01-30 09:35

Značajke svjetlosnog modula

• Arduino Uno
• Hardver i kućište kupljeni s interneta
• Neopixel & Power Supply posuđeno od School of Informatics & Product Design
• Svjetlosni modul kontroliran napajanjem
• Sve funkcije kontrolirane su interakcijom korisnika
• Vrste animacija Neopixel trake: Kiša, Vrsta tuša, Vrsta svjećice, Tip Pop, Nepravilan tip
• Prekidač za povlačenje spojen je na Neopixel traku i animacija se mijenja kada se povuče Neopixel traka

Korak 1: Prije nego počnemo

Pozdrav instruktori i tvorci.

Počeli smo s interaktivnim dizajnerskim projektom u smislu onoga što bi se dogodilo ako bismo mogli osjetiti emociju kiše kroz animaciju svjetla. Mislio sam da će senzibilitet korisnika biti maksimiziran kroz sučelje koje izravno privlači svjetlo.

Da se ne bacimo na posao

Korak 2: Potrebni dijelovi

Na temelju jednog svjetlosnog modula

*** Neopikseli i napajanje korišteni su uz podršku našeg odjela. ***

Elektronika:

1. Arduino Uno
2. Žica u 3 boje (crna, crvena, bilo koja boja)
3. 3 -pinski konektor (veza za kupnju)
4. Povucite prekidač 1 (veza za kupnju)
5. cijev za skupljanje
6. WS2812b adresirana LED traka sa 74 LED (traka od neopiksela)*2
7. Napajanje (5V 350A) 1

*** Za Arduino, prekidač za povlačenje i NeoPixele potrebno je 50 kompleta. ***

Hardver:

1. Akrilna šipka 2t (10 mm*1000 mm) 1
2. Akrilna ploča 5t (60 mm*60 mm) 1
3. Foemax 10t (1200 mm*1800 mm) 1
4. Crni sprej
5. Kabelska vezica
6. Niz
7. Tvrda ploča
8. Mrežna ploča

Korak 3: Povezivanje i izgradnja hardvera

Prvo nam je potrebno rezanje akrilom za izradu jednog modula za osvjetljenje.

• Kao način da doživite animaciju svjetla, nacrtajte modul rasvjete koji je fiksiran pričvršćivanjem 74 LED diode u obliku trake od neopiksela na akrilnu šipku debljine 2 mm s površinom od 1 M. Proizveli smo dvije vrste rasvjetnih modula: tipične linearne i spiralne.
• Za linearne tipove, postojeće neopikselne trake mogu se držati i učvrstiti, ali spiralne vrste zahtijevaju ručni rad. Svaki od 74 LED diode podijeljen je na komade, pričvršćen na spiralni akril i spojen olovom.

Pričvrstite Neopixel traku na akril i pričvrstite svaku traku da se spriječi njeno širenje toplinom ili je zavežite tankom ribarskom vrpcom. U slučaju linearnog tipa, kugla koju je trebalo povući na kraj modula instalirana je kako bi se oblikovao estetski izgled, a loptu za stolni tenis dovršili smo crnim sprejom. Zatim su izbušili malu rupu u kugli za stolni tenis i povezali je užetom. Sljedeći najvažniji dio, prekidač i neopiksel, spojeni su kako je prikazano. Prekidač je zatim pričvršćen na stropnu policu.

U slučaju spiralnog tipa, postoji opasnost da bi izravno povlačenje spiralnog modula moglo razbiti akril pod pritiskom, pa su potezni dio (ulaz) i modul (izlaz) razdvojeni. Kako bi se povećalo padanje svjetlosti, moduli su postavljeni okomito na strop, linearni moduli pričvršćeni su na zrak, spirale su pričvršćene izravno na strop. Spojili smo loptu za ping pong i prekidač na ribarsku liniju kako bi se njome moglo upravljati.

Akrilno rezanje kako je prikazano na gornjoj slici potrebno je za pričvršćivanje prekidača na policu. Prekidač kvadratnog oblika od 6 cm debljine je otprilike 5 mm, s prekidačem u sredini i kabelskom vezicom umetnutom kroz rupe na obje strane kako bi se prekidač čvrsto učvrstio. Kružna rupa na dnu središta otkriva povlačenje prekidača, ispod kojeg se trožični kabel izvlači i spaja na kabelski terminal modula. Slično, kroz rupu u četiri ugla polica i akril su učvršćeni kabelskim vezicama. Kao što je gore opisano, linearni modul spojen je izravno na povlačenje, ali spiralni modul zasebno povezuje iglu i prekidač.

Korak 4: Kreirajte pomoću 50 svjetlosnih modula

Osmislili smo korisničko iskustvo za bogatiju svjetlost primjenom ukupno 50 modula

Imali smo policu širine 1 800 mm i duljinu 1 200 mm, a svaki prekidač i modul smo spojili tako da ste mogli iskusiti kišu i kišno okruženje koje smo prvotno planirali, a svaki smo modul imali samostalno kako bismo omogućili obavljanje više zadataka.

Ovisno o crtežu projekta, u foemax je izbušena okrugla rupa kako bi se sakrila instalacija i kako bi se osiguralo da povezano područje LED modula nije vidljivo. Budući da je udaljenost od akrilne ploče do priključka LED modula na koji je priključen prekidač oko 1 cm, upotrijebljen je foemax debljine 1 cm.

Metalni kvadratni okvir korišten je za držanje instalacije zajedno s vijcima i vezicama za kabele uz održavanje ukupne težine i ravnoteže. Ako je duljina izloženih spojeva veća od one kada proizvođač pokuša, deblja ploča je neučinkovita i preporučuju se druge strukture.

Kako bi se olakšalo korisničko iskustvo u visini očiju, dovršena instalacija postavljena je na nosač visok približno 2 m, ali oprez je da je vrlo nezgodno instalirati ugrađeni LED modul s prekidačem, pa bi se sve veze trebale ukloniti. Popeli smo se ljestvama i spojili modul s instalacijom pričvršćenom na nosač.

Najvažniji dio cijelog ovog procesa je osigurati da se posao obavlja sigurno i potpuno osiguran kako bi se osiguralo da je iskustvo omogućeno u sigurnom okruženju

Ukupno je korišteno 10 arduino i 50 LED modula, a spojeno je pet LED modula po arduinu za učinkovitije i besprijekorno obavljanje više zadataka. Za detalje pogledajte priloženi nacrt. Neopikselno kodiranje s više zadataka pomoću potpunog prekidača prema shemi dizajna bit će detaljno obrađeno u sljedećem koraku.

Korak 5: Arduino kodiranje i ožičenje

Ožičenje

• 50 modula spojeno je prema rasporedu iz koraka 4.
• Svaki je modul bio podijeljen u 10 kompleta od 50 modula kako bi se omogućilo obavljanje više zadataka i omogućila jasna veza.
• Kao što je prikazano na gornjoj slici skupa 1, pet modula je spojeno na jedan arduino, a 5 -pinski pinovi neopiksela su povezani odjednom kako bi se spojilo napajanje.
• GND neopiksela i prekidači također su povezani zajedno, a radi lakše percepcije, prekidači su uključeni u pinove 2, 3, 4, 5, 6, a neopikseli su priključeni u pinove 9, 10, 11, 12, 13.
• Prekidači i neopikseli povezani su na 2-9, 3-10, 4-11, 5-12, 6-13 načina.
• Valja napomenuti da se budući da su spojevi vodova složeni i postoji opasnost od požara zbog kratkih spojeva, cijev koja se skuplja zagrijala kako bi se osiguralo da se slabi dijelovi ne slome.

Neopikselno kodiranje za više zadataka s prekidačem na izvlačenje

5 svjetlosnih animacija (vrsta kiše, tip tuša, vrsta svjećice, tip pop, nepravilni tip)

#uključi

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

uzorak nabrajanja {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 픽셀 을 방향 을 설정/*/ smjer nabrajanja {FORWARD, REVERSE};

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

razred NeoPatterns: javni Adafruit_NeoPixel { /* 패턴 을 추가 하고 업데이트 하기 위한 /* / public: pattern ActivePattern; /*클레스 함수 에 패턴 의 방향 을/*/ smjer Smjer;

/*변수 Interval 을 추가*/ nepotpisani dugi interval; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 Boja1, Boja2 를 추가*/ uint32_t Boja1, Boja2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Indeks 를 추가*/ uint16_t Indeks;

/*패턴 을 을 했을 시 다시 불러오는/*/ void (*OnComplete) (); /*네오 패턴 에서 네오 픽샐 의 갯수, 핀 번호, 타입, 콜백 을 불러오는/*/ NeoPatterns (uint16_t piksela, uint8_t pin, uint8_t tip, void (*povratni poziv) ()): Adafruit_NeoPixel (pikseli, pin, tip) { OnComplete = povratni poziv; }

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

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

/*kućište THEATER_CHASE 에서는 TheaterChaseUpdate 를 실행 하라*/

slučaj THEATER_CHASE: TheaterChaseUpdate (); /*case THEATER_CHASE 에서 나와라*/ break;

/*kućište COLOR_WIPE 에서는 ColorWipeUpdate 를 실행 하라*/

kućište COLOR_WIPE: ColorWipeUpdate (); /*kućište COLOR_WIPE 에서 나와라*/ break; /*SCANNER case 에서는 ScannerUpdate 를 실행 하라*/ case SCANNER: ScannerUpdate (); /*case SCANNER 에서 나와라*/ break;

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

slučaj FADE: FadeUpdate (); /*case FADE 에서 나와라*/ break;

/*kućište TWINKLE 에서는 TwinkleUpdate 를 실행 하라*/

slučaj TWINKLE: TwinkleUpdate (); /*kućište TWINKLE 에서 나와라*/ break;

/*kućište STAR 에서는 StarUpdate 를 실행 하라*/

slučaj STAR: StarUpdate (); /*kućište STAR 에서 나와라*/ break;

/*kućište RAINBOWSPARKLE 에서는 RainbowsparkleUpdate 를 실행 하라*/

slučaj RAINBOWSPARKLE: RainbowsparkleUpdate (); /*kućište RAINBOWSPARKLE 에서 나와라*/ break; /*slučaj METEOR 에서는 MeteorUpdate 를 실행 하라*/ slučaj METEOR: MeteorUpdate (); /*kućište METEOR 에서 나와라*/ break;

/*kućište LIGHT 에서는 LightUpdate 를 실행 하라*/

kućište LIGHT: LightUpdate (); /*kućište LIGHT 에서 나와라*/ break;

/*kućište BLOSSOM 에서는 BlossomUpdate 를 실행 하라*/

slučaj BLOSSOM: BlossomUpdate (); /*kućište BLOSSOM 에서 나와라*/ break; }}}

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

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

void Povećanje () { /*만약 정방향 이면 인덱스 를 증가 /* / if (Smjer == NAPRIJED) {Indeks ++; /*만약 인덱스 가 전체 네오 픽셀 구동 갯수 와 같 거나 면 으로 0 으로 초기화/*/ if (Indeks> = TotalSteps) {Indeks = 0; /*패턴 을 완료 시키는/*/ if (OnComplete! = NULL) {OnComplete (); }}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void ColorWipeUpdate () { /*index 를 컬러 1 로 변환 시켜라* / setPixelColor (Index, Color1); / *애니메이션 을 보여주는/ */ show (); Povećanje (); }

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

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

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

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

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

void Fade (uint32_t color1, uint32_t color2, uint16_t koraci, uint8_t interval, smjer dir = NAPRIJED) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 void Fade () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*구동 갯수 는 는/*/ TotalSteps = koraci; /*컬러 1, 2 를 설정*/ Boja1 = boja1; Boja2 = boja2; /*인덱스 는 0 으로 설정/*/ Indeks = 0; /*방향 은 void Fade () 안에 입력 되는 dir = NAPRIJED 과 같음*/ Smjer = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 crveno 값 은 다음 과 /* / uint8_t crveno = ((Crveno (Boja1)*(TotalSteps - Indeks)) + (Crveno (Boja2)*Indeks)) / TotalSteps; / * 변수 zelena 값 은 다음 과 같음 * / uint8_t zelena = ((zelena (boja1) * (ukupni koraci - indeks)) + (zelena (boja2) * indeks)) / ukupni koraci; / * 변수 plavo 값 은 다음 과 같음 * / uint8_t plavo = ((Plavo (Boja1) * (Ukupno koraka - Indeks)) + (Plavo (Boja2) * Indeks)) / TotalSteps; /*위 의 crvena, zelena, plava 값 으로 컬러 를 셋팅/*/ ColorSet (Boja (crvena, zelena, plava)); / *애니메이션 을 보여주는/ */ show (); Povećanje (); }

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

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 를 설정*/ Boja1 = boja1; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Indeks = 0; }

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

void TwinkleUpdate () { /*모든 네오 픽셀 의 컬러 를 0 으로 셋팅* / setAll (0, 0, 0); /*변수 Pixel 은 random 74*/ int Pixel = random (74); /*slučajno 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 (Pixel, 0, 0, 0); / *애니메이션 을 보여주는/ */ show (); Povećanje (); }

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

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

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

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

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

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

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

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

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

void MeteorUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == Index) {setPixelColor (i, 100, random (255), 255); } else {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 / * / show (); Povećanje (); }

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

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

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

void LightUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 150, random (200), 40); } else {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 / * / show (); Povećanje (); }

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

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

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

void BlossomUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 255, random (255), 100); } else {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 / * / show (); Povećanje (); }

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

/ *네오 픽셀 의 켜지 는 위치 와 색 을 지정 해주는/ */ void setAll (bajt crveno, bajt zeleno, bajt plavo) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, crveno, zelena, plava); } show (); }

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

uint32_t DimColor (boja uint32_t) {// Pomicanje komponenti R, G i B za jedan bit udesno uint32_t dimColor = Boja (Crvena (boja) >> 1, Zelena (boja) >> 1, Plava (boja) >> 1); povratak dimColor; }

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

void ColorSet (uint32_t boja) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, boja); } show (); }

/*레드 값 을 불러 옴*/

uint8_t Crveno (uint32_t boja) {return (boja >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Zeleno (uint32_t boja) {return (boja >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t Plava (uint32_t boja) {povratna boja & 0xFF; }

/*Duga 컬러 를 불러 옴*/

uint32_t Kotač (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return Color (255 - WheelPos * 3, 0, WheelPos * 3); } else if (WheelPos <170) {WheelPos -= 85; return Color (0, WheelPos * 3, 255 - WheelPos * 3); } else {WheelPos -= 170; povratna boja (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

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

void strip1Complete (); void strip2Complete (); void strip3Complete (); void strip4Complete (); void strip5Complete ();

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

#define NUMPIXELS 74 /*사용 하는 버튼 의 갯수 설정* / #define B_NUM 5 /*Uvoz trake1 ~ 5 까지, 갯수 는 74 개 스트립 연결 핀 traka1 은 8 ~ traka5 까지 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 strip5 (74, 12, NEO_GRB + NEO_KHZ800, & strip5Complete); /*배열 을 사용한 연결 버튼 핀 설정*/ const int buttonPin [B_NUM] = {2, 3, 4, 5, 6}; /*배열 을 사용 하여 버튼 상태 를 지정/*/ int buttonState [B_NUM]; /*2 번핀 부터 6 번핀 까지 상태 는 순서 대로 LOW 임*/ int lastButtonState [B_NUM] = {LOW, LOW, LOW, LOW, LOW}; /*2 번핀 부터 6 번핀 까지 버튼 카운터 를 초기화/*/ int buttonCounter [B_NUM] = {0, 0, 0, 0, 0}; /*2 번핀 부터 6 번핀 까지 최대 버튼 카운터 임 5 임*/ int buttonCounterMax = 5; /*모든 버튼 핀 을 읽 일수 있도록 변수/*/ int čitanje [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 delay50 과 같음*/ unsigned long debounceDelay = 50;

void setup () {

/*복잡 하게 저항 연결 이 필요 없도록 인풋 풀업 G G G G: GND - 5V (povežite se s brojem kontakta)*/ 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, NAPRIJED);

}

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

int brojač = 5; void loop () { /*버튼 수 보다 i 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (čitanje ! = buttonState ) {buttonState = čitanje ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 Max 값 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = čitanje ; } /*모든 스트립 스트립 을**.* / Strip1. Update (); strip2. Update (); strip3. Update (); strip4. Update (); strip5. Update ();

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

/*Podijeli 0 stavki. 2 번핀 에 연결된 버튼 을 활용 하여 애니메이션 이 되도록 하는 스위치 케이스/*/ switch (buttonCounter [0]) {

/*첫번째 버튼 을 활동 시키면 구동 되는/*/

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

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

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

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

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

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

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

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

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

// strip1 Completion Povratni poziv

void strip1Complete () {strip1. Color1 = strip1. Wheel (nasumično (255)); traka1. Boja2 = traka1. Točak (nasumično (255)); strip1. Index = 0; }

// strip2 Completion Povratni poziv

void strip2Complete () {strip2. Color1 = strip2. Wheel (nasumično (255)); traka2. Boja2 = traka2. Točak (nasumično (255)); strip2. Index = 0; }

// strip3 Dovršetak Povratni poziv

void strip3Complete () {strip3. Color1 = strip3. Wheel (nasumično (255)); strip3. Boja2 = strip3. Točak (nasumično (255)); strip3. Index = 0; }

// strip4 Completion Povratni poziv

void strip4Complete () {strip4. Color1 = strip4. Wheel (nasumično (255)); traka4. Boja2 = traka4. Točak (nasumično (255)); strip4. Index = 0; }

// strip5 Završetak Povratni poziv

void strip5Complete () {strip5. Color1 = strip5. Wheel (nasumično (255)); strip5. Color2 = strip5. Wheel (nasumično (255)); strip5. Index = 0; }

Korak 6: Rezultat i stvaranje filma

Hvala vam na interesu za naš projekt, iako to nije dovoljno.