Patraukite šviesos ir šviesos modulį naudodami „Neopixel“ir ištraukimo jungiklį: 6 žingsniai (su paveikslėliais)

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:47

Šviesos modulio ypatybės

• Arduino Uno
• Aparatūra ir gaubtas pirktas iš interneto
• Neopikseliai ir maitinimo šaltinis pasiskolinti iš Informatikos ir gaminių dizaino mokyklos
• Šviesos modulis, valdomas maitinimo šaltiniu
• Visos funkcijos valdomos sąveikaujant vartotojams
• Neopikselių juostelės animacijos tipai: lietaus, dušo, kibirkštinio žaibo, pop, nereguliaraus tipo
• Ištraukimo jungiklis yra prijungtas prie „Neopixel“juostelės, o animacija pasikeičia, kai ištraukiama „Neopixel“juostelė

1 žingsnis: Prieš pradėdami

Sveiki, instruktoriai ir kūrėjai.

Pradėjome interaktyvų dizaino projektą, kalbant apie tai, kas nutiktų, jei per šviesos animaciją pajustume lietaus emocijas. Maniau, kad vartotojo jautrumas būtų maksimaliai padidintas per sąsają, kuri tiesiogiai traukia šviesą.

Kad tik nekiltų darbo

2 žingsnis: reikalingos dalys

Remiantis vienu šviesos moduliu

*** Neopikseliai ir maitinimo šaltinis buvo naudojami padedant mūsų skyriui. ***

Elektronika:

1. Arduino Uno
2. 3 spalvų viela (juoda, raudona, bet kokia spalva)
3. 3 kontaktų jungtis (nuoroda pirkti)
4. Ištraukite jungiklį 1 (nuoroda į pirkimą)
5. susitraukiantis vamzdis
6. WS2812b pridedama LED juostelė su 74 LED (neopikselio juostelė)*2
7. Maitinimo šaltinis (5V 350A) 1

*** „Arduino“, „Pull Switch“ir „NeoPixels“reikia 50 rinkinių. ***

Techninė įranga:

1. Akrilo juosta 2t (10mm*1000mm) 1
2. Akrilo plokštė 5t (60mm*60mm) 1
3. „Foemax 10t“(1200 mm*1800 mm) 1
4. Juodasis purškiklis
5. Kabelis
6. Styginė
7. Kietosios plokštės
8. Tinklelio lenta

3 žingsnis: prijungimas ir aparatūros kūrimas

Pirma, mums reikia akrilo pjovimo, kad sukurtume vieną apšvietimo modulį.

• Norėdami patirti šviesos animaciją, nubrėžkite apšvietimo modulį, kuris pritvirtinamas pritvirtinant 74 šviesos diodus neopikselio juostelės pavidalu ant 2 mm storio akrilo juostos su 1 mln. Mes pagaminome dviejų tipų apšvietimo modulius: tipišką linijinį ir spiralinį.
• Linijiniams tipams esamas neopikselių juosteles galima laikyti ir pritvirtinti, tačiau spiraliniams tipams reikia valdyti rankiniu būdu. Kiekvienas iš 74 šviesos diodų yra padalintas į dalis, pritvirtintas prie spiralinio akrilo ir sujungtas su švinu.

Pritvirtinkite „Neopixel“juostelę prie akrilo ir užfiksuokite kiekvieną juostelę, kad ji nepasklistų karščio, arba suriškite plona meškere. Linijinio tipo atveju, norint sukurti estetinę išvaizdą, sfera, kurią reikia ištraukti ant modulio galo, buvo sumontuota, o stalo teniso kamuoliuką užbaigėme juodu purškimu. Tada jie išgręžė nedidelę skylę stalo teniso kamuoliuke ir sujungė jį virve. Kita svarbiausia dalis, jungiklis ir neopikselis, yra prijungti, kaip parodyta. Tada jungiklis tvirtinamas prie lubų lentynos.

Spiralinio tipo atveju kyla pavojus, kad tiesiogiai traukiant spiralinį modulį akrilas gali sulūžti esant slėgiui, todėl traukimo sekcija (įvestis) ir modulis (išėjimas) buvo atskirti. Siekiant maksimaliai padidinti šviesos kritimą, moduliai buvo sumontuoti vertikaliai ant lubų, linijiniai moduliai pritvirtinti prie oro, spiralės pritvirtintos tiesiai prie lubų. Mes prijungėme stalo teniso kamuoliuką ir jungiklį prie meškerės, kad jį būtų galima valdyti.

Norint pritvirtinti jungiklį prie lentynos, reikia pjauti akrilą, kaip parodyta aukščiau esančiame brėžinyje. 6 cm kvadrato formos jungiklis yra maždaug 5 mm storio, jungiklis yra centre, o laido raištis įkištas per skylutes abiejose pusėse, kad jungiklis būtų tvirtai pritvirtintas. Apskrito formos skylė centro apačioje atskleidžia jungiklio traukimą, po kuriuo ištraukiamas trijų laidų kabelis ir prijungiamas prie modulio kabelio gnybto. Panašiai, per skylę keturiuose kampuose, lentyna ir akrilas tvirtinami kabeliais. Kaip aprašyta aukščiau, linijinis modulis yra tiesiogiai prijungtas prie traukos, tačiau spiralinis modulis jungia kaištį ir jungiklį atskirai.

4 žingsnis: sukurkite naudodami 50 šviesos modulių

Išdėstę 50 modulių, sukūrėme naudotojo patirtį, kad gautume turtingesnę šviesą

Turėjome 1 800 mm pločio ir 1 200 mm ilgio lentyną, ir mes prijungėme kiekvieną jungiklį ir modulį, kad galėtumėte patirti lietaus ir lietaus aplinką, kurią planavome iš pradžių, ir kiekvienas modulis buvo atskiras, kad būtų galima atlikti kelias užduotis.

Atsižvelgiant į konstrukcijos brėžinį, į „foemax“buvo išgręžta apvali skylė, skirta paslėpti įrenginį ir įsitikinti, kad nematoma prijungta LED modulio sritis. Kadangi atstumas nuo akrilo plokštės iki LED modulio jungties, kurioje yra jungiklis, yra apie 1 cm, buvo naudojamas 1 cm storio foemax.

Metalinis kvadratinis rėmas buvo naudojamas montuoti kartu su varžtais ir trosais, išlaikant bendrą svorį ir pusiausvyrą. Jei atvirų jungčių ilgis yra ilgesnis nei gamintojo bandymas, storesnė plokštė yra neefektyvi ir rekomenduojamos kitos konstrukcijos.

Siekiant palengvinti naudotojo patirtį akių lygyje, baigtas diegimas dedamas ant maždaug 2 m aukščio atramos, tačiau reikia atkreipti dėmesį į tai, kad įmontuoti įterptąjį LED modulį su jungikliu yra labai sudėtinga, todėl visos jungtys turi būti pašalintos. Mes užlipome kopėčiomis ir prijungėme modulį prie montavimo, pritvirtinto prie atramos.

Svarbiausia viso šio proceso dalis yra užtikrinti, kad darbas būtų atliktas saugiai ir visiškai, kad patirtis būtų įmanoma saugioje aplinkoje

Iš viso buvo panaudota 10 arduino ir 50 LED modulių, o prie vieno arduino buvo prijungti penki LED moduliai, siekiant efektyvesnio ir sklandesnio kelių užduočių atlikimo. Išsamesnės informacijos rasite pridedamame projekte. „Neopixel“daugiafunkcinis kodavimas naudojant visą jungiklį pagal projektavimo schemą bus išsamiai aptartas kitame žingsnyje.

5 žingsnis: „Arduino“kodavimas ir laidai

Laidai

• 50 modulių buvo prijungta pagal 4 žingsnio išdėstymą.
• Kiekvienas modulis buvo padalintas į 10 50 modulių rinkinių, kad būtų galima atlikti kelias užduotis ir užtikrinti aiškų ryšį.
• Kaip parodyta aukščiau esančiame 1 rinkinio paveikslėlyje, penki moduliai buvo prijungti prie vieno arduino, o 5 V neopikselio kaiščiai buvo sujungti vienu metu, kad būtų galima prijungti maitinimo šaltinį.
• Neopikselių GND ir jungikliai taip pat buvo susieti ir, kad būtų lengviau suvokti, jungikliai buvo prijungti prie 2, 3, 4, 5, 6 kaiščių, o neopikseliai buvo prijungti prie 9, 10, 11, 12, 13 kaiščių.
• Jungikliai ir neopikseliai buvo prijungti atitinkamai 2-9, 3-10, 4-11, 5-12, 6-13 būdais.
• Reikėtų pažymėti, kad kadangi linijų jungtys yra sudėtingos ir dėl trumpojo jungimo kyla gaisro pavojus, susitraukiantis vamzdis buvo šildomas, kad silpnos dalys nesulūžtų.

„Neopixel“daugiafunkcinis kodavimas su ištraukimo jungikliu

5 šviesos animacija (lietaus tipas, dušo tipas, kibirkštinio žaibo tipas, pop tipo, netaisyklingo tipo)

#įtraukti

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

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

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

klasės „NeoPatterns“: viešas „Adafruit_NeoPixel“{ /* 패턴 을 추가 하고 업데이트 하기 위한 함수* / public: pattern ActivePattern; /*클레스 함수 에 패턴 의 방향 을 입력*/ kryptis Kryptis;

/*변수 Intervalas 을 추가*/ nepasirašytas ilgas intervalas; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 Spalva1, spalva2 를 추가*/ uint32_t spalva1, spalva2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Indeksas 를 추가*/ uint16_t Indeksas;

/*패턴 을 완료 했을 시 다시 불러오는 함수*/ void (*OnComplete) (); /*네오 패턴 에서 네오 의 갯수, 핀 번호, 타입, 콜백 을 함수 함수*/ „NeoPatterns“(uint16_t pikseliai, uint8_t kaištis, uint8_t tipas, void (*atgalinis skambutis) ()): „Adafruit_NeoPixel“(pikseliai, smeigtukas, tipas) { OnComplete = atgalinis skambutis; }

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

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

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

atvejis THEATER_CHASE: TheaterChaseUpdate (); /*atvejis THEATER_CHASE 에서 나와라*/ pertrauka;

/*dėklas COLOR_WIPE 에서는 ColorWipeUpdate 를 실행 하라*/

atvejis COLOR_WIPE: ColorWipeUpdate (); /*dėklas COLOR_WIPE 에서 나와라*/ break; /*korpusas SKENERIUS 에서는 ScannerUpdate 를 실행 하라*/ korpusas SKENERIUS: ScannerUpdate (); /*dėklas SKENERIS 에서 나와라*/ pertrauka;

/*dėklas FADE 에서는 FadeUpdate 를 실행 하라*/

atvejis FADE: FadeUpdate (); /*dėklas FADE 에서 나와라*/ break;

/*dėklas TWINKLE 에서는 TwinkleUpdate 를 실행 하라*/

atvejis TWINKLE: TwinkleUpdate (); /*atvejis TWINKLE 에서 나와라*/ pertrauka;

/*dėklas STAR 에서는 StarUpdate 를 실행 하라*/

korpusas STAR: StarUpdate (); /*dėklas STAR 에서 나와라*/ break;

/*dėklas RAINBOWSPARKLE 에서는 RainbowsparkleAtnaujinti 를 실행 하라*/

atvejis RAINBOWSPARKLE: RainbowsparkleUpdate (); /*dėklas RAINBOWSPARKLE 에서 나와라*/ pertrauka; /*atvejis METEOR 에서는 MeteorUpdate 를 실행 하라*/ case METEOR: MeteorUpdate (); /*dėklas METEOR 에서 나와라*/ break;

/*dėklas LIGHT 에서는 LightUpdate 를 실행 하라*/

korpusas LIGHT: LightUpdate (); /*dėklas LIGHT 에서 나와라*/ pertrauka;

/*dėklas BLOSSOM 에서는 BlossomUpdate 를 실행 하라*/

dėklas BLOSSOM: BlossomUpdate (); /*dėklas BLOSSOM 에서 나와라*/ break; }}}

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

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

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

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

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

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

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

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

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

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

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

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

void TheaterChase (uint32_t color1, uint32_t color2, uint8_t intervalas, kryptis dir = FORWARD) { /*실행 되는 패턴 은 RTHEATER_CHASE* / ActivePattern = THEATER_CHASE; /*시간 은 void TheaterChase () 안에 입력 되는 intervalas 과 같음*/ Intervalas = intervalas; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1, 2 를 설정*/ Spalva1 = spalva1; Spalva2 = spalva2; /*인덱스 는 0 으로 설정 함*/ Indeksas = 0; /*방향 은 void TheaterChase () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = rež; }

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

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

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

void ColorWipe (uint32_t spalva, uint8_t intervalas, kryptis dir = FORWARD) { /*실행 되는 패턴 은 COLOR_WIPE* / ActivePattern = COLOR_WIPE; /*시간 은 void ColorWipe () 안에 입력 되는 intervalas 과 같음*/ Intervalas = intervalas; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Spalva1 = spalva; /*인덱스 는 0 으로 설정 함*/ Indeksas = 0; /*방향 은 void ColorWipe () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

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

void ColorWipeUpdate () { /*indeksas 를 컬러 1 로 변환 시켜라* / setPixelColor (indeksas, spalva1); / *애니메이션 을 보여주는 함수 */ rodyti (); Padidėjimas (); }

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

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

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

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

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

void Fade (uint32_t color1, uint32_t color2, uint16_t žingsniai, uint8_t intervalas, kryptis dir = FORWARD) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 void Fade () 안에 입력 되는 intervalas 과 같음*/ Intervalas = intervalas; /*구동 갯수 는 스텝 값임*/ TotalSteps = žingsniai; /*컬러 1, 2 를 설정*/ Spalva1 = spalva1; Spalva2 = spalva2; /*인덱스 는 0 으로 설정 함*/ Indeksas = 0; /*방향 은 void Fade () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 raudona 값 은 다음 과 같음* / uint8_t red = ((raudona (spalva1)*(TotalSteps - indeksas)) + (raudona (spalva2)*indeksas)) / „TotalSteps“; / * 변수 žalia 값 은 다음 과 같음 * / uint8_t žalia = ((žalia (spalva1) * („TotalSteps - Index“) + (žalia (spalva2) * indeksas)) / „TotalSteps“; / * 변수 mėlyna 값 은 다음 과 같음 * / uint8_t blue = ((mėlyna (spalva1) * (TotalSteps - indeksas)) + (mėlyna (spalva2) * indeksas)) / TotalSteps; /*위 의 raudona, žalia, mėlyna 값 으로 컬러 를 셋팅 함*/ ColorSet (spalva (raudona, žalia, mėlyna)); / *애니메이션 을 보여주는 함수 */ rodyti (); Padidėjimas (); }

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

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

/*Mirksėti 의 컬러 1 와 시간 을 입력*/

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

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

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

/*Žvaigždė 의 컬러 1 값 을 입력*/

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

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

void StarUpdate () { /*인덱스 와 컬러 를 셋팅* / setPixelColor (indeksas, spalva1); Rodyti(); /*변수 i 가 0 이고 구동 갯수 작 으면 i 를 감소 시킴 = 한칸 씩 이동 하는*// (int i = 0; i <numPixels (); i--) {setPixelColor (i, spalva (0, 0, 0)); } / *애니메이션 을 보여주는 함수 * / padidėjimas (); }

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

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

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

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

/*Šviesa 의 시간 과 방향 을 입력*/

void Light (uint32_t color1) { /*실행 되는 패턴 은 LIGHT* / ActivePattern = LIGHT; /*시간 설정*/ Intervalas = intervalas; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Spalva1 = spalva1; Indeksas = 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 (); Padidėjimas (); }

/*Žydi 의 시간 과 방향 을 입력*/

void Blossom (uint32_t color1) { /*실행 되는 패턴 은 BLOSSOM* / ActivePattern = BLOSSOM; /*시간 설정*/ Intervalas = intervalas; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Spalva1 = spalva1; Indeksas = 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 (); Padidėjimas (); }

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

/ *네오 픽셀 의 켜지 는 위치 색 을 지정 해주는 함수 */ void setAll (baitas raudonas, baitas žalias, baitas mėlynas) {skirtas (int i = 0; i <numPixels (); i ++) {setPixelColor (i, raudona, žalia, mėlyna); } Rodyti(); }

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

uint32_t DimColor (uint32_t spalva) {// Perkelkite R, G ir B komponentus vieną bitą į dešinę uint32_t dimColor = Spalva (raudona (spalva) >> 1, žalia (spalva) >> 1, mėlyna (spalva) >> 1); return dimColor; }

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

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

/*레드 값 을 불러 옴*/

uint8_t Raudona (uint32_t spalva) {return (spalva >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Žalia (uint32_t spalva) {return (spalva >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t Mėlyna (uint32_t spalva) {return color & 0xFF; }

/*Vaivorykštė 컬러 를 불러 옴*/

uint32_t Ratas (baitas WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return Color (255 - WheelPos * 3, 0, WheelPos * 3); } else if (WheelPos <170) {WheelPos -= 85; grąžinti spalvą (0, WheelPos * 3, 255 - WheelPos * 3); } else {WheelPos -= 170; grąžinti spalvą („WheelPos * 3“, 255 - „WheelPos“* 3, 0); }}};

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

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

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

#define NUMPIXELS 74 /*사용 하는 버튼 의 갯수 /* / #define B_NUM 5 /*Importuoti juostelę1 ~ 5 까지, 갯수 는 74 개 스트립 연결 핀 은 juostelė1 은 8 ~ juostelė5 까지 12* / „NeoPatterns“juostelė1 (74, 8, NEO_GRB + NEO_KHZ800, & strip1Complete); „NeoPatterns strip2“(74, 9, NEO_GRB + NEO_KHZ800 ir & strip2Complete); „NeoPatterns strip3“(74, 10, NEO_GRB + NEO_KHZ800 ir & strip3Complete); „NeoPatterns strip4“(74, 11, NEO_GRB + NEO_KHZ800 ir & strip4Complete); „NeoPatterns strip5“(74, 12, NEO_GRB + NEO_KHZ800 ir „strip5Complete“); /*배열 을 사용한 연결 버튼 핀 설정*/ const int buttonPin [B_NUM] = {2, 3, 4, 5, 6}; /*배열 을 사용 하여 버튼 상태 를 지정 해줌*/ int buttonState [B_NUM]; /*2 번핀 부터 6 번핀 까지 상태 는 순서 OW 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 mygtukasCounterMax = 5; /*모든 버튼 핀 을 읽 일수 있도록 변수 추가*/ int skaitymas [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 delay50 과 같음*/ unsigned long debounceDelay = 50;

void setup () {

/*복잡 하게 저항 연결 이 없도록 인풋 풀업 방식 의 버튼 설정: GND - 5V (prisijungimas prie PIN kodo)*/ skirtas (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Serial.begin (9600); /*스트립 1 ~ 5 를 셋팅*/ strip1.begin (); juostelė2.pradis (); strip3.begin (); strip4.begin (); strip5.begin ();

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

}

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

int skaitiklis = 5; void loop () { /*버튼 수 가 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (skaitymas ! = buttonState ) {buttonState = skaitymas ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 Maks. 값 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = skaitymas ; } /*모든 스트립 을 업데이트 함.* / Strip1. Update (); juostelė2. Atnaujinti (); juostelė3. Atnaujinti (); juostelė4. Atnaujinti (); juostelė5. Atnaujinti ();

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

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

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

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

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

jungiklis (buttonCounter [1]) {atvejis 0: strip2. ActivePattern = STAR; juostelė 2. Intervalas = 50; strip2. TotalSteps = strip2.numPixels (); pertrauka; 1 atvejis: juostelė2. ActivePattern = RAINBOWSPARKLE; juostelė 2. Intervalas = 100; strip2. TotalSteps = strip2.numPixels (); pertrauka; 2 atvejis: juostelė2. ActivePattern = SCANNER; juostelė 2. Intervalas = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; pertrauka; 3 atvejis: juostelė2. ActivePattern = TWINKLE; juostelė 2. Intervalas = 5; strip2. TotalSteps = strip2.numPixels (); pertrauka; 4 atvejis: juostelė2. ActivePattern = METEOR; juostelė 2. Intervalas = 40; strip2. TotalSteps = strip2.numPixels (); pertrauka; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

jungiklis (buttonCounter [2]) {case 0: strip3. ActivePattern = STAR; juostelė3. Intervalas = 50; strip3. TotalSteps = strip3.numPixels (); pertrauka; 1 atvejis: juostelė3. ActivePattern = RAINBOWSPARKLE; juostelė3. Intervalas = 100; strip3. TotalSteps = strip3.numPixels (); pertrauka; 2 atvejis: juostelė3. ActivePattern = SCANNER; juostelė 3. Intervalas = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; pertrauka; 3 atvejis: juostelė3. ActivePattern = TWINKLE; juostelė3. Intervalas = 5; strip3. TotalSteps = strip3.numPixels (); pertrauka; 4 atvejis: juostelė3. ActivePattern = METEOR; juostelė3. Intervalas = 25; strip3. TotalSteps = strip3.numPixels (); pertrauka; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

jungiklis (buttonCounter [3]) {case 0: strip4. ActivePattern = STAR; juostelė 4. Intervalas = 50; strip4. TotalSteps = strip4.numPixels (); pertrauka; 1 atvejis: juostelė4. ActivePattern = RAINBOWSPARKLE; juostelė 4. Intervalas = 100; strip4. TotalSteps = strip4.numPixels (); pertrauka; 2 atvejis: juostelė4. ActivePattern = SCANNER; juostelė 4. Intervalas = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; pertrauka; 3 atvejis: juostelė4. ActivePattern = TWINKLE; juostelė 4. Intervalas = 5; strip4. TotalSteps = strip4.numPixels (); pertrauka; 4 atvejis: juostelė4. ActivePattern = METEOR; juostelė 4. Intervalas = 25; strip4. TotalSteps = strip4.numPixels (); pertrauka; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

jungiklis (buttonCounter [4]) {case 0: strip5. ActivePattern = STAR; juostelė 5. Intervalas = 50; strip5. TotalSteps = strip5.numPixels (); pertrauka; 1 atvejis: juostelė5. ActivePattern = RAINBOWSPARKLE; juostelė 5. Intervalas = 100; strip5. TotalSteps = strip5.numPixels (); pertrauka; 2 atvejis: juostelė5. ActivePattern = SCANNER; juostelė 5. Intervalas = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; pertrauka; 3 atvejis: juostelė5. ActivePattern = TWINKLE; juostelė 5. Intervalas = 5; strip5. TotalSteps = strip5.numPixels (); pertrauka; 4 atvejis: juostelė5. ActivePattern = METEOR; juostelė 5. Intervalas = 25; strip5. TotalSteps = strip5.numPixels (); pertrauka; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Baigiamasis atšaukimas

void strip1Complete () {strip1. Color1 = strip1. Wheel (atsitiktinis (255)); juostelė1. Spalva2 = juostelė1. Ratas (atsitiktinis (255)); juostelė1. Indeksas = 0; }

// strip2 Baigimo atgalinis skambutis

void strip2Complete () {strip2. Color1 = strip2. Wheel (atsitiktinis (255)); juostelė2. Spalva2 = juostelė2. Ratas (atsitiktinis (255)); juostelė 2. Indeksas = 0; }

// strip3 Baigimo atgalinis skambutis

void strip3Complete () {strip3. Color1 = strip3. Wheel (atsitiktinis (255)); juostelė3. Spalva2 = juostelė3. Ratas (atsitiktinis (255)); juostelė3.indeksas = 0; }

// strip4 užbaigimo atgalinis skambutis

void strip4Complete () {strip4. Color1 = strip4. Wheel (atsitiktinis (255)); juostelė4. Spalva2 = juostelė4. Ratas (atsitiktinis (255)); juostelė4. Indeksas = 0; }

// strip5 Baigiamasis atšaukimas

void strip5Complete () {strip5. Color1 = strip5. Wheel (random (255)); juostelė5. Spalva2 = juostelė5. Ratas (atsitiktinis (255)); juostelė5. Indeksas = 0; }

6 žingsnis: rezultatas ir filmo kūrimas

Dėkojame, kad domitės mūsų projektu, nors to nepakanka.