Húzza a fény - fénymodult a Neopixel és a felhúzó kapcsoló segítségével: 6 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

A Light modul jellemzői

• Arduino Uno
• Hardver és ház az internetről vásárolt
• Neopixel és tápegység kölcsönzött az Informatikai és Terméktervezési Iskolától
• Tápegység által vezérelt fénymodul
• Minden funkció a felhasználói interakción keresztül vezérelhető
• A Neopixel szalag animációs típusai: eső, zuhany típus, szikra villám, pop típus, szabálytalan típus
• A felhúzó kapcsoló a Neopixel csíkhoz van csatlakoztatva, és az animáció megváltozik, amikor meghúzza a Neopixel csíkot

Lépés: Mielőtt elkezdenénk

Sziasztok oktatók és készítők.

Elkezdtünk egy interaktív tervezési projektet azzal kapcsolatban, hogy mi történne, ha a fény animációjával éreznénk az eső érzelmeit. Azt hittem, hogy a felhasználó érzékenysége maximalizálható egy olyan felületen keresztül, amely közvetlenül a fényt vonzza.

Nehogy munkába álljon

2. lépés: Szükséges alkatrészek

Egy fénymodul alapján

*** Neopixeleket és tápegységeket használtak osztályunk támogatásával. ***

Elektronika:

1. Arduino Uno
2. 3 színű vezeték (fekete, piros, bármilyen színű)
3. 3 tűs csatlakozó (link a vásárláshoz)
4. Húzza fel az 1 kapcsolót (link a vásárláshoz)
5. zsugorodó cső
6. WS2812b címezhető LED szalag 74 LED -el (neopixel szalag)*2
7. Tápegység (5V 350A) 1

*** 50 készlet szükséges az Arduino, a Pull Switch és a NeoPixels készülékekhez. ***

Hardver:

1. Akril rúd 2t (10mm*1000mm) 1
2. Akril lap 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Fekete spray
5. Kábelkötegelő
6. Húr
7. Farostlemez
8. Rácslap

3. lépés: Csatlakozás és a hardver építése

Először is szükségünk van egy akrilvágásra egy világítási modul elkészítéséhez.

• A fény animációjának megtapasztalása érdekében rajzoljon meg egy világítási modult, amelyet 74 LED -es neopixel csík formájában rögzítenek egy 2 mm vastag, 1 M -es területű akrilrúdra. Kétféle világítási modult gyártottunk: tipikus lineáris és spirális.
• Lineáris típusoknál a meglévő neopixel csíkok tarthatók és rögzíthetők, de a spirál típusok kézi működtetést igényelnek. A 74 LED mindegyike darabokra van osztva, spirális akrilra van erősítve, és ólommal van összekötve.

Csatlakoztassa a Neopixel csíkot az akrilhoz, és rögzítse mindegyik csíkot, hogy ne terjedjen ki hő hatására, vagy kösse vékony horogsorral. Lineáris típus esetén a modul végére húzandó gömböt telepítettük az esztétikai megjelenés megtervezésére, és a pingponglabdát fekete spray -vel fejeztük be. Aztán kis lyukat fúrtak a pingpong labdába, és kötéllel kötötték össze. A következő legfontosabb rész, a kapcsoló és a neopixel az ábrán látható módon van csatlakoztatva. A kapcsolót ezután a mennyezeti polchoz rögzítik.

Spirál típus esetén fennáll annak a veszélye, hogy a spirálmodul közvetlen húzása nyomás alatt eltörheti az akrilt, ezért a húzószakasz (bemenet) és a modul (kimenet) elkülönültek. A fényesés maximalizálása érdekében a modulokat függőlegesen a mennyezetre szerelték fel, a lineáris modulokat a levegőhöz rögzítették, a spirálokat közvetlenül a mennyezethez rögzítették. A ping -pong labdát és a kapcsolót pedig a horgászzsinórhoz kötöttük, hogy működtethető legyen.

A fenti rajzon látható akril vágás szükséges a kapcsoló polcra rögzítéséhez. A 6 cm -es, négyzet alakú kapcsoló körülbelül 5 mm vastag, a kapcsoló középre van helyezve, és mindkét oldalon lyukakba illesztett kábelkötegelő segítségével a kapcsoló szilárdan rögzíthető. A középső alján lévő kör alakú lyuk kiteszi a kapcsoló húzását, amely alatt egy háromvezetékes kábelt húznak ki és csatlakoztatnak a modul kábelcsatlakozójához. Hasonlóképpen, a négy sarokban lévő lyukon keresztül a polc és az akril kábelkötegekkel vannak rögzítve. A fentebb leírtak szerint a lineáris modul közvetlenül a húzóhoz van csatlakoztatva, de a spirálmodul külön köti össze a csapot és a kapcsolót.

4. lépés: Létrehozás 50 fénymodul használatával

A gazdagabb fény érdekében felhasználói élményt terveztünk, összesen 50 modul alkalmazásával

Volt egy polcunk, amely 1 800 mm széles és 1 200 mm hosszú volt, és minden kapcsolót és modult összekapcsoltunk, hogy megtapasztalhassuk az eredetileg tervezett eső- és esőkörnyezetet, és minden modul különálló volt, hogy lehetővé tegye a többfeladatos munkát.

A tervrajz függvényében egy kerek lyukat fúrtak a foemaxba, hogy elrejtse a telepítést, és megbizonyosodjon arról, hogy a LED -modul csatlakoztatott területe nem látható. Mivel az akril tábla és a LED modul csatlakozó közötti távolság, ahol a kapcsoló rögzítve van, körülbelül 1 cm, 1 cm vastag foemaxot használtunk.

A fém négyzet alakú keretet használták a szerelés csavarokkal és kábelkötegelőkkel való összefogására, miközben megtartották az összsúlyt és az egyensúlyt. Ha a kitett csatlakozások hossza nagyobb, mint amikor a gyártó megpróbálja, a vastagabb lemez nem hatékony, és más szerkezetek ajánlottak.

A felhasználó szemmagasságbeli élményének megkönnyítése érdekében a befejezett telepítést körülbelül 2 m magas támaszra kell helyezni, de vigyázat, hogy nagyon nehézkes a beépített LED -modul felszerelése a kapcsolóval, ezért minden csatlakozást el kell távolítani. Felmásztunk a létrán, és összekötöttük a modult a tartóra rögzített szereléssel.

Ennek az egész folyamatnak a legfontosabb része annak biztosítása, hogy a munkát biztonságosan és teljes biztonságban végezzék, annak érdekében, hogy a tapasztalatok biztonságos környezetben történjenek

Összesen 10 arduino és 50 LED modult használtak, és öt LED modult csatlakoztattak arduino-nként a hatékonyabb és zökkenőmentes többfeladatos munkavégzés érdekében. Részletekért lásd a mellékelt tervrajzot. A Neopixel többfeladatos kódolást a tervezési diagram szerinti teljes kapcsolóval részletesen tárgyaljuk a következő lépésben.

5. lépés: Arduino kódolás és huzalozás

Vezeték

• 50 modult csatlakoztattak a 4. lépés elrendezésének megfelelően.
• Mindegyik modult 10, 50 modulból álló készletre osztották, hogy lehetővé tegyék a többfeladatos munkát, és egyértelmű kapcsolatot biztosítsanak.
• Amint az a fenti 1. képen látható, öt modult csatlakoztattak egyetlen arduino -hoz, és az 5 V -os neopixel csapokat egyszerre kötötték össze a tápegység csatlakoztatásához.
• A neopixelek és a kapcsolók GND -jét is összekötötték, és az észlelés megkönnyítése érdekében a kapcsolókat a 2, 3, 4, 5, 6 érintkezőkbe dugták, a neopixeleket pedig a 9, 10, 11, 12, 13 érintkezőkbe..
• A kapcsolók és a neopixelek 2-9, 3-10, 4-11, 5-12, 6-13 módon csatlakoztak.
• Meg kell jegyezni, hogy mivel a vezetékek összeköttetései bonyolultak, és tűzveszély áll fenn a rövidzárlatok miatt, a zsugorcsövet felmelegítették, hogy a gyenge részek ne törjenek el.

Neopixel többfeladatos kódolás felhúzó kapcsolóval

5 könnyű animáció (eső, zuhany típus, szikra villám, pop típus, szabálytalan típus)

#befoglalni

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

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

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

osztály NeoPatterns: public Adafruit_NeoPixel { /* 패턴 을 추가 하고 업데이트 하기 위한 함수* / public: minta ActivePattern; /*클레스 함수 에 패턴 의 방향 을 입력*/ irány Irány;

/*변수 Interval 을 추가*/ unsigned long Interval; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 Szín1, Színes2 를 추가*/ uint32_t Szín1, Szín2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Index 를 추가*/ uint16_t Index;

/*패턴 을 완료 했을 시 다시 불러오는 함수*/ void (*OnComplete) (); /*네오 패턴 에서 네오 의 갯수, 핀 번호, 타입, 콜백 을 함수 함수*/ NeoPatterns (uint16_t pixels, uint8_t pin, uint8_t type, void (*callback) ()): Adafruit_NeoPixel (pixel, pin, type) { OnComplete = visszahívás; }

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

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

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

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

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

eset COLOR_WIPE: ColorWipeUpdate (); /*tok COLOR_WIPE 에서 나와라*/ break; /*tok SCANNER 에서는 ScannerUpdate 를 실행 하라*/ case SCANNER: ScannerUpdate (); /*eset SZKENNER 에서 나와라*/ break;

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

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

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

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

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

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

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

tok RAINBOWSPARKLE: RainbowsparkleUpdate (); /*tok RAINBOWSPARKLE 에서 나와라*/ break; /*case METEOR 에서는 MeteorUpdate 를 실행 하라*/ case METEOR: MeteorUpdate (); /*tok METEOR 에서 나와라*/ break;

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

tok LIGHT: LightUpdate (); /*tok LIGHT 에서 나와라*/ break;

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

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

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

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

void Increment () { /*만약 정방향 이면 인덱스 를 증가 시켜라* / if (Irány == ELŐRE) {Index ++; /*만약 인덱스 가 전체 네오 픽셀 구동 갯수 와 같 거나 많다 면 0 으로 초기화 시켜라*/ if (Index> = Összes lépés) {Index = 0; /*패턴 을 완료 시키는 함수*/ if (OnComplete! = NULL) {OnComplete (); }}}

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

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

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

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

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

void RainbowCycle (uint8_t intervallum, irány dir = FORWARD) { /*실행 되는 패턴 은 RainbowCycle 임* / ActivePattern = RAINBOW_CYCLE; /*시간 은 void RainbowCycle () 안에 입력 되는 intervallum 과 같음*/ Interval = intervallum; /*총 구동 갯수 는 255 임*/ TotalSteps = 255; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 void RainbowCycle () 안에 입력 되는 dir = ELŐRE 과 같음*/ Irány = dir; }

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

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

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

void TheaterChase (uint32_t color1, uint32_t color2, uint8_t intervallum, irány dir = FORWARD) { /*실행 되는 패턴 은 RTHEATER_CHASE* / ActivePattern = THEATER_CHASE; /*시간 은 void TheaterChase () 안에 입력 되는 intervallum 과 같음*/ Interval = intervallum; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1, 2 를 설정*/ Szín1 = szín1; Szín2 = szín2; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 void TheaterChase () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

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

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

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

void ColorWipe (uint32_t szín, uint8_t intervallum, irány dir = ELŐRE) { /*실행 되는 패턴 은 COLOR_WIPE* / ActivePattern = COLOR_WIPE; /*시간 은 void ColorWipe () 안에 입력 되는 intervallum 과 같음*/ Interval = intervallum; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Szín1 = szín; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 void ColorWipe () 안에 입력 되는 dir = ELŐRE 과 같음*/ Irány = dir; }

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

void ColorWipeUpdate () { /*index 를 컬러 1 로 변환 시켜라* / setPixelColor (Index, Szín1); / *애니메이션 을 보여주는 함수 */ show (); Növekedés(); }

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

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

/*Szkennerfrissítés 를 업데이트 했을 경우*/

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

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

void Fade (uint32_t szín1, uint32_t szín2, uint16_t lépés, uint8_t intervallum, irány dir = ELŐRE) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 void Fade () 안에 입력 되는 intervallum 과 같음*/ Interval = intervallum; /*구동 갯수 는 스텝 값임*/ TotalSteps = lépések; /*컬러 1, 2 를 설정*/ Szín1 = szín1; Szín2 = szín2; /*인덱스 는 0 으로 설정 함*/ Index = 0; /*방향 은 void Fade () 안에 입력 되는 dir = ELŐRE 과 같음*/ Irány = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 piros 값 은 다음 과 같음* / uint8_t red = ((Piros (Szín1)*(TotalSteps - Index)) + (Piros (Színes2)*Index)) / TotalSteps; / * 변수 zöld 값 은 다음 과 같음 * / uint8_t green = ((Green (Color1) * (TotalSteps - Index)) + (Green (Color2) * Index)) / TotalSteps; / * 변수 kék 값 은 다음 과 같음 * / uint8_t blue = ((Blue (Color1) * (TotalSteps - Index)) + (Blue (Color2) * Index)) / TotalSteps; /*위 의 piros, zöld, kék 값 으로 컬러 를 셋팅 함*/ ColorSet (Színes (piros, zöld, kék)); / *애니메이션 을 보여주는 함수 */ show (); Növekedés(); }

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

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

/*Csillogás 의 컬러 1 와 시간 을 입력*/

void Twinkle (uint32_t color1, uint8_t intervallum) { /*실행 되는 패턴 은 TWINKLE* / ActivePattern = TWINKLE; /*시간 은 void Twinkle () 안에 입력 되는 intervallum 과 같음*/ Interval = intervallum; /*컬러 1 를 설정*/ Szín1 = szín1; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Index = 0; }

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

void TwinkleUpdate () { /*모든 네오 픽셀 의 컬러 를 0 으로 셋팅* / setAll (0, 0, 0); /*변수 Pixel 은 random 74*/ int Pixel = random (74); /*véletlenszerű 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 (); Növekedés(); }

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

void Star (uint32_t color1) { /*실행 되는 패턴 은 STAR* / ActivePattern = STAR; /*시간 은 void Star () 안에 입력 되는 intervallum 과 같음*/ Interval = Időköz; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Szín1 = szín1; Index = 0; }

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

void StarUpdate () { /*인덱스 와 컬러 를 셋팅* / setPixelColor (Index, Szín1); előadás(); /*변수 i 가 0 이고 구동 갯수 작 으면 i 를 감소 시킴 = 한칸 씩 이동 하는*/ for (int i = 0; i <numPixels (); i--) {setPixelColor (i, Color (0, 0, 0)); } / *애니메이션 을 보여주는 함수 * / Növelés (); }

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

void Rainbowsparkle (uint8_t intervallum, irány dir = FORWARD) { /*실행 되는 패턴 IN RAINBOWSPARKLE* / ActivePattern = RAINBOWSPARKLE; /*시간 은 void Rainbowsparkle () 안에 입력 되는 intervallum 과 같음*/ Interval = intervallum; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Index = 0; /*방향 은 void Rainbowsparkle () 안에 입력 되는 irány 과 같음*/ Irány = dir; }

/*RainbowsparkleFrissítés 를 업데이트 했을 경우*/

void 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, random (255)); }} / *애니메이션 을 보여주는 함수 * / show (); Növekedés(); } /*Meteor 의 시간 과 방향 을 입력* / void Meteor (uint32_t color1) { /*실행 되는 패턴 은 METEOR* / ActivePattern = METEOR; /*시간 설정*/ Interval = Időköz; / *총 구동 갯수 는 számPixelek 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (számPixelek ()-1) *2; /*컬러 1 을 설정*/ Szín1 = szín1; 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 (); Növekedés(); }

/*Fény 의 시간 과 방향 을 입력*/

void Light (uint32_t color1) { /*실행 되는 패턴 은 LIGHT* / ActivePattern = LIGHT; /*시간 설정*/ Interval = Időköz; / *총 구동 갯수 는 számPixelek 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (számPixelek ()-1) *2; /*컬러 1 을 설정*/ Szín1 = szín1; 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 (); Növekedés(); }

/*Virágos 의 시간 과 방향 을 입력*/

void Blossom (uint32_t color1) { /*실행 되는 패턴 은 BLOSSOM* / ActivePattern = BLOSSOM; /*시간 설정*/ Interval = Időköz; / *총 구동 갯수 는 számPixelek 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (számPixelek ()-1) *2; /*컬러 1 을 설정*/ Szín1 = szín1; 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 (); Növekedés(); }

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

/ *네오 픽셀 의 켜지 는 위치 와 을 지정 해주는 함수 */ void setAll (bájt piros, bájt zöld, bájt kék) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, piros, zöldes-kék); } előadás(); }

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

uint32_t DimColor (uint32_t color) {// Az R, G és B komponensek eltolása egy bittel jobbra uint32_t dimColor = Szín (piros (szín) >> 1, zöld (szín) >> 1, kék (szín) >> 1); return dimColor; }

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

void ColorSet (uint32_t color) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, color); } előadás(); }

/*레드 값 을 불러 옴*/

uint8_t Piros (uint32_t szín) {return (szín >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Zöld (uint32_t szín) {return (szín >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t Blue (uint32_t color) {return color & 0xFF; }

/*Szivárvány 컬러 를 불러 옴*/

uint32_t Kerék (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return Color (255 - WheelPos * 3, 0, WheelPos * 3); } else if (WheelPos <170) {WheelPos -= 85; visszatérési szín (0, WheelPos * 3, 255 - WheelPos * 3); } else {WheelPos -= 170; visszatérő szín (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

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

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

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

#define NUMPIXELS 74 /*사용 하는 버튼 의 갯수 설정* / #define B_NUM 5 /*Csík importálása 1 ~ 5 까지, 갯수 는 74 개 스트립 연결 핀 은 szalag 1 은 8 ~ szalag5 까지 12* / NeoPatterns szalag1 (74, 8, NEO_GRB + NEO_KHZ800, & strip1Complete); NeoPatterns strip2 (74, 9, NEO_GRB + NEO_KHZ800 és & strip2Complete); NeoPatterns strip3 (74, 10, NEO_GRB + NEO_KHZ800 és & strip3Complete); NeoPatterns strip4 (74, 11, NEO_GRB + NEO_KHZ800 és & strip4Complete); NeoPatterns strip5 (74, 12, NEO_GRB + NEO_KHZ800 és & 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 gombCounter [B_NUM] = {0, 0, 0, 0, 0}; /*2 번핀 부터 6 번핀 까지 최대 버튼 카운터 는 5 임*/ int gombCounterMax = 5; /*모든 버튼 핀 을 읽 일수 있도록 변수 추가*/ int olvasás [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 delay50 과 같음*/ unsigned long debounceDelay = 50;

void setup () {

/*복잡 하게 저항 연결 이 필요 없도록 풀업 풀업 방식 의 버튼 설정: GND - 5V (Csatlakozás a pin -számhoz)*/ for (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Sorozat.kezdet (9600); /*스트립 1 ~ 5 를 셋팅*/ strip1.begin (); csík2.kezdet (); strip3.begin (); strip4.begin (); strip5.begin ();

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

}

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

int számláló = 5; void loop () { /*버튼 수 가 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (olvasás ! = buttonState ) {buttonState = olvasás ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 Max. 를 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = olvasás ; } /*모든 스트립 을 업데이트 함.* / Strip1. Update (); csík2. Frissítés (); csík3. Frissítés (); csík4. Frissítés (); csík5. Frissítés ();

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

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

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

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

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

switch (buttonCounter [1]) {case 0: strip2. ActivePattern = STAR; csík 2. Interval = 50; strip2. TotalSteps = strip2.numPixels (); szünet; 1. eset: csík 2. ActivePattern = RAINBOWSPARKLE; csík 2. Interval = 100; strip2. TotalSteps = strip2.numPixels (); szünet; 2. eset: szalag2. ActivePattern = SZKENNER; csík 2. Interval = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; szünet; 3. eset: szalag2. ActivePattern = TWINKLE; csík 2. Interval = 5; strip2. TotalSteps = strip2.numPixels (); szünet; 4. eset: szalag2. ActivePattern = METEOR; csík 2. Interval = 40; strip2. TotalSteps = strip2.numPixels (); szünet; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [2]) {case 0: strip3. ActivePattern = STAR; csík3.intervallum = 50; strip3. TotalSteps = strip3.numPixels (); szünet; 1. eset: csík3. ActivePattern = RAINBOWSPARKLE; csík3.intervallum = 100; strip3. TotalSteps = strip3.numPixels (); szünet; 2. eset: csík3. Aktív minta = SZKENNER; csík3.intervallum = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; szünet; 3. eset: csík 3. ActivePattern = TWINKLE; csík3.intervallum = 5; strip3. TotalSteps = strip3.numPixels (); szünet; 4. eset: szalag 3. ActivePattern = METEOR; csík3.intervallum = 25; strip3. TotalSteps = strip3.numPixels (); szünet; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [3]) {case 0: strip4. ActivePattern = STAR; csík4.intervallum = 50; strip4. TotalSteps = strip4.numPixels (); szünet; 1. eset: szalag4. ActivePattern = RAINBOWSPARKLE; csík4.intervallum = 100; strip4. TotalSteps = strip4.numPixels (); szünet; 2. eset: szalag4. ActivePattern = SZKENNER; csík4.intervallum = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; szünet; 3. eset: szalag4. ActivePattern = TWINKLE; csík4.intervallum = 5; strip4. TotalSteps = strip4.numPixels (); szünet; 4. eset: szalag4. ActivePattern = METEOR; csík4.intervallum = 25; strip4. TotalSteps = strip4.numPixels (); szünet; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [4]) {case 0: strip5. ActivePattern = STAR; csík 5. Interval = 50; strip5. TotalSteps = strip5.numPixels (); szünet; 1. eset: csík 5. ActivePattern = RAINBOWSPARKLE; csík 5. Interval = 100; strip5. TotalSteps = strip5.numPixels (); szünet; 2. eset: szalag5. ActivePattern = SCANNER; csík 5. Interval = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; szünet; 3. eset: szalag5. ActivePattern = TWINKLE; csík 5. Interval = 5; strip5. TotalSteps = strip5.numPixels (); szünet; 4. eset: szalag5. ActivePattern = METEOR; csík 5. Interval = 25; strip5. TotalSteps = strip5.numPixels (); szünet; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Befejezés Visszahívás

void strip1Complete () {strip1. Color1 = strip1. Wheel (random (255)); csík1. Szín2 = csík1. Kerék (véletlenszerű (255)); csík1.index = 0; }

// strip2 Befejezés Visszahívás

void strip2Complete () {strip2. Color1 = strip2. Wheel (random (255)); csík2. Szín2 = csík2. Kerék (véletlenszerű (255)); szalag 2. Index = 0; }

// strip3 Befejezés Visszahívás

void strip3Complete () {strip3. Color1 = strip3. Wheel (random (255)); csík3. Szín2 = csík3. Kerék (véletlenszerű (255)); csík3.index = 0; }

// strip4 Befejezés Visszahívás

void strip4Complete () {strip4. Color1 = strip4. Wheel (random (255)); csík4. Szín2 = csík4. Kerék (véletlenszerű (255)); csík4.index = 0; }

// strip5 Befejezés Visszahívás

void strip5Complete () {strip5. Color1 = strip5. Wheel (random (255)); csík5. Szín2 = szalag5. Kerék (véletlenszerű (255)); csík5. Index = 0; }

6. lépés: Eredmény és film készítése

Köszönjük érdeklődését projektünk iránt, bár ez nem elég.