Vytiahnite modul svetla - svetlo pomocou Neopixelu a vypínača: 6 krokov (s obrázkami)

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 11:59

Vlastnosti modulu Light

• Arduino Uno
• Hardvér a kryt kúpené na internete
• Neopixel a napájací zdroj zapožičané zo Školy informatiky a produktového dizajnu
• Svetelný modul ovládaný napájaním
• Všetky funkcie sa ovládajú prostredníctvom interakcie používateľov
• Typy animácií Neopixelového pásu: Dážď, Typ sprchy, Typ iskrového blesku, Typ Pop, Nepravidelný typ
• Vyťahovací spínač je pripojený k pásu Neopixel a animácia sa zmení po vytiahnutí pásu Neopixel

Krok 1: Skôr než začneme

Dobrý deň, návody a tvorcovia.

Začali sme projekt interaktívneho dizajnu s cieľom zistiť, čo by sa stalo, keby sme mohli cítiť emóciu dažďa prostredníctvom animácie svetla. Myslel som si, že citlivosť používateľa bude maximalizovaná prostredníctvom rozhrania, ktoré priamo priťahuje svetlo.

Aby som sa mohol pustiť do práce

Krok 2: Potrebné diely

Na základe jedného svetelného modulu

*** Neopixely a napájanie boli použité s podporou nášho oddelenia. ***

Elektronika:

1. Arduino Uno
2. 3 -farebný drôt (čierny, červený, ľubovoľná farba)
3. 3 -pinový konektor (odkaz na nákup)
4. Potiahnite spínač 1 (odkaz na nákup)
5. zmršťovacia trubica
6. Riaditeľný LED pás WS2812b so 74 LED (neopixelový pás)*2
7. Napájanie (5V 350A) 1

*** Pre Arduino, Pull Switch a NeoPixels je potrebných 50 sád. ***

Hardvér:

1. Akrylová tyč 2t (10mm*1000mm) 1
2. Akrylová doska 5 t (60 mm*60 mm) 1
3. Foemax 10t (1200 mm*1800 mm) 1
4. Čierny sprej
5. Káblové zväzky
6. Reťazec
7. Sololit
8. Mriežková doska

Krok 3: Pripojiteľnosť a budovanie hardvéru

Najprv potrebujeme akrylový rez na výrobu jedného osvetľovacieho modulu.

• Ako spôsob zážitku z animácie svetla navrhnite svetelný modul, ktorý je upevnený pripevnením 74 LED diód vo forme neopixelového pásu na 2 mm hrubú akrylovú lištu s plochou 1 M. Vyrobili sme dva typy svetelných modulov: typické lineárne a špirálové.
• Pri lineárnych typoch je možné existujúce neopixelové pásy držať a zaistiť, ale špirálové typy vyžadujú ručnú obsluhu. Každá zo 74 LED diód je rozdelená na kúsky, pripevnené k špirálovému akrylátu a spojené dohromady olovom.

Pripevnite pásik Neopixel k akrylu a zaistite každý prúžok, aby sa zabránilo šíreniu teplom, alebo previažte tenkou šnúrkou. V prípade lineárneho typu bola guľa, ktorú bolo potrebné vytiahnuť na koniec modulu, nainštalovaná tak, aby navrhla estetický vzhľad, a pingpongovú loptičku sme dokončili čiernym sprejom. Potom do pingpongovej loptičky vyvŕtali malú dieru a spojili ju lanom. Ďalšia najdôležitejšia časť, spínač a neopixel, je zapojená podľa obrázku. Vypínač je potom zaistený k stropnej polici.

V prípade špirálového typu existuje riziko, že priame ťahanie špirálového modulu by mohlo spôsobiť rozbitie akrylátu pod tlakom, takže ťažná časť (vstup) a modul (výstup) boli oddelené. Aby sa maximalizovalo padanie svetla, moduly boli inštalované vertikálne na strop, lineárne moduly boli pripevnené k vzduchu, špirály boli pripevnené priamo k stropu. A pripojili sme pingpongovú loptičku a vypínač k vlascu, aby sa dalo ovládať.

Na zaistenie spínača k polici je potrebné akrylové rezanie, ako je znázornené na obrázku vyššie. Prepínač 6 cm v tvare štvorca je približne 5 mm hrubý, so spínačom v strede a káblovou sponou zasunutou cez otvory na oboch stranách, aby bol spínač pevne zaistený. Kruhový otvor v spodnej časti stredu odkrýva potiahnutie spínača, pod ktorým je vytiahnutý trojvodičový kábel a pripojený k káblovej svorke modulu. A podobne, cez dieru v štyroch rohoch sú polica a akryl zaistené sťahovacími páskami. Ako je popísané vyššie, lineárny modul je pripojený priamo k ťahu, ale špirálový modul spája kolík a spínač oddelene.

Krok 4: Vytvorte pomocou 50 svetelných modulov

Navrhli sme používateľské prostredie pre bohatšie osvetlenie nasadením celkom 50 modulov

Mali sme policu, ktorá bola 1 800 mm široká a 1 200 mm dlhá, a prepojili sme každý vypínač a modul, aby ste mohli zažiť prostredie dažďa a dažďa, ktoré sme pôvodne plánovali, a každý modul sme nechali stáť samostatne, aby sme mohli vykonávať viacero úloh naraz..

V závislosti od výkresovej schémy bol do foemax vyvŕtaný okrúhly otvor, aby sa skryla inštalácia a aby sa zaistilo, že pripojená oblasť modulu LED nie je viditeľná. Pretože vzdialenosť od akrylovej dosky k pripojeniu modulu LED, kde je pripojený spínač, je asi 1 cm, bol použitý foemax hrubý 1 cm.

Kovový štvorcový rám slúžil na držanie inštalácie spolu so skrutkami a káblovými zväzkami pri zachovaní celkovej hmotnosti a rovnováhy. Ak je dĺžka odhalených spojov väčšia, ako sa výrobca pokúša, hrubšia doska je neúčinná a odporúčajú sa iné štruktúry.

Aby sa uľahčila používateľská skúsenosť na úrovni očí, je dokončená inštalácia umiestnená na podperu vysokú približne 2 m, ale opatrnosťou je, že je veľmi ťažké inštalovať vstavaný modul LED pomocou prepínača, preto by mali byť odstránené všetky pripojenia. Vyliezli sme po rebríku a spojili modul s inštaláciou upevnenou na podpere.

Najdôležitejšou súčasťou celého tohto procesu je zaistiť, aby sa práca vykonávala bezpečne a plne zabezpečene, aby sa zaistilo, že skúsenosti budú možné v bezpečnom prostredí

Použitých bolo celkom 10 arduino a 50 LED modulov a na jeden arduino bolo zapojených päť LED modulov, aby sa dosiahol efektívnejší a bezproblémový multitasking. Podrobnosti nájdete v priloženom pláne. Viacúlohové kódovanie Neopixel pomocou úplného prepínača podľa schémy návrhu bude podrobne prediskutované v nasledujúcom kroku.

Krok 5: Kódovanie a zapojenie Arduino

Elektrické vedenie

• Podľa usporiadania v kroku 4 bolo pripojených 50 modulov.
• Každý modul bol rozdelený do 10 sád 50 modulov, aby bolo možné vykonávať viac úloh naraz a poskytovať jasné spojenie.
• Ako je znázornené na obrázku sady 1 vyššie, päť modulov bolo pripojených k jednému arduinu a 5v kolíky neopixelu boli naraz zviazané, aby sa pripojilo napájanie.
• GND neopixelov a spínačov boli tiež zviazané dohromady a kvôli ľahšiemu vnímaniu boli spínače zapojené do pinov 2, 3, 4, 5, 6 a neopixely boli zapojené do pinov 9, 10, 11, 12, 13.
• Prepínače a neopixely boli spojené 2-9, 3-10, 4-11, 5-12, 6-13 príslušným spôsobom.
• Je potrebné poznamenať, že keďže spojenia vedení sú zložité a kvôli skratom hrozí riziko požiaru, zmršťovacia trubica bola zahriata, aby sa zabezpečilo, že sa slabé časti nerozbijú.

Neopixelové viacúlohové kódovanie s vyťahovacím prepínačom

5 svetelných animácií (typ dažďa, typ sprchy, typ iskrivého blesku, typ pop, nepravidelný typ)

#zahrnúť

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

enumový vzor {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 픽셀 을 방향 을 설정 함*/ smer enum {VPRED, VZAD};

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

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

/*변수 Interval 을 추가*/ bez znamienka dlhý interval; /*변수 lastUpdate 를 추가*/ nepodpísané dlhé lastUpdate; /*변수 Farba1, Farba2 를 추가*/ uint32_t Farba1, Farba2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Register 를 추가*/ uint16_t Register;

/*패턴 을 완료 했을 시 다시 불러오는 함수*/ void (*OnComplete) (); /*네오 패턴 에서 네오 픽샐 의 갯수, 핀 번호, 타입, 콜백 을 불러오는 함수*/ NeoPatterns (uint16_t pixelov, uint8_t pin, uint8_t typ, void (*spätné volanie) ()): Adafruit_NeoPixel (pixely, pin, typ) { OnComplete = spätné volanie; }

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

zrušiť aktualizáciu () { /*패턴 의 시간 설정. 멀티 태스킹 을 구현 하는 구문*/ if ((milis () - lastUpdate)> Interval) {lastUpdate = millis (); /*ActivePattern 의 스위치 구문*/ switch (ActivePattern) {/*case RAINBOW_CYCLE 에서는 RainbowCycleUpdate 를 실행 하라*/ case RAINBOW_CYCLE: RainbowCycleUpdate (); /*prípad RAINBOW_CYCLE 에서 나와라*/ break;

/*prípad THEATER_CHASE 에서는 TheaterChaseUpdate 를 실행 하라*/

prípad THEATER_CHASE: TheaterChaseUpdate (); /*prípad THEATRE_CHASE 에서 나와라*/ prestávka;

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

prípad COLOR_WIPE: ColorWipeUpdate (); /*puzdro COLOR_WIPE 에서 나와라*/ prestávka; /*case SCANNER 에서는 ScannerUpdate 를 실행 하라*/ case SCANNER: ScannerUpdate (); /*puzdro SKENER 에서 나와라*/ prestávka;

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

prípad FADE: FadeUpdate (); /*case FADE 에서 나와라*/ break;

/*prípad TWINKLE 에서는 TwinkleUpdate 를 실행 하라*/

prípad TWINKLE: TwinkleUpdate (); /*puzdro TWINKLE 에서 나와라*/ prestávka;

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

case STAR: StarUpdate (); /*prípad STAR 에서 나와라*/ prestávka;

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

puzdro RAINBOWSPARKLE: RainbowsparkleUpdate (); /*puzdro RAINBOWSPARKLE 에서 나와라*/ prestávka; /*prípad METEOR 에서는 MeteorUpdate 를 실행 하라*/ prípad METEOR: MeteorUpdate (); /*prípad METEOR 에서 나와라*/ prestávka;

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

puzdro LIGHT: LightUpdate (); /*puzdro SVETLO 에서 나와라*/ prestávka;

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

puzdro BLOSSOM: BlossomUpdate (); /*puzdro BLOSSOM 에서 나와라*/ prestávka; }}}

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

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

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

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

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

neplatné Spätný chod () { /*애니메이션 함수 에 Spätný chod 를 썼을 시, 만약 방향 이 정방향 이면* / if (Smer == VPRED); Index = Celkový počet krokov - 1; } /*그 외의 방향 이 정방향 이면 인덱스 를 0 으로 설정 해라* / else {Smer = Vpred; Index = 0; }}

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

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

neplatný RainbowCycle (uint8_t interval, smer dir = Vpred) { /*실행 되는 패턴 은 RainbowCycle 임* / ActivePattern = RAINBOW_CYCLE; /*시간 은 neplatný RainbowCycle () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 255 임*/ TotalSteps = 255; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 neplatné RainbowCycle () 안에 입력 되는 dir = Vpred 과 같음*/ Smer = dir; }

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

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

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

neplatné TheaterChase (uint32_t farba1, uint32_t farba2, uint8_t interval, smer dir = VPRED) { /*실행 되는 패턴 은 RTHEATER_CHASE* / ActivePattern = THEATER_CHASE; /*시간 은 neplatné TheaterChase () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1, 2 를 설정*/ Farba1 = farba1; Farba2 = farba2; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 neplatné TheaterChase () 안에 입력 되는 réžia = VPRED 과 같음*/ Smer = réžia; }

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

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

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

neplatné ColorWipe (uint32_t farba, uint8_t interval, smer dir = Vpred) { /*실행 되는 패턴 은 COLOR_WIPE* / ActivePattern = COLOR_WIPE; /*시간 은 neplatný ColorWipe () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Farba1 = farba; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 neplatné ColorWipe () 안에 입력 되는 dir = VPRED 과 같음*/ Smer = dir; }

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

neplatné ColorWipeUpdate () { /*index 를 컬러 1 로 변환 시켜라* / setPixelColor (index, farba1); / *애니메이션 을 보여주는 함수 */ show (); Prírastok (); }

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

neplatný skener (uint32_t farba1, uint8_t interval) { /*실행 되는 패턴 은 SKENER* / ActivePattern = SKENER; /*시간 은 neplatný skener () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*구동 갯수 는 총 갯수 에서 1 을 빼고 2 를 곱 해라*/ TotalSteps = (numPixels () - 1)*2; /*컬러 1 을 설정*/ Farba1 = farba1; /*인덱스 는 0 으로 설정 함*/ Index = 0; }

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

void ScannerUpdate () { /*변수 i 는 영 이고 총 갯수 보다 작을 경우 i 를 증가 시켜라* /for (int i = 0; i <numPixels (); 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 (); Prírastok (); }

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

void Fade (uint32_t color1, uint32_t color2, uint16_t kroky, uint8_t interval, smer dir = FORWARD) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 neplatné Fade () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*구동 갯수 는 스텝 값임*/ TotalSteps = kroky; /*컬러 1, 2 를 설정*/ Farba1 = farba1; Farba2 = farba2; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 neplatné Fade () 안에 입력 되는 dir = DOPREDU 과 같음*/ Smer = dir; } /*FadeUpdate 를 업데이트 했을 경우* / neplatné FadeUpdate () { /*변수 červená 값 은 다음 과 같음* / uint8_t červená = ((červená (farba1)*(celkové kroky - index)) + (červená (farba2)*index)) / TotalSteps; / * 변수 zelená 값 은 다음 과 같음 * / uint8_t zelená = ((Zelená (Farba1) * (Celkový počet krokov - index)) + (Zelená (Farba2) * Register)) / Celkový počet krokov; / * 변수 modrá 값 은 다음 과 같음 * / uint8_t modrá = ((Modrá (Farba1) * (Celkový počet krokov - index)) + (Modrá (Farba2) * Register)) / Celkový počet krokov; /*위 의 červená, zelená, modrá 값 으로 컬러 를 셋팅 함*/ ColorSet (farba (červená, zelená, modrá)); / *애니메이션 을 보여주는 함수 */ show (); Prírastok (); }

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

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

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

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

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

neplatné TwinkleUpdate () { /*모든 네오 픽셀 의 컬러 를 0 으로 셋팅* / setAll (0, 0, 0); /*변수 Pixel 은 náhodný 74*/ int Pixel = náhodný (74); /*náhodný 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 (); Prírastok (); }

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

neplatná hviezda (uint32_t farba1) { /*실행 되는 패턴 은 STAR* / ActivePattern = STAR; /*시간 은 neplatné Hviezda () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Farba1 = farba1; Index = 0; }

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

neplatné StarUpdate () { /*인덱스 와 컬러 를 셋팅* / setPixelColor (Index, Color1); šou(); /*변수 i 가 0 이고 구동 갯수 보다 작 으면 i 를 감소 시킴 = 한칸 씩 이동 하는 애니메이션 애니메이션*/ for (int i = 0; i <numPixels (); i--) {setPixelColor (i, Color (0, 0, 0)); } / *애니메이션 을 보여주는 함수 * / Prírastok (); }

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

neplatné Rainbowsparkle (uint8_t interval, smer dir = Vpred) { /*실행 되는 패턴 은 RAINBOWSPARKLE* / ActivePattern = RAINBOWSPARKLE; /*시간 은 neplatné Rainbowsparkle () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Index = 0; /*방향 은 neplatný Rainbowsparkle () 안에 입력 되는 smer 과 같음*/ Smer = smer; }

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

neplatné RainbowsparkleUpdate () { /*변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데* /for (int i = 0; i <numPixels (); i ++) { /*변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데*/ if ((i + index) % 2 == 0) {uint32_t c = náhodný (255); setPixelColor (i, c); } else {setPixelColor (i, náhodný (255)); }} / *애니메이션 을 보여주는 함수 * / show (); Prírastok (); } /*Meteor 의 시간 과 방향 을 입력* / neplatný meteor (uint32_t color1) { /*실행 되는 패턴 은 METEOR* / ActivePattern = METEOR; /*시간 설정*/ Interval = interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Farba1 = farba1; Index = 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 (); Prírastok (); }

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

prázdne svetlo (uint32_t farba1) { /*실행 되는 패턴 은 SVETLO* / ActivePattern = SVETLO; /*시간 설정*/ Interval = interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Farba1 = farba1; Index = 0; }

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

neplatné 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 (); Prírastok (); }

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

void Blossom (uint32_t color1) { /*실행 되는 패턴 은 BLOSSOM* / ActivePattern = BLOSSOM; /*시간 설정*/ Interval = interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Farba1 = farba1; Index = 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 (); Prírastok (); }

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

/ *네오 픽셀 의 켜지 는 위치 와 색 을 지정 해주는 함수 */ void setAll (byte červená, bajt zelená, byte modrá) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, červená, zelená, modrá); } šou(); }

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

uint32_t DimColor (farba uint32_t) {// Posun komponent R, G a B o jeden bit doprava uint32_t dimColor = Farba (červená (farba) >> 1, zelená (farba) >> 1, modrá (farba) >> 1); vrátiť dimColor; }

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

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

/*레드 값 을 불러 옴*/

uint8_t Červená (farba uint32_t) {return (farba >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Zelená (farba uint32_t) {návrat (farba >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t modrá (farba uint32_t) {vrátiť farbu & 0xFF; }

/*Dúha 컬러 를 불러 옴*/

uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return Color (255 - WheelPos * 3, 0, WheelPos * 3); } else if (WheelPos <170) {WheelPos -= 85; vrátiť farbu (0, WheelPos * 3, 255 - WheelPos * 3); } else {WheelPos -= 170; vrátiť farbu (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

/*pásik 을 불러 오기 위한 함수 /*사용 하는 스트립 별로 모두 지정 지정 함 함* /

prázdny pásik1Complete (); neplatný strip2Complete (); prázdny strip3Complete (); neplatný strip4Complete (); prázdny pásik5Complete ();

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

#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 strip5 (74, 12, NEO_GRB + NEO_KHZ800, & strip5Complete); /*배열 을 사용한 연결 버튼 핀 설정*/ const int buttonPin [B_NUM] = {2, 3, 4, 5, 6}; /*배열 을 사용 하여 버튼 상태 를 지정 해줌*/ int tlačidloState [B_NUM]; /*2 번핀 부터 6 번핀 까지 상태 는 순서 대로 LOW 임*/ int lastButtonState [B_NUM] = {LOW, LOW, LOW, LOW, LOW}; /*2 번핀 부터 6 번핀 까지 버튼 카운터 를 초기화 시킴*/ int tlačidlo Počítadlo [B_NUM] = {0, 0, 0, 0, 0}; /*2 번핀 부터 6 번핀 까지 최대 버튼 카운터 는 5 임*/ int tlačidloCounterMax = 5; /*모든 버튼 핀 을 읽 일수 있도록 변수 추가*/ int čítanie [B_NUM]; nepodpísaný dlhý poslednýDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 oneskorenie50 과 같음*/ nepodpísané dlhé debounceDelay = 50;

neplatné nastavenie () {

/*복잡 하게 저항 연결 이 필요 없도록 인풋 풀업 방식 의 버튼 설정 GN: GND - 5V (Connect to Pin number)*/ 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 počítadlo = 5; void loop () { /*버튼 수 보다 i 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (čítanie ! = buttonState ) {buttonState = čítanie ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 Max 값 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = čítanie ; } /*모든 스트립 을 업데이트 함.* / Strip1. Update (); strip2. Update (); strip3. Update (); strip4. Update (); strip5. Update ();

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

/*버튼 배열 의 0 번째 즉. 2/ prepínač (prepínač tlačidiel [0]) {

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

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

///// SPÍNAČ_3 ////////////////////////////////////////////////////// ////////////////////////////////////////////////////////// ///////////////////////////////////////////////

prepínač (buttonCounter [1]) {prípad 0: strip2. ActivePattern = STAR; strip2. Interval = 50; strip2. TotalSteps = strip2.numPixels (); prestávka; prípad 1: strip2. ActivePattern = RAINBOWSPARKLE; strip2. Interval = 100; strip2. TotalSteps = strip2.numPixels (); prestávka; prípad 2: strip2. ActivePattern = SKENER; strip2. Interval = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; prestávka; prípad 3: strip2. ActivePattern = TWINKLE; strip2. Interval = 5; strip2. TotalSteps = strip2.numPixels (); prestávka; prípad 4: strip2. ActivePattern = METEOR; strip2. Interval = 40; strip2. TotalSteps = strip2.numPixels (); prestávka; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// SPÍNAČ_4 ////////////////////////////////////////////////////// ////////////////////////////////////////////////////////// ///////////////////////////////////////////////

prepínač (buttonCounter [2]) {prípad 0: strip3. ActivePattern = STAR; strip3. Interval = 50; strip3. TotalSteps = strip3.numPixels (); prestávka; prípad 1: strip3. ActivePattern = RAINBOWSPARKLE; strip3. Interval = 100; strip3. TotalSteps = strip3.numPixels (); prestávka; prípad 2: strip3. ActivePattern = SKENER; strip3. Interval = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; prestávka; prípad 3: strip3. ActivePattern = TWINKLE; strip3. Interval = 5; strip3. TotalSteps = strip3.numPixels (); prestávka; prípad 4: strip3. ActivePattern = METEOR; strip3. Interval = 25; strip3. TotalSteps = strip3.numPixels (); prestávka; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// SPÍNAČ_5 //////////////////////////////////////////////////////// ////////////////////////////////////////////////////////// ///////////////////////////////////////////////

prepínač (buttonCounter [3]) {prípad 0: strip4. ActivePattern = STAR; strip4. Interval = 50; strip4. TotalSteps = strip4.numPixels (); prestávka; prípad 1: strip4. ActivePattern = RAINBOWSPARKLE; strip4. Interval = 100; strip4. TotalSteps = strip4.numPixels (); prestávka; prípad 2: strip4. ActivePattern = SKENER; strip4. Interval = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; prestávka; prípad 3: strip4. ActivePattern = TWINKLE; strip4. Interval = 5; strip4. TotalSteps = strip4.numPixels (); prestávka; prípad 4: strip4. ActivePattern = METEOR; strip4. Interval = 25; strip4. TotalSteps = strip4.numPixels (); prestávka; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// SPÍNAČ_6 //////////////////////////////////////////////////////// ////////////////////////////////////////////////////////// ///////////////////////////////////////////////

prepínač (buttonCounter [4]) {prípad 0: strip5. ActivePattern = STAR; pásik 5. Interval = 50; strip5. TotalSteps = strip5.numPixels (); prestávka; prípad 1: strip5. ActivePattern = RAINBOWSPARKLE; pásik 5. Interval = 100; strip5. TotalSteps = strip5.numPixels (); prestávka; prípad 2: strip5. ActivePattern = SKENER; pásik 5. Interval = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; prestávka; prípad 3: strip5. ActivePattern = TWINKLE; pásik 5. Interval = 5; strip5. TotalSteps = strip5.numPixels (); prestávka; prípad 4: strip5. ActivePattern = METEOR; pásik 5. Interval = 25; strip5. TotalSteps = strip5.numPixels (); prestávka; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Dokončenie spätného volania

neplatné strip1Complete () {strip1. Color1 = strip1. Wheel (random (255)); strip1. Color2 = strip1. Wheel (random (255)); strip1. Index = 0; }

// strip2 Dokončenie spätného volania

neplatné strip2Complete () {strip2. Color1 = strip2. Wheel (random (255)); strip2. Color2 = strip2. Wheel (random (255)); strip2. Index = 0; }

// strip3 Dokončenie spätného volania

neplatné strip3Complete () {strip3. Color1 = strip3. Wheel (random (255)); strip3. Color2 = strip3. Wheel (random (255)); strip3. Index = 0; }

// strip4 Dokončenie spätného volania

neplatné strip4Complete () {strip4. Color1 = strip4. Wheel (random (255)); strip4. Color2 = strip4. Wheel (random (255)); strip4. Index = 0; }

// strip5 Zavolanie späť

neplatné strip5Complete () {strip5. Color1 = strip5. Wheel (random (255)); strip5. Color2 = strip5. Wheel (random (255)); strip5. Index = 0; }

Krok 6: Výsledok a tvorba filmu

Ďakujeme za váš záujem o náš projekt, aj keď to nestačí.