Trek die lig - ligmodule met behulp van Neopixel en optel -skakelaar: 6 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

Kenmerke van die Light -module

• Arduino Uno
• Hardeware en omhulsel gekoop vanaf die internet
• Neopixel en kragtoevoer geleen by die School of Informatics & Product Design
• Ligmodule beheer deur kragtoevoer
• Alle funksies word beheer deur gebruikersinteraksie
• Animasietipes Neopixel -strook: tipe reën, tipe stort, tipe vonke, tipe pop, onreëlmatige tipe
• Die optrekskakelaar is gekoppel aan die Neopixel -strook en die animasie verander wanneer die Neopixel -strook getrek word

Stap 1: Voordat ons begin

Hallo instruksies en vervaardigers.

Ons het 'n interaktiewe ontwerpprojek begin met betrekking tot wat sou gebeur as ons die emosie van reën deur die animasie van lig kon voel. Ek het gedink dat die gevoeligheid van die gebruiker maksimaliseer deur 'n koppelvlak wat direk lig trek.

Sodat ons nie aan die werk kan gaan nie

Stap 2: Onderdele benodig

Gebaseer op een ligmodule

*** Neopixels en kragtoevoer is gebruik met die ondersteuning van ons departement. ***

Elektronika:

1. Arduino Uno
2. 3 kleur draad (swart, rooi, enige kleur)
3. 3 -pins aansluiting (skakel om te koop)
4. Trek skakelaar 1 op (skakel om te koop)
5. krimpende buis
6. WS2812b addisionele LED -strook met 74 LED (Neopixel -strook)*2
7. Kragtoevoer (5V 350A) 1

*** 50 stelle is nodig vir die Arduino, die trekskakelaar en die NeoPixels. ***

Hardeware:

1. Akrielstaaf 2t (10mm*1000mm) 1
2. Akrielbord 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Swart spuit
5. Kabeldas
6. String
7. Hardebord
8. Roosterbord

Stap 3: Konnektiwiteit en die bou van die hardeware

Eerstens benodig ons die akriel sny om een beligtingsmodule te maak.

• As 'n manier om die animasie van lig te ervaar, stel 'n beligtingsmodule op wat vasgemaak word deur 74 LED's in die vorm van 'n neopixelstrook aan 'n 2 mm dik akrielstaaf met 'n 1M -oppervlakte te heg. Ons het twee tipes beligtingsmodules vervaardig: tipies lineêr en spiraalvormig.
• Vir lineêre tipes kan die bestaande neopixelstroke vasgehou en beveilig word, maar spiraalvorme benodig handmatige werking. Elkeen van die 74 LED's word in stukke verdeel, aan 'n spiraalvormige akriel geheg en met lood vasgemaak.

Bevestig die Neopixel -strook aan die akriel en maak elke strook vas om te voorkom dat dit deur hitte versprei word, of bind dit vas met 'n dun vislyn. In die geval van 'n lineêre tipe, moes die bol aan die einde van die module getrek word om die estetiese voorkoms te ontwerp, en ons het die tafeltennisbal met 'n swart spuit klaar. Toe boor hulle 'n gaatjie in die tafeltennisbal en verbind dit met 'n tou. Die volgende belangrikste deel, die skakelaar en die neopixel, word verbind soos aangedui. Die skakelaar word dan aan die plafonrak vasgemaak.

In die geval van spiraaltipe, bestaan die risiko dat direkte trek van die spiraalmodule die akriel onder druk kan breek, sodat die trekgedeelte (invoer) en die module (uitset) geskei is. Om die val van lig te maksimeer, is modules vertikaal op die plafon geïnstalleer, lineêre modules is aan die lug vasgemaak, spirale is direk aan die plafon vasgemaak. En ons het die tafeltennisbal en die skakelaar aan die vislyn gekoppel sodat dit bedien kon word.

Die akriel sny soos in die tekening hierbo getoon, is nodig om die skakelaar op die rak vas te maak. 'N Vierkantige skakelaar van ongeveer 6 cm is ongeveer 5 mm dik, met die skakelaar gesentreer en 'n kabelbinder wat deur gate aan beide kante steek om die skakelaar stewig vas te maak. 'N Sirkelvormige gat aan die onderkant van die middel stel die trek van die skakelaar bloot, waaronder 'n driekabelkabel uitgetrek en aan die kabelaansluiting van die module gekoppel word. En op dieselfde manier word die rak en akriel deur 'n gat in die vier hoeke vasgemaak met kabelbinders. Soos hierbo beskryf, is die lineêre module direk gekoppel aan die trek, maar die spiraalmodule verbind die pen en die skakelaar afsonderlik.

Stap 4: Skep met 50 ligmodules

Ons het 'n gebruikerservaring vir ryker lig ontwerp deur 'n totaal van 50 modules te implementeer

Ons het 'n rak van 1, 800 mm breed en 1, 200 mm lank, en ons het elke skakelaar en module verbind sodat u die reën- en reënomgewing wat ons aanvanklik beplan het, kon ervaar, en ons het elke module alleen laat staan om multi-tasking moontlik te maak.

Afhangende van die ontwerptekening, is 'n ronde gat in die foemax geboor om die installasie te verberg en om seker te maak dat die gekoppelde area van die LED -module nie sigbaar is nie. Aangesien die afstand van die akrielbord tot die LED -moduleverbinding waar die skakelaar aangebring is ongeveer 1 cm is, is 'n 1 cm dik foemax gebruik.

Die metaal vierkantige raam is gebruik om die installasie saam met skroewe en kabelbinders vas te hou terwyl die totale gewig en balans behoue bly. As die lengte van die blootgestelde verbindings langer is as die vervaardiger probeer, is die dikker bord ondoeltreffend en word ander strukture aanbeveel.

Om die gebruikerservaring op ooghoogte te vergemaklik, word die voltooide installasie op 'n steun van ongeveer 2 m geplaas, maar die versigtigheid is dat dit baie omslagtig is om die ingeboude LED -module met die skakelaar te installeer, sodat alle verbindings verwyder moet word. Ons klim op die leer en verbind die module met die installasie op die steun.

Die belangrikste deel van hierdie hele proses is om te verseker dat die werk veilig en volledig uitgevoer word om te verseker dat die ervaring moontlik is in 'n veilige omgewing

'N Totaal van 10 arduino- en 50 LED-modules is gebruik en vyf LED-modules is per arduino gekoppel vir meer doeltreffende en naatlose multi-tasking. Sien aangehegte bloudruk vir meer inligting. Neopixel multi-tasking kodering met behulp van die volle skakelaar volgens die ontwerpdiagram sal in die volgende stap breedvoerig bespreek word.

Stap 5: Arduino -kodering en bedrading

Bedrading

• 50 modules is volgens die uiteensetting van stap 4 verbind.
• Elke module is verdeel in 10 stelle van 50 modules om multi-tasking moontlik te maak en 'n duidelike verbinding te bied.
• Soos in die stel 1 -prent hierbo getoon, is vyf modules aan 'n enkele arduino gekoppel, en die 5v -penne van neopixel is tegelyk vasgemaak om die kragtoevoer aan te sluit.
• Die GND van die neopixels en die skakelaars is ook aan mekaar vasgemaak en vir die gemak van waarneming is die skakelaars in penne 2, 3, 4, 5, 6 gekoppel en die neopixels in penne 9, 10, 11, 12, 13.
• Die skakelaars en neopixels is onderskeidelik op 2-9, 3-10, 4-11, 5-12, 6-13 maniere verbind.
• Daar moet op gelet word dat die krimpende buis verhit is om te verseker dat die swak dele nie breek nie, aangesien die verbindings van die lyne kompleks is en daar 'n brandgevaar is as gevolg van kortsluitings.

Neopixel multi-tasking kodering met optrekskakelaar

5 ligte animasie (tipe reën, tipe stort, tipe vonke, tipe pop, onreëlmatige tipe)

#insluit

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

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

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

klas NeoPatterns: publiek Adafruit_NeoPixel { /* 패턴 을 추가 하고 업데이트 하기 위한 함수* / public: patroon ActivePattern; /*클레스 함수 에 패턴 의 방향 을 입력*/ rigting Rigting;

/*변수 Interval 을 추가*/ ongetekende lang interval; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 Kleur1, Kleur2 를 추가*/ uint32_t Kleur1, Kleur2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Indeks 를 추가*/ uint16_t Indeks;

/*패턴 을 완료 했을 시 다시 불러오는 함수*/ void (*OnComplete) (); /*네오 패턴 에서 네오 픽샐 의 핀 핀 번호, 콜백 을 불러오는/*/ NeoPatterns (uint16_t pixels, uint8_t pin, uint8_t type, void (*callback) ()): Adafruit_NeoPixel (pixels, pin, type) { OnComplete = terugbel; }

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

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

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

saak THEATER_CHASE: TheatreChaseUpdate (); /*saak THEATER_CHASE 에서 나와라*/ breek;

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

saak COLOR_WIPE: ColorWipeUpdate (); /*geval COLOR_WIPE 에서 나와라*/ breek; /*case SCANNER 에서는 ScannerUpdate 를 실행 하라*/ case SCANNER: ScannerUpdate (); /*case SCANNER 에서 나와라*/ break;

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

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

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

geval TWINKLE: TwinkleUpdate (); /*geval TWINKLE 에서 나와라*/ breek;

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

geval STAR: StarUpdate (); /*geval STAR 에서 나와라*/ breek;

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

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

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

geval LIG: LightUpdate (); /*geval LIGT 에서 나와라*/ breek;

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

saak BLOSSOM: BlossomUpdate (); /*omhulsel BLOSSOM 에서 나와라*/ breek; }}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void ColorWipeUpdate () { /*indeks 를 컬러 1 로 변환 시켜라* / setPixelColor (Index, Color1); / *애니메이션 을 보여주는 함수 */ show (); Toename (); }

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

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

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

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

/*Skandeerder 의 컬러 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 = stappe; /*컬러 1, 2 를 설정*/ Kleur1 = kleur1; Kleur2 = kleur2; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void Fade () 안에 입력 되는 dir = VOORUIT 과 같음*/ Direction = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 rooi 값 은 다음 과 같음* / uint8_t red = ((Red (Color1)*(TotalSteps - Index)) + (Red (Color2)*Index)) / TotalSteps; / * 변수 groen 값 은 다음 과 같음 * / uint8_t green = ((Green (Color1) * (TotalSteps - Index)) + (Green (Color2) * Index)) / TotalSteps; / * 변수 blou 값 은 다음 과 같음 * / uint8_t blue = ((Blue (Color1) * (TotalSteps - Index)) + (Blue (Color2) * Index)) / TotalSteps; /*위 의 rooi, groen, blou 값 으로 컬러 를 셋팅/*/ ColorSet (kleur (rooi, groen, blou)); / *애니메이션 을 보여주는 함수 */ show (); Toename (); }

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

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

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

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

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

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

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

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

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

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

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

void Rainbowsparkle (uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 RAINBOWSPARKLE* / ActivePattern = RAINBOWSPARKLE; /*시간 은 leegte Rainbowsparkle () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Indeks = 0; /*방향 은 void Rainbowsparkle () 안에 입력 되는 rigting 과 같음*/ Direction = dir; }

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

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); } anders {setPixelColor (i, random (255)); }} / *애니메이션 을 보여주는 함수 * / show (); Toename (); } /*Meteor 의 시간 과 방향 을 입력* / void Meteor (uint32_t color1) { /*실행 되는 패턴 은 METEOR* / ActivePattern = METEOR; /*시간 설정*/ Interval = Interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Kleur1 = kleur1; Indeks = 0; }

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

void MeteorUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == Index) {setPixelColor (i, 100, random (255), 255); } anders {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 함수 * / show (); Toename (); }

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

void Light (uint32_t color1) { /*실행 되는 패턴 은 LIGHT* / ActivePattern = LIGHT; /*시간 설정*/ Interval = Interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Kleur1 = kleur1; Indeks = 0; }

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

void LightUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 150, random (200), 40); } anders {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 함수 * / show (); Toename (); }

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

void Blossom (uint32_t color1) { /*실행 되는 패턴 은 BLOSSOM* / ActivePattern = BLOSSOM; /*시간 설정*/ Interval = Interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Kleur1 = kleur1; Indeks = 0; }

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

void BlossomUpdate () {for (int i = 0; i <numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 255, random (255), 100); } anders {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 함수 * / show (); Toename (); }

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

/ *네오 픽셀 의 켜지 는 위치 와 색 을 지정 해주는/ */ void setAll (byte rooi, byte groen, byte blou) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, rooi, groen, blou); } Wys(); }

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

uint32_t DimColor (uint32_t kleur) {// Shift R, G en B komponente een bietjie na regs uint32_t dimColor = Kleur (Rooi (kleur) >> 1, Groen (kleur) >> 1, Blou (kleur) >> 1); gee dimColor terug; }

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

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

/*레드 값 을 불러 옴*/

uint8_t Rooi (uint32_t kleur) {return (kleur >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Groen (uint32_t kleur) {return (kleur >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t Blou (uint32_t kleur) {return color & 0xFF; }

/*Rainbow 컬러 를 불러 옴*/

uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; as (WheelPos <85) {return Color (255 - WheelPos * 3, 0, WheelPos * 3); } anders as (WheelPos <170) {WheelPos -= 85; gee kleur (0, WheelPos * 3, 255 - WheelPos * 3); } anders {WheelPos -= 170; retourkleur (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

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

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

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

#define NUMPIXELS 74 /*사용 하는 버튼 의 갯수 /* / #define B_NUM 5 /*Import strip1 ~ 5 까지, 갯수 는 74 개 스트립 연결 핀 은 strip1 은 8 ~ strip5 까지 12* / NeoPatterns strip1 (74, 8, NEO_GRB + NEO_KHZ800, en strip1Complete); NeoPatterns strip2 (74, 9, NEO_GRB + NEO_KHZ800, en strip2Complete); NeoPatterns strip3 (74, 10, NEO_GRB + NEO_KHZ800, en strip3Complete); NeoPatterns strip4 (74, 11, NEO_GRB + NEO_KHZ800, en strip4Complete); NeoPatterns strip5 (74, 12, NEO_GRB + NEO_KHZ800, en 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 buttonCounter [B_NUM] = {0, 0, 0, 0, 0}; /*2 번핀 부터 6 번핀 까지 최대 버튼 카운터 는 5 임*/ int buttonCounterMax = 5; /*모든 버튼 핀 을 읽 일수 있도록 변수 추가*/ int lees [B_NUM]; ongetekende lang lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 vertraging50 과 같음*/ ongetekende lang debounceDelay = 50;

ongeldige opstelling () {

/*복잡 하게 저항 연결 이 필요 인풋 풀업 풀업 방식 버튼 GN GN: GND - 5V (Koppel aan speldnommer)*/ vir (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Serial.begin (9600); /*스트립 1 ~ 5 를 셋팅*/ strip1.begin (); strip2.begin (); strip3.begin (); strip4.begin (); strook5.begin ();

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

}

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

int teller = 5; leemte -lus () { /*버튼 수 보다 i 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (lees ! = buttonState ) {buttonState = lees ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 Max 값 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = lees ; } /*모든 스트립 을 업데이트 함.* / Strip1. Update (); strook2. Opdateer (); strook3. Opdateer (); strook4. Update (); strook5. Update ();

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

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

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

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

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

skakelaar (buttonCounter [1]) {case 0: strip2. ActivePattern = STAR; strook2. Interval = 50; strip2. TotalSteps = strip2.numPixels (); breek; geval 1: strook2. ActivePattern = RAINBOWSPARKLE; strook2. Interval = 100; strip2. TotalSteps = strip2.numPixels (); breek; geval 2: strook2. ActivePattern = SCANNER; strook2. Interval = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; breek; saak 3: strook2. ActivePattern = TWINKLE; strook2. Interval = 5; strip2. TotalSteps = strip2.numPixels (); breek; geval 4: strook2. ActivePattern = METEOR; strook2. Interval = 40; strip2. TotalSteps = strip2.numPixels (); breek; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

skakelaar (buttonCounter [2]) {case 0: strip3. ActivePattern = STAR; strook 3. Interval = 50; strip3. TotalSteps = strip3.numPixels (); breek; geval 1: strook3. ActivePattern = RAINBOWSPARKLE; strook 3. Interval = 100; strip3. TotalSteps = strip3.numPixels (); breek; geval 2: strook3. ActivePattern = SCANNER; strook 3. Interval = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; breek; saak 3: strook3. ActivePattern = TWINKLE; strook 3. Interval = 5; strip3. TotalSteps = strip3.numPixels (); breek; saak 4: strook3. ActivePattern = METEOR; strook 3. Interval = 25; strip3. TotalSteps = strip3.numPixels (); breek; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

skakelaar (buttonCounter [3]) {case 0: strip4. ActivePattern = STAR; strook 4. Interval = 50; strip4. TotalSteps = strip4.numPixels (); breek; geval 1: strook4. ActivePattern = RAINBOWSPARKLE; strook 4. Interval = 100; strip4. TotalSteps = strip4.numPixels (); breek; geval 2: strip4. ActivePattern = SCANNER; strook 4. Interval = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; breek; saak 3: strook4. ActivePattern = TWINKLE; strook 4. Interval = 5; strip4. TotalSteps = strip4.numPixels (); breek; geval 4: strook4. ActivePattern = METEOR; strook4. Interval = 25; strip4. TotalSteps = strip4.numPixels (); breek; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

skakelaar (buttonCounter [4]) {case 0: strip5. ActivePattern = STAR; strook5. Interval = 50; strip5. TotalSteps = strip5.numPixels (); breek; geval 1: strook5. ActivePattern = RAINBOWSPARKLE; strook5. Interval = 100; strip5. TotalSteps = strip5.numPixels (); breek; geval 2: strook5. ActivePattern = SCANNER; strook5. Interval = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; breek; saak 3: strook5. ActivePattern = TWINKLE; strook5. Interval = 5; strip5. TotalSteps = strip5.numPixels (); breek; geval 4: strook5. ActivePattern = METEOR; strook5. Interval = 25; strip5. TotalSteps = strip5.numPixels (); breek; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Voltooiing Terugbel

void strip1Complete () {strip1. Color1 = strip1. Wheel (random (255)); strook1. Kleur2 = strook1. Wiel (ewekansig (255)); strook1. Indeks = 0; }

// strip2 Voltooiing Terugbel

void strip2Complete () {strip2. Color1 = strip2. Wheel (random (255)); strook2. Kleur2 = strook2. Wiel (ewekansig (255)); strook2. Indeks = 0; }

// strip3 Voltooiing Terugbel

void strip3Complete () {strip3. Color1 = strip3. Wheel (random (255)); strook3. Kleur2 = strook3. Wiel (ewekansig (255)); strook3. Indeks = 0; }

// strip4 Voltooiing Terugbel

void strip4Complete () {strip4. Color1 = strip4. Wheel (random (255)); strook4. Kleur2 = strook4. Wiel (ewekansig (255)); strook4. Indeks = 0; }

// strip5 Voltooiing Terugbel

void strip5Complete () {strip5. Color1 = strip5. Wheel (random (255)); strook5. Kleur2 = strook5. Wiel (ewekansig (255)); strook5. Indeks = 0; }

Stap 6: Resultaat en filmmaak

Dankie vir u belangstelling in ons projek, alhoewel dit nie genoeg is nie.