Pull the Light - Light Module using Neopixel & Pull Up Switch: 6 Steps (with Pictures)

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:22

Vlastnosti modulu Light

• Arduino Uno
• Hardware a skříň zakoupené z internetu
• Neopixel a napájecí zdroj zapůjčené ze školy informatiky a produktového designu
• Světelný modul ovládaný napájecím zdrojem
• Všechny funkce jsou ovládány interakcí uživatelů
• Typy animace pásu Neopixel: Rain, Typ Shower, Spark lightning, Pop, Ir nepravidelný typ
• Přepínač vytažení je připojen k pásu Neopixel a animace se změní po vytažení pásu Neopixel

Krok 1: Než začneme

Dobrý den, instruktoři a tvůrci.

Zahájili jsme projekt interaktivního designu z hlediska toho, co by se stalo, kdybychom cítili emoce deště prostřednictvím animace světla. Myslel jsem, že citlivost uživatele bude maximalizována prostřednictvím rozhraní, které přímo přitahuje světlo.

Abych se nedostal do práce

Krok 2: Potřebné součásti

Na základě jednoho světelného modulu

*** Neopixely a napájení byly použity s podporou našeho oddělení. ***

Elektronika:

1. Arduino Uno
2. 3 barevný vodič (černý, červený, jakákoli barva)
3. 3pin konektor (odkaz na nákup)
4. Vytáhněte spínač 1 (odkaz koupit)
5. smršťovací trubice
6. WS2812b nastavitelný LED pásek se 74 LED (Neopixelový pás)*2
7. Napájení (5V 350A) 1

*** Pro Arduino, Pull Switch a NeoPixels je potřeba 50 sad. ***

Hardware:

1. Akrylová tyč 2t (10mm*1000mm) 1
2. Akrylová deska 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Černý sprej
5. Kabelová svorka
6. Tětiva
7. Sololit
8. Mřížková deska

Krok 3: Připojení a budování hardwaru

Nejprve potřebujeme řezání akrylem na výrobu jednoho osvětlovacího modulu.

• Chcete -li zažít animaci světla, navrhněte světelný modul, který je upevněn připevněním 74 LED diod ve formě neopixelového proužku na 2 mm silnou akrylovou lištu s 1M oblastí. Vyrobili jsme dva typy osvětlovacích modulů: typický lineární a spirálový.
• U lineárních typů lze stávající neopixelové pásy přidržovat a zajišťovat, ale spirálové typy vyžadují ruční ovládání. Každá ze 74 LED je rozdělena na kusy, připevněna ke spirálovému akrylu a spojena olovem.

Připevněte proužek Neopixel k akrylu a zajistěte každý proužek, aby se zabránilo jeho šíření teplem, nebo jej spojte tenkou šňůrkou. V případě lineárního typu byla koule, kterou bylo třeba natáhnout na konec modulu, nainstalována, aby navrhla estetický vzhled, a pingpongový míč jsme dokončili černým sprejem. Poté vyvrtali do pingpongového míčku malou díru a spojili ji provazem. Další nejdůležitější část, přepínač a neopixel, je spojena podle obrázku. Přepínač je poté zajištěn ke stropní polici.

V případě spirálového typu existuje riziko, že přímé tažení spirálového modulu by mohlo rozbít akrylát pod tlakem, takže tažná část (vstup) a modul (výstup) byly odděleny. Pro maximalizaci dopadajícího světla byly moduly instalovány svisle na strop, lineární moduly byly upevněny do vzduchu, spirály byly upevněny přímo na strop. A připojili jsme pingpongový míč a vypínač k vlasci, aby se dal ovládat.

K zajištění přepínače k polici je vyžadováno řezání akrylem, jak je znázorněno na obrázku výše. Přepínač ve tvaru čtverce 6 cm je přibližně 5 mm tlustý, se spínačem vystředěným a kabelovým stahovacím páskem vloženým skrz otvory na obou stranách, aby byl spínač pevně zajištěn. Kruhový otvor ve spodní části středu odhaluje zatažení spínače, pod ním je vytažen třívodičový kabel a připojen ke kabelové svorce modulu. A podobně skrz otvor ve čtyřech rozích je police a akryl zajištěny stahovacími páskami. Jak je popsáno výše, lineární modul je připojen přímo k tahu, ale spirálový modul spojuje kolík a spínač samostatně.

Krok 4: Vytvořte pomocí 50 světelných modulů

Navrhli jsme uživatelské prostředí pro bohatší osvětlení nasazením celkem 50 modulů

Měli jsme polici, která byla 1 800 mm široká a 1 200 mm dlouhá, a připojili jsme každý přepínač a modul, abyste mohli zažít prostředí s deštěm a deštěm, které jsme původně plánovali, a každý modul jsme nechali samostatně, aby bylo možné provádět více úloh najednou..

V závislosti na konstrukčním výkresu byl do foemax vyvrtán kulatý otvor, aby se skryla instalace a aby se zajistilo, že připojená oblast LED modulu není vidět. Protože vzdálenost od akrylové desky k připojení modulu LED, kde je připojen spínač, je přibližně 1 cm, byl použit foemax o tloušťce 1 cm.

Kovový čtvercový rám byl použit k držení instalace společně se šrouby a kabelovými páskami při zachování celkové hmotnosti a rovnováhy. Pokud je délka odkrytých spojů větší než při pokusu výrobce, tlustší deska je neúčinná a doporučují se jiné struktury.

Aby se usnadnil uživatelský zážitek na úrovni očí, je dokončená instalace umístěna na podpěru vysokou přibližně 2 metry, ale opatrností je, že je velmi obtížné instalovat integrovaný modul LED pomocí přepínače, takže všechna připojení by měla být odstraněna. Vylezli jsme po žebříku a spojili modul s instalací upevněnou na podpěře.

Nejdůležitější částí celého tohoto procesu je zajistit, aby práce byla prováděna bezpečně a plně zabezpečena, aby bylo zajištěno, že zkušenosti budou možné v bezpečném prostředí

Bylo použito celkem 10 arduino a 50 LED modulů a na LED arduino bylo připojeno pět LED modulů pro efektivnější a bezproblémový multitasking. Podrobnosti najdete v přiloženém plánu. Víceúlohové kódování Neopixel pomocí úplného přepínače podle schématu návrhu bude podrobně diskutováno v dalším kroku.

Krok 5: Kódování a zapojení Arduino

Elektrické vedení

• Podle rozložení kroku 4 bylo připojeno 50 modulů.
• Každý modul byl rozdělen do 10 sad po 50 modulech, aby bylo možné provádět více úkolů a zajistit jasné spojení.
• Jak ukazuje obrázek sady 1 výše, pět modulů bylo připojeno k jednomu arduinu a 5v piny neopixelu byly spojeny najednou, aby se připojilo napájení.
• GND neopixelů a spínačů byly také svázány dohromady a kvůli snadnějšímu vnímání byly spínače zapojeny do kolíků 2, 3, 4, 5, 6 a neopixely byly zapojeny do kolíků 9, 10, 11, 12, 13.
• Přepínače a neopixely byly spojeny 2-9, 3-10, 4-11, 5-12, 6-13 způsobem.
• Je třeba poznamenat, že vzhledem k tomu, že spoje vedení jsou složité a kvůli zkratům hrozí nebezpečí požáru, smršťovací trubice byla zahřátá, aby se zajistilo, že se slabé části nerozbijí.

Víceúlohové kódování Neopixel s přepínačem nahoru

5 světelná animace (dešťový, sprchový, jiskřivý, bleskový, popový, nepravidelný)

#zahrnout

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

vzor výčtu {ŽÁDNÝ, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 픽셀 을 방향 을 설정 함*/ enum směr {DOPŘEDU, ZPĚT};

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

třída NeoPatterns: public Adafruit_NeoPixel { /* 패턴 을 추가 하고 업데이트 하기 위한 함수* / public: vzor ActivePattern; /*클레스 함수 에 패턴 의 방향 을 입력*/ směr Směr;

/*변수 Interval 을 추가*/ bez znaménka dlouhý interval; /*변수 lastUpdate 를 추가*/ nepodepsané dlouhé lastUpdate; /*변수 Barva1, Barva2 를 추가*/ uint32_t Barva1, Barva2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Rejstřík 를 추가*/ uint16_t Rejstřík;

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

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

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

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

případ THEATER_CHASE: TheaterChaseUpdate (); /*případ THEATRE_CHASE 에서 나와라*/ break;

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

případ COLOR_WIPE: ColorWipeUpdate (); /*pouzdro COLOR_WIPE 에서 나와라*/ break; /*case SCANNER 에서는 ScannerUpdate 를 실행 하라*/ case SCANNER: ScannerUpdate (); /*pouzdro SKENER 에서 나와라*/ break;

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

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

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

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

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

case STAR: StarUpdate (); /*case STAR 에서 나와라*/ break;

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

pouzdro RAINBOWSPARKLE: RainbowsparkleUpdate (); /*pouzdro RAINBOWSPARKLE 에서 나와라*/ break; /*případ METEOR 에서는 MeteorUpdate 를 실행 하라*/ případ METEOR: MeteorUpdate (); /*pouzdro METEOR 에서 나와라*/ break;

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

pouzdro LIGHT: LightUpdate (); /*pouzdro SVĚTLO 에서 나와라*/ přestávka;

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

pouzdro BLOSSOM: BlossomUpdate (); /*pouzdro BLOSSOM 에서 나와라*/ break; }}}

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

/*Rejstřík 를 증가 시키고 초기화 하는 함수*/

neplatný přírůstek () { /*만약 정방향 이면 인덱스 를 증가 시켜라* / if (Směr == VPŘED) {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é Zpětný chod () { /*애니메이션 함수 에 Zpětný chod 를 썼을 시, 만약 방향 이 정방향 이면* / if (Směr == Vpřed) { /*방향 은 그 와 반대 반대 이며 전체 구동 갯수 에서 1 일 빼라* / Směr = ZPĚT; Index = TotalSteps - 1; } /*그 외의 방향 이 정방향 이면 인덱스 를 0 으로 설정 해라* / else {Směr = VPŘED; Index = 0; }}

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

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

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

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

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

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

neplatné TheaterChase (uint32_t color1, uint32_t color2, uint8_t interval, směr dir = FORWARD) { /*실행 되는 패턴 은 RTHEATER_CHASE* / ActivePattern = THEATER_CHASE; /*시간 은 neplatné TheaterChase () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1, 2 를 설정*/ Barva1 = barva1; Barva2 = barva2; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 neplatné TheaterChase () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

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

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

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

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

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

neplatné ColorWipeUpdate () { /*index 를 컬러 1 로 변환 시켜라* / setPixelColor (Index, Color1); / *애니메이션 을 보여주는 함수 */ show (); Přírůstek(); }

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

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

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

neplatné 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 (); Přírůstek(); }

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

void Fade (uint32_t color1, uint32_t color2, uint16_t kroky, uint8_t interval, směr dir = FORWARD) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 neplatné Fade () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*구동 갯수 는 스텝 값임*/ TotalSteps = kroky; /*컬러 1, 2 를 설정*/ Barva1 = barva1; Barva2 = barva2; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 neplatné Fade () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; } /*FadeUpdate 를 업데이트 했을 경우* / neplatné FadeUpdate () { /*변수 červená 값 은 다음 과 같음* / uint8_t červená = ((červená (barva1)*(celkový počet kroků - index)) + (červená (barva2)*rejstřík)) / TotalSteps; / * 변수 zelená 값 은 다음 과 같음 * / uint8_t zelená = ((zelená (barva1) * (celkový počet kroků - index)) + (zelená (barva2) * index)) / celkový počet kroků; / * 변수 modrá 값 은 다음 과 같음 * / uint8_t modrá = ((Blue (Color1) * (TotalSteps - Index)) + (Blue (Color2) * Index)) / TotalSteps; /*위 의 červená, zelená, modrá 값 으로 컬러 를 셋팅 함*/ ColorSet (barva (červená, zelená, modrá)); / *애니메이션 을 보여주는 함수 */ show (); Přírůstek(); }

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

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

/*Třpyt 의 컬러 1 와 시간 을 입력*/

neplatné Twinkle (uint32_t color1, uint8_t interval) { /*실행 되는 패턴 은 TWINKLE* / ActivePattern = TWINKLE; /*시간 은 neplatné Twinkle () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*컬러 1 를 설정*/ Barva1 = barva1; /*총 구동 갯수 는 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 (); Přírůstek(); }

/*Hvězda 의 컬러 1 값 을 입력*/

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

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

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

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

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

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

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

/*Světlo 의 시간 과 방향 을 입력*/

prázdné světlo (uint32_t color1) { /*실행 되는 패턴 은 LIGHT* / ActivePattern = LIGHT; /*시간 설정*/ Interval = interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Barva1 = barva1; Index = 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 (); Přírůstek(); }

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

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

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

/ *네오 픽셀 의 켜지 는 위치 와 색 을 지정 해주는 함수 */ void setAll (byte red, byte green, byte blue) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, red, zeleno modrá); } ukázat(); }

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

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

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

void ColorSet (barva uint32_t) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, color); } ukázat(); }

/*레드 값 을 불러 옴*/

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

/*Duha 컬러 를 불러 옴*/

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átit barvu (0, WheelPos * 3, 255 - WheelPos * 3); } else {WheelPos -= 170; vrátit barvu (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

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

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

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

#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čítkoState [B_NUM]; /*2 번핀 부터 6 번핀 까지 상태 는 순서 대로 LOW 임*/ int lastButtonState [B_NUM] = {LOW, LOW, LOW, LOW, LOW}; /*2 번핀 부터 6 번핀 까지 버튼 카운터 를 초기화 시킴*/ int tlačítko Počitadlo [B_NUM] = {0, 0, 0, 0, 0}; /*2 번핀 부터 6 번핀 까지 최대 버튼 카운터 는 5 임*/ int tlačítkoCounterMax = 5; /*모든 버튼 핀 을 읽 일수 있도록 변수 추가*/ int čtení [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 zpoždění50 과 같음*/ nepodepsané dlouhé debounceDelay = 50;

neplatné nastavení () {

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

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

/*버튼 배열 의 0 번째 즉. 2 번핀 에 연결된 버튼 을 활용 하여 애니메이션 이 구동 되도록 하는 스위치 케이스 구문 구문*/ přepínač (tlačítkoCounter [0]) {

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

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

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

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

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

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

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

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

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

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

// strip1 Dokončení zpětného volání

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

// strip2 Dokončení zpětného volání

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

// strip3 Dokončení zpětného volání

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

// strip4 Dokončení zpětného volání

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

// strip5 Dokončení zpětného volání

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

Krok 6: Výsledek a tvorba filmu

Děkujeme za váš zájem o náš projekt, i když to nestačí.