Tõmmake valgus - valgusmoodul Neopixeli ja üles tõmbamise lüliti abil: 6 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:48

Valgusmooduli omadused

• Arduino Uno
• Riistvara ja ümbris ostetud Internetist
• Neopixel ja toiteallikas on laenatud informaatika- ja tootedisaini koolist
• Valgusmoodul, mida juhib toide
• Kõiki funktsioone juhitakse kasutajate suhtluse kaudu
• Neopikselriba animatsioonitüübid: vihmatüüp, dušitüüp, sädemevälk, pop -tüüp, ebaregulaarne tüüp
• Ülestõmmatav lüliti on ühendatud Neopixeli ribaga ja animatsioon muutub Neopixeli riba tõmbamisel

Samm: enne kui alustame

Tere juhendajad ja tegijad.

Alustasime interaktiivset disainiprojekti seoses sellega, mis juhtuks, kui saaksime valguse animatsiooni abil tunda vihma emotsioone. Ma arvasin, et kasutaja tundlikkus oleks maksimaalne liidese kaudu, mis tõmbab valgust otse.

Et ei hakkaks tööle

2. samm: vajalikud osad

Põhineb ühel valgusmoodulil

*** Meie osakonna toel kasutati neopiksleid ja toiteallikat. ***

Elektroonika:

1. Arduino Uno
2. 3 värvi juhe (must, punane, mis tahes värv)
3. 3 -pin pistik (link ostmiseks)
4. Tõmmake lüliti 1 üles (link ostmiseks)
5. kahanev toru
6. WS2812b lisatav LED -riba 74 LED -iga (neopikselriba)*2
7. Toide (5V 350A) 1

*** Arduino, Pull Switch ja NeoPixels jaoks on vaja 50 komplekti. ***

Riistvara:

1. Akrüülvarda 2t (10mm*1000mm) 1
2. Akrüülplaat 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Must pihusti
5. Kaabli lips
6. String
7. Kiudplaat
8. Võrgutahvel

3. samm: ühenduvus ja riistvara ehitamine

Esiteks vajame ühe valgustusmooduli valmistamiseks akrüüllõikust.

• Valguse animatsiooni kogemiseks joonistage valgustusmoodul, mis kinnitatakse, kinnitades 74 LED -i neopikseliriba kujul 2 mm paksusele 1M alaga akrüülvardale. Oleme tootnud kahte tüüpi valgustusmooduleid: tüüpiline lineaarne ja spiraalne.
• Lineaarsete tüüpide puhul saab olemasolevaid neopikseliribasid hoida ja kinnitada, kuid spiraaltüübid nõuavad käsitsi juhtimist. Kõik 74 LED -i on tükeldatud, kinnitatud spiraalse akrüüli külge ja ühendatud pliiga.

Kinnitage Neopixeli riba akrüüli külge ja kinnitage iga riba, et vältida kuumuse levikut, või ühendage see õhukese õngenööriga. Lineaarse tüübi korral paigaldati esteetilise väljanägemise kujundamiseks kera, mis tuli mooduli otsa tõmmata, ja viimistlesime pingipalli musta pihustiga. Seejärel puurisid nad pingpongi kuuli väikese augu ja ühendasid selle köiega. Järgmine kõige olulisem osa, lüliti ja neopiksel, on ühendatud nagu näidatud. Seejärel kinnitatakse lüliti lae riiuli külge.

Spiraalitüübi puhul on oht, et spiraalmooduli otsene tõmbamine võib akrüüli rõhu all purustada, mistõttu tõmbeosa (sisend) ja moodul (väljund) eraldati. Valguse langemise maksimeerimiseks paigaldati moodulid lakke vertikaalselt, lineaarsed moodulid kinnitati õhu külge, spiraalid kinnitati otse lakke. Ja me ühendasime pingpongi palli ja lüliti õngenööri külge, et seda saaks kasutada.

Lüliti riiuli külge kinnitamiseks on vajalik ülaltoodud joonisel näidatud akrüüllõikamine. 6 cm ruudukujuline lüliti on umbes 5 mm paksune, lüliti on tsentreeritud ja kaabliklamber on mõlemal küljel läbi aukude sisestatud, et lüliti kindlalt kinnitada. Keskuse allosas olev ümmargune auk paljastab lüliti tõmbe, millest allpool tõmmatakse välja kolmejuhtmeline kaabel ja ühendatakse mooduli kaabliklemmiga. Ja sarnaselt kinnitatakse riiul ja akrüül nelja nurga augu kaudu kaablisidemetega. Nagu eespool kirjeldatud, on lineaarne moodul ühendatud otse tõmbega, kuid spiraalmoodul ühendab tihvti ja lüliti eraldi.

4. samm: loomine 50 valgusmooduli abil

Oleme loonud rikkaliku valguse jaoks kasutuskogemuse, võttes kasutusele kokku 50 moodulit

Meil oli riiul, mille laius oli 1 800 mm ja pikkus 1 200 mm, ja me ühendasime iga lüliti ja mooduli nii, et saaksite kogeda vihma ja vihma keskkonda, mida me algselt plaanisime, ning meil oli iga moodul eraldi, et võimaldada mitme ülesande täitmist.

Sõltuvalt konstruktsioonijoonisest puuriti foemaxisse ümmargune auk, et varjata paigaldust ja veenduda, et LED -mooduli ühendatud ala pole nähtav. Kuna kaugus akrüülplaadist LED -mooduli ühenduseni, kus lüliti on kinnitatud, on umbes 1 cm, kasutati 1 cm paksust foemaxi.

Metallist ruudukujulist raami kasutati paigalduse hoidmiseks koos kruvide ja kaablisidemetega, säilitades samal ajal üldkaalu ja tasakaalu. Kui avatud ühenduste pikkus on valmistaja proovimisel suurem, on paksem plaat ebaefektiivne ja soovitatakse kasutada muid struktuure.

Kasutaja silmade kõrgusel kogemise hõlbustamiseks asetatakse lõpetatud paigaldus umbes 2 m kõrgusele toele, kuid ettevaatlik on see, et sisseehitatud LED -mooduli paigaldamine koos lülitiga on väga tülikas, mistõttu tuleb kõik ühendused eemaldada. Ronisime redelist üles ja ühendasime mooduli toega kinnitatud paigaldusega.

Kogu selle protsessi kõige olulisem osa on tagada töö turvaline ja täielik turvalisus, et tagada kogemuste saamine turvalises keskkonnas

Kokku kasutati 10 arduino ja 50 LED-moodulit ning viis LED-moodulit ühendati iga arduino kohta tõhusamaks ja sujuvamaks mitme ülesande täitmiseks. Üksikasju vt lisatud plaanist. Neopixeli mitme ülesande kodeerimist, kasutades täislülitit vastavalt konstruktsiooniskeemile, käsitletakse üksikasjalikult järgmises etapis.

Samm: Arduino kodeerimine ja juhtmestik

Juhtmestik

• 50 moodulit ühendati vastavalt 4. sammu skeemile.
• Iga moodul oli jagatud kümneks 50-mooduliliseks komplektiks, et võimaldada mitut ülesannet ja pakkuda selget ühendust.
• Nagu on näidatud ülaltoodud komplekti 1 pildil, ühendati viis moodulit ühe arduinoga ja neopikseli 5 -voldised ühendati toiteallika ühendamiseks korraga.
• Samuti seoti kokku neopikslite ja lülitite GND ning tajumise hõlbustamiseks ühendati lülitid tihvtidega 2, 3, 4, 5, 6 ja neopikslid pistikutega 9, 10, 11, 12, 13.
• Lülitid ja neopikslid ühendati vastavalt 2-9, 3-10, 4-11, 5-12, 6-13 viisil.
• Tuleb märkida, et kuna liinide ühendused on keerulised ja lühise tõttu on tuleoht, kuumutati kahanev toru, et tagada nõrkade osade purunemine.

Neopixeli mitme ülesande kodeerimine koos üleslülituslülitiga

5 kerget animatsiooni (vihmatüüp, duši tüüp, sädemevälk, pop -tüüp, ebaregulaarne tüüp)

#kaasake

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

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

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

klassi NeoPatterns: avalik Adafruit_NeoPixel { /* 패턴 을 추가 하고 업데이트 하기 위한 함수* / public: muster ActivePattern; /*클레스 함수 에 패턴 의 방향 을 입력*/ suund Suund;

/*변수 Intervall 을 추가*/ allkirjastamata pikk intervall; /*변수 lastUpdate 를 추가*/ allkirjastamata pikk lastUpdate; /*변수 Värv1, Värv2 를 추가*/ uint32_t Värv1, Värv2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Indeks 를 추가*/ uint16_t Indeks;

/*패턴 을 완료 했을 시 다시 불러오는 함수*/ void (*OnComplete) (); /*네오 패턴 에서 네오 의 핀, 핀 번호, 타입, 콜백 을 함수 함수*/ NeoPatterns (uint16_t pikslit, uint8_t pin, uint8_t tüüp, void (*tagasihelistamine) ()): Adafruit_NeoPixel (pikslit, tihvt, tüüp) { OnComplete = tagasihelistamine; }

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

tühine värskendus () { /*패턴 의 시간 설정. 멀티 태스킹 을 구현 하는 구문*/ if ((millis () - lastUpdate)> Intervall) {lastUpdate = millis (); /*ActivePattern 의 스위치 구문*/ lüliti (ActivePattern) {/*juhtum RAINBOW_CYCLE 에서는 RainbowCycleUpdate 를 실행 하라*/ case RAINBOW_CYCLE: RainbowCycleUpdate (); /*juhtum RAINBOW_CYCLE 에서 나와라*/ break;

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

juhtum THEATER_CHASE: TheaterChaseUpdate (); /*juhtum THEATER_CHASE 에서 나와라*/ break;

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

juhtum COLOR_WIPE: ColorWipeUpdate (); /*juhtum COLOR_WIPE 에서 나와라*/ break; /*korpuse SKANNER 에서는 ScannerUpdate 를 실행 하라*/ juhtumi SKANNER: ScannerUpdate (); /*juhtum SKANNER 에서 나와라*/ murda;

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

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

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

juhtum TWINKLE: TwinkleUpdate (); /*juhtum TWINKLE 에서 나와라*/ murda;

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

juhtum STAR: StarUpdate (); /*ümbris STAR 에서 나와라*/ murda;

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

juhtum RAINBOWSPARKLE: RainbowsparkleUpdate (); /*ümbris RAINBOWSPARKLE 에서 나와라*/ murda; /*juhtum METEOR 에서는 MeteorUpdate 를 실행 하라*/ juhtum METEOR: MeteorUpdate (); /*juhtum METEOR 에서 나와라*/ murda;

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

juhtum LIGHT: LightUpdate (); /*korpus LIGHT 에서 나와라*/ murda;

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

juhtum BLOSSOM: BlossomUpdate (); /*ümbris BLOSSOM 에서 나와라*/ break; }}}

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

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

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

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

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

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

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

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

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

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

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

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

tühine TheaterChase (uint32_t color1, uint32_t color2, uint8_t intervall, suund dir = FORWARD) { /*실행 되는 패턴 은 RTHEATER_CHASE* / ActivePattern = THEATER_CHASE; /*시간 은 tühine TheaterChase () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1, 2 를 설정*/ Värv1 = värv1; Värv2 = värv2; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 tühine TheaterChase () 안에 입력 되는 dir = FORWARD FOR 같음*/ Direction = dir; }

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

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

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

tühine ColorWipe (uint32_t värv, uint8_t intervall, suund dir = FORWARD) { /*실행 되는 패턴 은 COLOR_WIPE* / ActivePattern = COLOR_WIPE; /*시간 은 void ColorWipe () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Värv1 = värv; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void ColorWipe () 안에 입력 되는 dir = FORWARD FOR 같음*/ Direction = dir; }

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

void ColorWipeUpdate () { /*indeks 를 컬러 1 로 변환 시켜라* / setPixelColor (indeks, värv1); / *애니메이션 을 보여주는 함수 */ show (); Suurendus (); }

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

tühine skanner (uint32_t color1, uint8_t intervall) { /*실행 되는 패턴 은 SKANNER* / ActivePattern = SKANNER; /*시간 은 tühine skanner () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*구동 갯수 는 총 갯수 에서 1 을 빼고 2 를 곱 해라*/ TotalSteps = (arvPikslid () - 1)*2; /*컬러 1 을 설정*/ Värv1 = värv1; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; }

/*Skanneri uuendamine 를 업데이트 했을 경우*/

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

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

void Fade (uint32_t color1, uint32_t color2, uint16_t sammu, uint8_t intervall, suund dir = FORWARD) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 void Fade () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*구동 갯수 는 스텝 값임*/ TotalSteps = sammud; /*컬러 1, 2 를 설정*/ Värv1 = värv1; Värv2 = värv2; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void Fade () 안에 입력 되는 dir = FORWARD FOR 같음*/ Direction = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 punane 값 은 다음 과 같음* / uint8_t red = (((punane (värv1)*(TotalSteps - indeks)) + (punane (värv2)*indeks)) / TotalSteps; / * 변수 roheline 값 은 다음 과 같음 * / uint8_t green = ((Green (Color1) * (TotalSteps - Index)) + (Green (Color2) * Index)) / TotalSteps; / * 변수 sinine 값 은 다음 과 같음 * / uint8_t blue = ((sinine (värv1) * (TotalSteps - indeks)) + (sinine (värv2) * indeks)) / TotalSteps; /*위 의 punane, roheline, sinine 값 으로 컬러 를 셋팅 함*/ ColorSet (värv (punane, roheline, sinine)); / *애니메이션 을 보여주는 함수 */ show (); Suurendus (); }

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

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

/*Sära 의 컬러 1 와 시간 을 입력*/

tühine Twinkle (uint32_t color1, uint8_t intervall) { /*실행 되는 패턴 은 TWINKLE* / ActivePattern = TWINKLE; /*시간 은 void Twinkle () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*컬러 1 를 설정*/ Värv1 = värv1; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Indeks = 0; }

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

void TwinkleUpdate () { /*모든 네오 픽셀 의 컬러 를 0 으로 셋팅* / setAll (0, 0, 0); /*변수 Piksel 은 juhuslik 74*/ int Piksel = juhuslik (74); /*juhuslik 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 (); Suurendus (); }

/*Täht 의 컬러 1 값 을 입력*/

tühine täht (uint32_t color1) { /*실행 되는 패턴 은 STAR* / ActivePattern = STAR; /*시간 은 tühi täht () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Värv1 = värv1; Indeks = 0; }

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

void StarUpdate () { /*인덱스 와 컬러 를 셋팅* / setPixelColor (indeks, värv1); näita (); /*변수 i 가 0 이고 구동 갯수 작 으면 i 를 감소 시킴 = 한칸 씩 이동 하는*/ for (int i = 0; i <numPixels (); i--) {setPixelColor (i, värv (0, 0, 0)); } / *애니메이션 을 보여주는 함수 * / juurdekasv (); }

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

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

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

void RainbowsparkleUpdate () { /*변수 i 가 0 이고 구동 갯수 작 으면 i 값 을 증가 하는데* /for (int i = 0; i <numPixels (); i ++) { /*변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데*/ kui ((i + indeks) % 2 == 0) {uint32_t c = juhuslik (255); setPixelColor (i, c); } else {setPixelColor (i, juhuslik (255)); }} / *애니메이션 을 보여주는 함수 * / show (); Suurendus (); } /*Meteor 의 시간 과 방향 을 입력* / void Meteor (uint32_t color1) { /*실행 되는 패턴 은 METEOR* / ActivePattern = METEOR; /*시간 설정*/ Intervall = intervall; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Värv1 = värv1; 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 (); Suurendus (); }

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

tühi valgus (uint32_t color1) { /*실행 되는 패턴 은 LIGHT* / ActivePattern = LIGHT; /*시간 설정*/ Intervall = intervall; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Värv1 = värv1; 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 (); Suurendus (); }

/*Õis 의 시간 과 방향 을 입력*/

void Blossom (uint32_t color1) { /*실행 되는 패턴 은 BLOSSOM* / ActivePattern = BLOSSOM; /*시간 설정*/ Intervall = intervall; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Värv1 = värv1; 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 (); Suurendus (); }

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

/ *네오 픽셀 의 켜지 는 위치 색 을 지정 해주는 함수 */ void setAll (bait punane, bait roheline, bait sinine) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, red, roheline, sinine); } show (); }

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

uint32_t DimColor (uint32_t värv) {// Nihutage R-, G- ja B -komponente üks bit paremale uint32_t dimColor = Värv (punane (värv) >> 1, roheline (värv) >> 1, sinine (värv) >> 1); return dimColor; }

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

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

/*레드 값 을 불러 옴*/

uint8_t Punane (uint32_t värv) {return (värv >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Roheline (uint32_t värv) {return (värv >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t Blue (uint32_t color) {return color & 0xFF; }

/*Vikerkaar 컬러 를 불러 옴*/

uint32_t Ratas (bait 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); } muu {WheelPos -= 170; tagastusvärv (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

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

tühi riba1Täielik (); void strip2Complete (); tühi riba3Complete (); tühi riba4Complete (); tühi riba5Täielik ();

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

#define NUMPIXELS 74 /*사용 하는 버튼 의 갯수 설정* / #define B_NUM 5 /*Impordi riba1 ~ 5 까지, 갯수 는 74 개 스트립 연결 핀 은 riba1 은 8 ~ riba5 까지 12* / NeoPatterns riba1 (74, 8, NEO_GRB + NEO_KHZ800, & strip1Complete); NeoPatterns strip2 (74, 9, NEO_GRB + NEO_KHZ800 ja & strip2Complete); NeoPatterns strip3 (74, 10, NEO_GRB + NEO_KHZ800 ja & strip3Complete); NeoPatterns strip4 (74, 11, NEO_GRB + NEO_KHZ800 ja & strip4Complete); NeoPatterns strip5 (74, 12, NEO_GRB + NEO_KHZ800 ja & 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 nuppCounterMax = 5; /*모든 버튼 핀 을 읽 일수 있도록 변수 추가*/ int lugemine [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 delay50 과 같음*/ unsigned long debounceDelay = 50;

tühine seadistus () {

/*복잡 하게 저항 연결 이 없도록 인풋 풀업 방식 의 버튼 설정: GND - 5V (ühendage pin -numbriga)*/ jaoks (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Seriaal.algus (9600); /*스트립 1 ~ 5 를 셋팅*/ strip1.begin (); riba2.algus (); riba3.algus (); riba4.algus (); riba5 algus ();

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

}

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

int loendur = 5; void loop () { /*버튼 수 가 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (lugemine ! = buttonState ) {buttonState = lugemine ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 Max 값 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = lugemine ; } /*모든 스트립 을 업데이트 함.* / Strip1. Update (); riba2. Uuenda (); riba3. Uuenda (); riba4. Uuenda (); riba5. Värskenda ();

///// LÜLITI_2 ///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////- /////////////////////////////////////////////////////////

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

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

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

///// LÜLITUS_3 ////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////- /////////////////////////////////////////////////////////

lüliti (buttonCounter [1]) {case 0: strip2. ActivePattern = STAR; riba 2. Intervall = 50; riba2. KokkuSteps = riba2.numPikslid (); murda; juhtum 1: riba2. ActivePattern = RAINBOWSPARKLE; riba 2. Intervall = 100; riba2. KokkuSteps = riba2.numPikslid (); murda; juhtum 2: riba2. ActivePattern = SKANNER; riba 2. Intervall = 20; riba2. KokkuSteps = (riba2.numPikslid () - 1) * 2; murda; juhtum 3: riba2. ActivePattern = TWINKLE; riba 2. Intervall = 5; riba2. KokkuSteps = riba2.numPikslid (); murda; juhtum 4: riba2. ActivePattern = METEOR; riba 2. Intervall = 40; riba2. KokkuSteps = riba2.numPikslid (); murda; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// LÜLITAMINE_4 ////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////- /////////////////////////////////////////////////////////

lüliti (buttonCounter [2]) {case 0: strip3. ActivePattern = STAR; riba3.intervall = 50; riba3. KokkuSteps = riba3.numPikslid (); murda; juhtum 1: riba3. ActivePattern = RAINBOWSPARKLE; riba3.intervall = 100; riba3. KokkuSteps = riba3.numPikslid (); murda; juhtum 2: riba3. ActivePattern = SKANNER; riba3.intervall = 20; riba3. KokkuSteps = (riba3.numPikslid () - 1) * 2; murda; juhtum 3: riba3. ActivePattern = TWINKLE; riba3.intervall = 5; riba3. KokkuSteps = riba3.numPikslid (); murda; juhtum 4: riba3. ActivePattern = METEOR; riba3.intervall = 25; riba3. KokkuSteps = riba3.numPikslid (); murda; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// LÜLITAMINE_5 ////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////- /////////////////////////////////////////////////////////

lüliti (buttonCounter [3]) {case 0: strip4. ActivePattern = STAR; riba4.intervall = 50; riba4. KokkuSteps = riba4.numPikslid (); murda; juhtum 1: riba4. ActivePattern = RAINBOWSPARKLE; riba4.intervall = 100; riba4. KokkuSteps = riba4.numPikslid (); murda; juhtum 2: riba4. ActivePattern = SKANNER; riba4.intervall = 20; riba4. KokkuSteps = (riba4.numPikslid () - 1) * 2; murda; juhtum 3: riba4. ActivePattern = TWINKLE; riba4.intervall = 5; riba4. KokkuSteps = riba4.numPikslid (); murda; juhtum 4: riba4. ActivePattern = METEOR; riba4.intervall = 25; riba4. KokkuSteps = riba4.numPikslid (); murda; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// LÜLITAMINE_6 ////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////- /////////////////////////////////////////////////////////

lüliti (buttonCounter [4]) {case 0: strip5. ActivePattern = STAR; riba 5. Intervall = 50; riba5. TotalSteps = riba5.numPikslid (); murda; juhtum 1: riba5. ActivePattern = RAINBOWSPARKLE; riba 5. Intervall = 100; riba5. TotalSteps = riba5.numPikslid (); murda; juhtum 2: riba5. ActivePattern = SKANNER; riba 5. Intervall = 20; riba5. TotalSteps = (riba5.numPikslid () - 1) * 2; murda; juhtum 3: riba5. ActivePattern = TWINKLE; riba 5. Intervall = 5; riba5. TotalSteps = riba5.numPikslid (); murda; juhtum 4: riba5. ActivePattern = METEOR; riba 5. Intervall = 25; riba5. TotalSteps = riba5.numPikslid (); murda; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Lõpetamise tagasihelistamine

void strip1Complete () {rib1. Värv1 = riba1. Ratas (juhuslik (255)); riba1. Värv2 = riba1. Ratas (juhuslik (255)); riba1.indeks = 0; }

// strip2 Lõpetamise tagasihelistamine

void strip2Complete () {rib2. Värv1 = riba2. Ratas (juhuslik (255)); riba2. Värv2 = riba2. Ratas (juhuslik (255)); riba2.indeks = 0; }

// strip3 Lõpetamise tagasihelistamine

tühi riba3Complete () {riba3. Värv1 = riba3. Ratas (juhuslik (255)); riba3. Värv2 = riba3. Ratas (juhuslik (255)); riba3.indeks = 0; }

// strip4 Lõpetamise tagasihelistamine

tühi riba4Complete () {riba4. Värv1 = riba4. Ratas (juhuslik (255)); riba4. Värv2 = riba4. Ratas (juhuslik (255)); riba4.indeks = 0; }

// strip5 Lõpetamise tagasihelistamine

tühi riba5Täielik () {riba5. Värv1 = riba5. Ratas (juhuslik (255)); riba5. Värv2 = riba5. Ratas (juhuslik (255)); riba5. Indeks = 0; }

6. samm: tulemus ja filmi tegemine

Täname teid huvi eest meie projekti vastu, kuigi sellest ei piisa.