Vedä valo - valomoduuli Neopixel & Pull Up -kytkimellä: 6 vaihetta (kuvilla)

2024 Kirjoittaja: John Day | [email protected]. Viimeksi muokattu: 2024-01-30 09:02

Valomoduulin ominaisuudet

• Arduino Uno
• Laitteisto ja kotelo ostettu Internetistä
• Neopixel & virtalähde lainattu Informatiikan ja tuotesuunnittelun korkeakoulusta
• Valomoduuli, jota ohjaa virtalähde
• Kaikkia toimintoja ohjataan käyttäjien vuorovaikutuksella
• Neopixel -nauhan animaatiotyypit: Sateen tyyppi, Suihkutyyppi, Kipinän salama, Pop -tyyppi, Epäsäännöllinen tyyppi
• Pull -up -kytkin on liitetty Neopixel -nauhaan ja animaatio muuttuu, kun Neopixel -nauhaa vedetään

Vaihe 1: Ennen kuin aloitamme

Hei ohjattavat ja tekijät.

Aloitimme interaktiivisen suunnitteluprojektin, mitä tapahtuisi, jos saisimme tuntea sateen tunteen valon animaation kautta. Luulin, että käyttäjän herkkyys maksimoidaan suoraan valoa vetävän käyttöliittymän kautta.

Että pääsee töihin

Vaihe 2: Tarvittavat osat

Perustuu yhteen valomoduuliin

*** Neopikseleitä ja virtalähdettä käytettiin osastomme tuella. ***

Elektroniikka:

1. Arduino Uno
2. 3 värilankaa (musta, punainen, mikä tahansa väri)
3. 3 -nastainen liitin (linkki ostamiseen)
4. Vedä kytkin 1 ylös (linkki ostaa)
5. kutistuva putki
6. WS2812b lisättävä LED -nauha, jossa 74 LED -valoa (neopikselinauha)*2
7. Virtalähde (5V 350A) 1

*** Arduinoa, vetokytkintä ja NeoPixeleitä varten tarvitaan 50 sarjaa. ***

Laitteisto:

1. Akryylitanko 2t (10mm*1000mm) 1
2. Akryylilevy 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Musta suihke
5. Nippuside
6. Jousisoitin
7. Kovalevy
8. Ruudukkolevy

Vaihe 3: Yhteydet ja laitteiston rakentaminen

Ensinnäkin tarvitsemme akryylileikkauksen yhden valaistusmoduulin tekemiseksi.

• Valon animaation kokeilemiseksi vedä valaistusmoduuli, joka kiinnitetään kiinnittämällä 74 LEDiä neopikseliliuskan muodossa 2 mm paksuiseen akryylitankoon, jonka pinta -ala on 1 M. Olemme tuottaneet kahdenlaisia valaistusmoduuleja: tyypillisiä lineaarisia ja spiraalisia.
• Lineaarisissa tyypeissä olemassa olevia neopikseliliuskoja voidaan pitää ja kiinnittää, mutta spiraalityypit edellyttävät manuaalista käyttöä. Jokainen 74 LED: stä on jaettu osiin, kiinnitetty kierreakryyliin ja liimattu yhteen lyijyn kanssa.

Kiinnitä Neopixel -nauha akryyliin ja kiinnitä jokainen nauha kuumuuden leviämisen estämiseksi tai sido ohut siima. Lineaarisen tyypin tapauksessa pallo, joka oli vedettävä moduulin päähän, asennettiin esteettisen ilmeen suunnittelua varten, ja viimeistelemme pingispallon mustalla suihkulla. Sitten he porasivat pienen reiän pingispallopalloon ja yhdensivät sen köydellä. Seuraava tärkein osa, kytkin ja neopikseli, on kytketty kuvan mukaisesti. Kytkin kiinnitetään sitten kattohyllyyn.

Spiraalityypin tapauksessa on olemassa vaara, että spiraalimoduulin suora vetäminen voi rikkoa akryylin paineen alaisena, joten vetokohta (tulo) ja moduuli (lähtö) erotettiin toisistaan. Valon putoamisen maksimoimiseksi moduulit asennettiin pystysuoraan kattoon, lineaariset moduulit kiinnitettiin ilmaan, spiraalit kiinnitettiin suoraan kattoon. Yhdistimme pingispallon ja kytkimen siimaan, jotta sitä voitaisiin käyttää.

Yllä olevan piirroksen mukainen akryylileikkaus on tarpeen kytkimen kiinnittämiseksi hyllyyn. 6 cm: n neliönmuotoinen kytkin on noin 5 mm paksu, kytkin keskellä ja nippuside työnnetty molemmin puolin olevien reikien läpi, jotta kytkin pysyy tukevasti kiinni. Keskellä oleva pyöreä reikä paljastaa kytkimen vedon, jonka alapuolelta vedetään kolmijohtiminen kaapeli ja kytketään moduulin kaapeliliittimeen. Samoin hylly ja akryyli on kiinnitetty nippusiteillä neljän kulman reiän kautta. Kuten edellä on kuvattu, lineaarimoduuli on kytketty suoraan vetolaitteeseen, mutta spiraalimoduuli yhdistää tapin ja kytkimen erikseen.

Vaihe 4: Luo käyttämällä 50 valomoduulia

Olemme suunnitelleet käyttökokemuksen rikkaammalle valolle ottamalla käyttöön yhteensä 50 moduulia

Meillä oli hylly, joka oli 1 800 mm leveä ja 1 200 mm pitkä, ja yhdistämme kaikki kytkimet ja moduulit, jotta voit kokea alun perin suunnitellun sade- ja sadeympäristön, ja meillä oli jokainen moduuli erillään monitoimityön mahdollistamiseksi.

Suunnittelupiirustuksesta riippuen reikä porattiin foemaxiin asennuksen piilottamiseksi ja sen varmistamiseksi, että LED -moduulin liitetty alue ei ole näkyvissä. Koska etäisyys akryylilevystä LED -moduuliliitäntään, johon kytkin on kiinnitetty, on noin 1 cm, käytettiin 1 cm paksua foemaxia.

Metallista neliömäistä kehystä käytettiin asennuksen pitämiseen yhdessä ruuveilla ja nippusiteillä säilyttäen kokonaispaino ja tasapaino. Jos paljaiden liitosten pituus on suurempi kuin valmistajan yrittäessä, paksumpi levy on tehoton ja muita rakenteita suositellaan.

Käyttäjän kokemuksen helpottamiseksi silmien tasolla valmistunut asennus asetetaan noin 2 m korkealle tuelle, mutta varoitus on, että sulautetun LED -moduulin asentaminen kytkimen kanssa on erittäin hankalaa, joten kaikki liitännät on irrotettava. Kiipesimme tikkaita ylös ja yhdistämme moduulin asennukseen, joka on kiinnitetty tukeen.

Tämän prosessin tärkein osa on varmistaa, että työ tehdään turvallisesti ja täysin varmistettuna, jotta kokemus saadaan mahdolliseksi turvallisessa ympäristössä

Yhteensä 10 arduino- ja 50 LED-moduulia käytettiin ja viisi LED-moduulia liitettiin arduinoa kohti tehokkaamman ja saumattomamman tehtävän suorittamiseksi. Katso lisätietoja oheisesta piirustuksesta. Neopixel-monitoimikoodausta, jossa käytetään suunnittelukuvion mukaista täyskytkintä, käsitellään yksityiskohtaisesti seuraavassa vaiheessa.

Vaihe 5: Arduino -koodaus ja johdotus

Johdotus

• 50 moduulia liitettiin vaiheen 4 asettelun mukaisesti.
• Kukin moduuli oli jaettu 10 sarjaan 50 moduulia, jotta monitoimityö on mahdollista ja yhteys on selkeä.
• Kuten yllä olevasta sarjan 1 kuvasta näkyy, viisi moduulia liitettiin yhteen arduinoon ja neopikselin 5 voltin nastat sidottiin yhteen virtalähteen liittämiseksi.
• Neopikselien GND ja kytkimet sidottiin myös yhteen ja havaitsemisen helpottamiseksi kytkimet liitettiin nastoihin 2, 3, 4, 5, 6 ja neopikselit liitettiin nastoihin 9, 10, 11, 12, 13.
• Kytkimet ja neopikselit yhdistettiin 2-9, 3-10, 4-11, 5-12, 6-13 tavalla.
• On huomattava, että koska linjojen liitännät ovat monimutkaisia ja niissä on tulipalovaara oikosulkujen vuoksi, kutisteputki lämmitettiin varmistaakseen, että heikot osat eivät katkenneet.

Neopixel-monitoimikoodaus vedettävällä kytkimellä

5 kevyttä animaatiota (sadetyyppi, suihkutyyppi, kipinäsalamatyyppi, pop -tyyppi, epäsäännöllinen tyyppi)

#sisältää

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

enum -kuvio {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 픽셀 을 방향 을 설정 함*/ enum direction {Eteenpäin, taaksepäin};

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

luokan NeoPatterns: julkinen Adafruit_NeoPixel { /* 패턴 을 추가 하고 업데이트 하기 위한 함수* / public: pattern ActivePattern; /*클레스 함수 에 패턴 의 방향 을 입력*/ suunta Suunta;

/*변수 Intervalli 을 추가*/ unsigned long Interval; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 Väri1, Väri2 를 추가*/ uint32_t Väri1, Väri2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Hakemisto 를 추가*/ uint16_t Hakemisto;

/*패턴 을 완료 했을 시 다시 불러오는 함수*/ void (*OnComplete) (); /*네오 패턴 에서 네오 의 갯수, 핀 번호, 타입, 콜백 을 함수 함수*/ NeoPatterns (uint16_t pikseliä, uint8_t -nasta, uint8_t -tyyppi, void (*soittopyyntö) ()): Adafruit_NeoPixel (pikseliä, pin, tyyppi) { OnComplete = takaisinsoitto; }

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

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

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

tapaus THEATER_CHASE: TheaterChaseUpdate (); /*tapaus THEATER_CHASE 에서 나와라*/ tauko;

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

tapaus COLOR_WIPE: ColorWipeUpdate (); /*kotelo COLOR_WIPE 에서 나와라*/ tauko; /*kotelo SKANNERI 에서는 ScannerUpdate 를 실행 하라*/ kotelo SKANNERI: ScannerUpdate (); /*kotelo SKANNERI 에서 나와라*/ tauko;

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

tapaus FADE: FadeUpdate (); /*kotelo FADE 에서 나와라*/ tauko;

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

tapaus TWINKLE: TwinkleUpdate (); /*kotelo TWINKLE 에서 나와라*/ tauko;

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

tapaus STAR: StarUpdate (); /*kotelo STAR 에서 나와라*/ tauko;

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

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

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

kotelo LIGHT: LightUpdate (); /*kotelo LIGHT 에서 나와라*/ tauko;

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

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

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

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

mitätön lisäys () { /*만약 정방향 이면 인덱스 를 증가 시켜라* / jos (suunta == ETEENPÄIN) {Indeksi ++; /*만약 인덱스 가 전체 네오 픽셀 구동 갯수 와 같 거나 면 으로 0 으로 초기화 시켜라*/ if (Index> = TotalSteps) {Index = 0; /*패턴 을 완료 시키는 함수*/ if (OnComplete! = NULL) {OnComplete (); }}}

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

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

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

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

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

void RainbowCycle (uint8_t -väli, suunta dir = FORWARD) { /*실행 되는 패턴 은 RainbowCycle 임* / ActivePattern = RAINBOW_CYCLE; /*시간 은 void RainbowCycle () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 255 임*/ TotalSteps = 255; /*인덱스 는 0 으로 설정 함*/ Hakemisto = 0; /*방향 은 void RainbowCycle () 안에 입력 되는 dir = ETEENPÄIN 과 같음*/ Suunta = dir; }

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

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

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

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

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

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

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

void ColorWipe (uint32_t väri, uint8_t väli, suunta dir = ETEENPÄIN) { /*실행 되는 패턴 은 COLOR_WIPE* / ActivePattern = COLOR_WIPE; /*시간 은 void ColorWipe () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Väri1 = väri; /*인덱스 는 0 으로 설정 함*/ Hakemisto = 0; /*방향 은 void ColorWipe () 안에 입력 되는 dir = ETEENPÄIN 과 같음*/ Suunta = dir; }

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

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

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

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

/*Skannerin päivitys 를 업데이트 했을 경우*/

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

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

void Fade (uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 void Fade () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*구동 갯수 는 스텝 값임*/ TotalSteps = askeleet; /*컬러 1, 2 를 설정*/ Väri1 = väri1; Väri2 = väri2; /*인덱스 는 0 으로 설정 함*/ Hakemisto = 0; /*방향 은 void Fade () 안에 입력 되는 dir = ETEENPÄIN 과 같음*/ Suunta = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 punainen 값 은 다음 과 같음* / uint8_t red = ((Punainen (Väri1)*(TotalSteps - Indeksi)) + (Punainen (Väri2)*Indeksi)) / TotalSteps; / * 변수 vihreä 값 은 다음 과 같음 * / uint8_t green = ((Vihreä (väri1) * (TotalSteps - Index)) + (Green (Color2) * Index)) / TotalSteps; / * 변수 sininen 값 은 다음 과 같음 * / uint8_t blue = ((sininen (väri1) * (TotalSteps - Index)) + (sininen (väri2) * Index)) / TotalSteps; /*위 의 punainen, vihreä, sininen 값 으로 컬러 를 셋팅 함*/ ColorSet (Väri (punainen, vihreä, sininen)); / *애니메이션 을 보여주는 함수 */ show (); Lisäys (); }

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

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

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

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

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

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

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

mitätön tähti (uint32_t color1) { /*실행 되는 패턴 은 STAR* / ActivePattern = STAR; /*시간 은 void Star () 안에 입력 되는 interval 과 같음*/ Interval = Interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Väri1 = väri1; Indeksi = 0; }

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

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

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

void Rainbowsparkle (uint8_t -väli, suunta dir = FORWARD) { /*실행 되는 패턴 은 RAINBOWSPARKLE* / ActivePattern = RAINBOWSPARKLE; /*시간 은 void Rainbowsparkle () 안에 입력 되는 interval 과 같음*/ Interval = väli; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Indeksi = 0; /*방향 은 void Rainbowsparkle () 안에 입력 되는 suunta 과 같음*/ Suunta = dir; }

/*RainbowsparklePäivitä 를 업데이트 했을 경우*/

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

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

tyhjä valo (uint32_t color1) { /*실행 되는 패턴 은 LIGHT* / ActivePattern = LIGHT; /*시간 설정*/ Intervalli = Väli; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Väri1 = väri1; Indeksi = 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 (); Lisäys (); }

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

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

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

/ *네오 픽셀 의 켜지 는 위치 와 을 지정 해주는 함수 */ void setAll (tavu punainen, tavu vihreä, tavu sininen) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, red, vihreä sininen); } näytä(); }

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

uint32_t DimColor (uint32_t väri) {// Siirrä R-, G- ja B -komponentteja yksi bitti oikealle uint32_t dimColor = Väri (punainen (väri) >> 1, vihreä (väri) >> 1, sininen (väri) >> 1); paluu dimColor; }

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

void ColorSet (uint32_t color) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, väri); } näytä(); }

/*레드 값 을 불러 옴*/

uint8_t Punainen (uint32_t väri) {return (väri >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Vihreä (uint32_t väri) {return (väri >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t Sininen (uint32_t väri) {return color & 0xFF; }

/*Sateenkaari 컬러 를 불러 옴*/

uint32_t Pyörä (tavua WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return Color (255 - WheelPos * 3, 0, WheelPos * 3); } muu jos (WheelPos <170) {WheelPos -= 85; palauta väri (0, WheelPos * 3, 255 - WheelPos * 3); } else {WheelPos -= 170; palauta väri (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

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

void strip1Complete (); void strip2Complete (); void strip3Complete (); tyhjä nauha4Complete (); tyhjä nauha5Täys ();

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

#define NUMPIXELS 74 /*사용 하는 버튼 의 갯수 설정* / #define B_NUM 5 /*Tuo nauha1 ~ 5 까지, 갯수 는 74 개 스트립 연결 핀 은 nauha1 은 8 ~ nauha5 까지 12* / NeoPatterns strip1 (74, 8, NEO_GRB + NEO_KHZ800, & strip1Complete); NeoPatterns strip2 (74, 9, NEO_GRB + NEO_KHZ800 ja & strip2Complete); NeoPatterns strip3 (74, 10, NEO_GRB + NEO_KHZ800 ja strip3Complete); NeoPatterns strip4 (74, 11, NEO_GRB + NEO_KHZ800 ja strip4Complete); NeoPatterns strip5 (74, 12, NEO_GRB + NEO_KHZ800 ja & strip5Complete); /*배열 을 사용한 연결 버튼 핀 설정*/ const int buttonPin [B_NUM] = {2, 3, 4, 5, 6}; /*배열 을 사용 하여 버튼 상태 를 지정 해줌*/ int buttonState [B_NUM]; /*2 번핀 부터 6 번핀 까지 상태 는 순서 대로 LOW 임*/ int lastButtonState [B_NUM] = {LOW, LOW, LOW, LOW, LOW}; /*2 번핀 부터 6 번핀 까지 버튼 카운터 를 초기화 시킴*/ int -painikeCounter [B_NUM] = {0, 0, 0, 0, 0}; /*2 번핀 부터 6 번핀 까지 최대 버튼 카운터 는 5 임*/ int -painikeCounterMax = 5; /*모든 버튼 핀 을 읽 일수 있도록 변수 추가*/ int lukeminen [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 delay50 과 같음*/ unsigned long debounceDelay = 50;

void setup () {

/*복잡 하게 저항 연결 이 필요 인풋 풀업 방식 의 의 설정 G: GND - 5V (Yhdistä PIN -numeroon)*/ for (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Sarja.alku (9600); /*스트립 1 ~ 5 를 셋팅*/ strip1.begin (); nauha2.alku (); strip3.begin (); strip4.begin (); strip5.begin ();

//raita1. Teatterivaihe (nauha1. Väri (255, 0, 255), nauha1. Väri (255, 50, 0), 20, ETEENPÄIN);

}

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

int laskuri = 5; void loop () { /*버튼 수 가 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (luku ! = buttonState ) {buttonState = lukeminen ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 Max 값 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = lukeminen ; } /*모든 스트립 을 업데이트 함.* / Strip1. Update (); nauha2. Päivitä (); nauha3. Päivitä (); nauha4. Päivitä (); nauha 5. Päivitä ();

///// KYTKIN_2 /////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////. //////////////////////////////////////////////////////////

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

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

tapaus 0: nauha 1. ActivePattern = BLOSSOM; /*해당 애니메이션 의 시간 을 설정*/ strip1. Interval = 20; /*구동 되는 네오 픽셀 의 갯수 를 설정*/ strip1. TotalSteps = strip1.numPixels (); tauko; /*두번째 버튼 을 활동 시키면 구동 되는 애니메이션*/ tapaus 1: kaistale 1. ActivePattern = RAINBOWSPARKLE; nauha 1. Interval = 50; strip1. TotalSteps = strip1.numPixels (); tauko; /*세번째 버튼 을 활동 시키면 구동 되는 애니메이션*/ tapaus 2: nauha 1. ActivePattern = SKANNERI; nauha1. Väli = 10; strip1. TotalSteps = (strip1.numPixels () - 1) * 2; tauko; /*네번째 버튼 을 활동 시키면 구동 되는 애니메이션*/ tapaus 3: kaistale 1. ActivePattern = TWINKLE; nauha1. Väli = 1; strip1. TotalSteps = strip1.numPixels (); tauko; /*다섯 번째 버튼 을 활동 시키면 구동 되는 애니메이션*/ tapaus 4: kaista 1. ActivePattern = METEOR; nauha1. väli = 10; strip1. TotalSteps = strip1.numPixels (); tauko; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// KYTKIN_3 /////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////. //////////////////////////////////////////////////////////

kytkin (buttonCounter [1]) {case 0: strip2. ActivePattern = STAR; nauha 2. väli = 50; strip2. TotalSteps = strip2.numPixels (); tauko; tapaus 1: kaistale 2. ActivePattern = RAINBOWSPARKLE; nauha 2. väli = 100; strip2. TotalSteps = strip2.numPixels (); tauko; tapaus 2: nauha 2. ActivePattern = SKANNERI; nauha 2. väli = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; tauko; tapaus 3: nauha 2. ActivePattern = TWINKLE; nauha 2. väli = 5; strip2. TotalSteps = strip2.numPixels (); tauko; tapaus 4: nauha2. ActivePattern = METEOR; nauha 2. väli = 40; strip2. TotalSteps = strip2.numPixels (); tauko; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// SWITCH_4 /////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////. //////////////////////////////////////////////////////////

kytkin (buttonCounter [2]) {case 0: strip3. ActivePattern = STAR; nauha 3. väli = 50; strip3. TotalSteps = strip3.numPixels (); tauko; tapaus 1: nauha 3. ActivePattern = RAINBOWSPARKLE; strip3. Interval = 100; strip3. TotalSteps = strip3.numPixels (); tauko; tapaus 2: nauha 3. ActivePattern = SKANNERI; nauha 3. väli = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; tauko; tapaus 3: nauha 3. ActivePattern = TWINKLE; nauha 3. väli = 5; strip3. TotalSteps = strip3.numPixels (); tauko; tapaus 4: nauha 3. ActivePattern = METEOR; nauha 3. väli = 25; strip3. TotalSteps = strip3.numPixels (); tauko; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// KYTKIN_5 /////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////. //////////////////////////////////////////////////////////

kytkin (buttonCounter [3]) {case 0: strip4. ActivePattern = STAR; nauha 4. väli = 50; strip4. TotalSteps = strip4.numPixels (); tauko; tapaus 1: nauha4. ActivePattern = RAINBOWSPARKLE; nauha4.intervalli = 100; strip4. TotalSteps = strip4.numPixels (); tauko; tapaus 2: nauha4. ActivePattern = SKANNERI; nauha4.intervalli = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; tauko; tapaus 3: strip4. ActivePattern = TWINKLE; nauha 4. väli = 5; strip4. TotalSteps = strip4.numPixels (); tauko; tapaus 4: nauha4. ActivePattern = METEOR; nauha4.intervalli = 25; strip4. TotalSteps = strip4.numPixels (); tauko; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

///// KYTKIN_6 /////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////. //////////////////////////////////////////////////////////

kytkin (buttonCounter [4]) {case 0: strip5. ActivePattern = STAR; nauha 5.intervalli = 50; strip5. TotalSteps = strip5.numPixels (); tauko; tapaus 1: nauha 5. ActivePattern = RAINBOWSPARKLE; nauha 5.intervalli = 100; strip5. TotalSteps = strip5.numPixels (); tauko; tapaus 2: nauha 5. ActivePattern = SKANNERI; nauha 5.intervalli = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; tauko; tapaus 3: nauha 5. ActivePattern = TWINKLE; nauha 5.intervalli = 5; strip5. TotalSteps = strip5.numPixels (); tauko; tapaus 4: nauha 5. ActivePattern = METEOR; nauha 5.intervalli = 25; strip5. TotalSteps = strip5.numPixels (); tauko; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Valmistumisen takaisinsoitto

void strip1Complete () {strip1. Color1 = strip1. Wheel (random (255)); nauha1. Väri2 = nauha1. Pyörä (satunnainen (255)); strip1. Index = 0; }

// strip2 Viimeistelyn takaisinsoitto

void strip2Complete () {strip2. Color1 = strip2. Wheel (random (255)); nauha2. Väri2 = nauha2. Pyörä (satunnainen (255)); strip2. Index = 0; }

// strip3 Viimeistelyn takaisinsoitto

void strip3Complete () {strip3. Color1 = strip3. Wheel (random (255)); nauha3. Väri2 = nauha3. Pyörä (satunnainen (255)); strip3. Index = 0; }

// strip4 Viimeistelyn takaisinsoitto

void strip4Complete () {strip4. Color1 = strip4. Wheel (random (255)); nauha4. Väri2 = nauha4. Pyörä (satunnainen (255)); strip4. Index = 0; }

// strip5 Viimeistelyn takaisinsoitto

void strip5Complete () {strip5. Color1 = strip5. Wheel (random (255)); nauha5. Väri2 = kaistale 5. Pyörä (satunnainen (255)); strip5. Index = 0; }

Vaihe 6: Tulos ja elokuvan tekeminen

Kiitos mielenkiinnostasi projektiamme kohtaan, vaikka se ei riitä.