Træk i lyset - lysmodulet ved hjælp af Neopixel & Pull Up -switch: 6 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

Funktioner i lysmodulet

• Arduino Uno
• Hardware og kabinet købt fra internettet
• Neopixel & strømforsyning lånt fra School of Informatics & Product Design
• Lysmodul styret af strømforsyning
• Alle funktioner styres via brugerens interaktion
• Animationstyper af Neopixel strip: Regntype, Brusertype, Type gnist lyn, Pop type, Uregelmæssig type
• Pull up -kontakten er forbundet til Neopixel -stripen, og animationen ændres, når den trækkes til Neopixel -stripen

Trin 1: Inden vi begynder

Hej instruktører og producenter.

Vi startede og interaktive designprojekt med hensyn til, hvad der ville ske, hvis vi kunne mærke regnens følelser gennem animation af lys. Jeg troede, at brugerens følsomhed ville blive maksimeret gennem en grænseflade, der trækker lys direkte.

Lad mig komme på arbejde

Trin 2: Nødvendige dele

Baseret på et lysmodul

*** Neopixels og strømforsyning blev brugt med støtte fra vores afdeling. ***

Elektronik:

1. Arduino Uno
2. 3 -farvetråd (sort, rød, enhver farve)
3. 3 -polet stik (link til køb)
4. Træk kontakt 1 op (link til køb)
5. krympende rør
6. WS2812b tilføjelig LED -strimmel med 74 LED (Neopixel -strimmel)*2
7. Strømforsyning (5V 350A) 1

*** 50 sæt er nødvendige til Arduino, pull -kontakten og NeoPixels. ***

Hardware:

1. Akrylstang 2t (10mm*1000mm) 1
2. Akrylplade 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Sort spray
5. Kabelbinder
6. Snor
7. Hardboard
8. Gitterbræt

Trin 3: Forbindelse og opbygning af hardware

For det første har vi brug for akrylskæringen for at lave et belysningsmodul.

• Som et middel til at opleve animationen af lys, udarbejde et belysningsmodul, der er fastgjort ved at fastgøre 74 lysdioder i form af en neopixelstrimmel på en 2 mm tyk akrylstang med et 1M område. Vi har produceret to typer belysningsmoduler: typisk lineær og spiralformet.
• For lineære typer kan de eksisterende neopixelstrimler fastholdes og sikres, men spiraltyper kræver manuel betjening. Hver af de 74 LED'er er delt i stykker, fastgjort til en spiralakryl og limet sammen med bly.

Sæt Neopixel -strimlen på akrylen, og fastgør hver strimmel for at forhindre, at den spredes af varme, eller bind med en tynd fiskelinje. I tilfælde af lineær type skulle kuglen trækkes på enden af modulet for at designe det æstetiske udseende, og vi afsluttede bordtennisbolden med en sort spray. Derefter borede de et lille hul i bordtennisbolden og forbandt det med et reb. Den næste vigtigste del, kontakten og neopixel, er forbundet som vist. Kontakten er derefter fastgjort til loftshylden.

I tilfælde af spiraltype er der risiko for, at direkte træk i spiralmodulet kan bryde akrylen under tryk, så trækkesektionen (Input) og modulet (Output) blev adskilt. For at maksimere lysfaldet blev moduler installeret lodret på loftet, lineære moduler blev fastgjort til luften, spiraler blev fastgjort direkte til loftet. Og vi sluttede bordtennisbolden og kontakten til fiskesnoren, så den kunne betjenes.

Akrylskæringen som vist på tegningen ovenfor er påkrævet for at fastgøre kontakten til hylden. En 6 cm firkantet kontakt er cirka 5 mm tyk, med kontakten centreret og et kabelbinder indsat gennem huller på begge sider for at sikre kontakten godt. Et cirkulært hul i bunden af midten viser kontakten, hvorunder et tretrådskabel trækkes ud og tilsluttes modulets kabelterminal. Og på samme måde er hylden og akryl fastgjort med kabelbinder gennem et hul i de fire hjørner. Som beskrevet ovenfor er det lineære modul forbundet direkte til trækket, men spiralmodulet forbinder stiften og kontakten separat.

Trin 4: Opret ved hjælp af 50 lysmoduler

Vi har designet en brugeroplevelse til rigere lys ved at implementere i alt 50 moduler

Vi havde en hylde, der var 1, 800 mm bred og 1, 200 mm lang, og vi forbandt hver switch og modul, så du kunne opleve regn- og regnmiljøet, som vi oprindeligt planlagde, og vi havde hvert modul stå alene for at muliggøre multi-tasking.

Afhængigt af designtegningen blev der boret et rundt hul i foemaxen for at skjule installationen og for at sikre, at det tilsluttede område af LED -modulet ikke er synligt. Da afstanden fra akrylpladen til LED -modulforbindelsen, hvor kontakten er fastgjort, er ca. 1 cm, blev der brugt en 1 cm tyk foemax.

Den firkantede metalramme blev brugt til at holde installationen sammen med skruer og kabelbindere, samtidig med at den samlede vægt og balance blev opretholdt. Hvis længden af de udsatte forbindelser er mere end den, når producenten prøver, er det tykkere bræt ineffektivt og andre strukturer anbefales.

For at lette brugerens oplevelse i øjenhøjde placeres den færdige installation på en støtte på cirka 2 m høj, men forsigtigheden er, at det er meget besværligt at installere det integrerede LED -modul med kontakten, så alle forbindelser skal fjernes. Vi klatrede op af stigen og forbandt modulet med installationen fastgjort på understøtningen.

Den vigtigste del af hele denne proces er at sikre, at arbejdet udføres sikkert og fuldt sikret for at sikre, at oplevelsen bliver mulig i et sikkert miljø

Der blev brugt i alt 10 arduino- og 50 LED-moduler, og fem LED-moduler blev tilsluttet pr. Arduino for mere effektiv og problemfri multi-tasking. Se vedhæftede plan for detaljer. Neopixel multi-tasking kodning ved hjælp af fuld switch i henhold til design diagrammet vil blive diskuteret detaljeret i det næste trin.

Trin 5: Arduino kodning og ledninger

Ledninger

• 50 moduler blev forbundet i henhold til layoutet i trin 4.
• Hvert modul var opdelt i 10 sæt med 50 moduler for at muliggøre multi-tasking og for at give en klar forbindelse.
• Som vist i sæt 1 -billedet ovenfor, blev fem moduler forbundet til en enkelt arduino, og neopixels 5v -pins blev bundet sammen for at tilslutte strømforsyningen.
• Neopixelernes og switches GND var også bundet sammen, og for at lette opfattelsen blev switchene sat i stifterne 2, 3, 4, 5, 6, og neopixel blev sat i stifterne 9, 10, 11, 12, 13.
• Skifterne og neopixel blev forbundet på henholdsvis 2-9, 3-10, 4-11, 5-12, 6-13 måder.
• Det skal bemærkes, at da forbindelserne til ledningerne er komplekse, og der er risiko for brand på grund af kortslutninger, blev det krympende rør opvarmet for at sikre, at de svage dele ikke brød.

Neopixel multi-tasking kodning med pull up switch

5 lys animationer (regntype, brusebadstype, gnistlyntype, poptype, uregelmæssig type)

#omfatte

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

enum mønster {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 픽셀 을 방향 을 설정 함*/ enum retning {FREM, BAGVEND};

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

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

/*변수 Interval 을 추가*/ usigneret langt interval; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 Farve1, Farve2 를 추가*/ uint32_t Farve1, Farve2; /*변수 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 = tilbagekald; }

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

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

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

sag THEATER_CHASE: TheaterChaseUpdate (); /*sag THEATER_CHASE 에서 나와라*/ pause;

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

sag COLOR_WIPE: ColorWipeUpdate (); /*sag COLOR_WIPE 에서 나와라*/ pause; /*case SCANNER 에서는 ScannerUpdate 를 실행 하라*/ case SCANNER: ScannerUpdate (); /*sag SCANNER 에서 나와라*/ pause;

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

sag FADE: FadeUpdate (); /*sag FADE 에서 나와라*/ pause;

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

case TWINKLE: TwinkleUpdate (); /*sag TWINKLE 에서 나와라*/ pause;

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

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

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

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

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

sag LIGHT: LightUpdate (); /*etui LIGHT 에서 나와라*/ pause;

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

sag BLOSSOM: BlossomUpdate (); /*etui BLOSSOM 에서 나와라*/ pause; }}}

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

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

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

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

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

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

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

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

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

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

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

/*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 를 설정*/ Color1 = color1; Farve2 = farve2; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void TheaterChase () 안에 입력 되는 dir = FREMVÆRD 과 같음*/ Direction = dir; }

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

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

/*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 을 설정*/ Farve1 = farve; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void ColorWipe () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; }

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

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

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

void Scanner (uint32_t color1, uint8_t interval) { /*실행 되는 패턴 은 SCANNER* / ActivePattern = SCANNER; /*시간 은 void Scanner () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*구동 갯수 는 총 갯수 에서 1 을 빼고 2 를 곱 해라*/ TotalSteps = (numPixels () - 1)*2; /*컬러 1 을 설정*/ Farve1 = farve1; /*인덱스 는 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 를 전체 구동 갯수 에서 인덱스 를 뺀값 과 같다 * / ellers hvis (i == TotalSteps - Indeks) {setPixelColor (i, Color1); } / *그 밖에는 i 를 디밍 시켜라 i 의 값 만큼 * / else {setPixelColor (i, DimColor (getPixelColor (i))); }} / *애니메이션 을 보여주는 함수 * / show (); Forøgelse (); }

/*Scanner 의 컬러 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 = trin; /*컬러 1, 2 를 설정*/ Color1 = color1; Farve2 = farve2; /*인덱스 는 0 으로 설정 함*/ Indeks = 0; /*방향 은 void Fade () 안에 입력 되는 dir = FORWARD 과 같음*/ Direction = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 rød 값 은 다음 과 같음* / uint8_t red = ((Red (Color1)*(TotalSteps - Index)) + (Red (Color2)*Index)) / TotalSteps; / * 변수 grøn 값 은 다음 과 같음 * / uint8_t green = ((Green (Color1) * (TotalSteps - Index)) + (Green (Color2) * Index)) / TotalSteps; / * 변수 blå 값 은 다음 과 같음 * / uint8_t blue = ((Blue (Color1) * (TotalSteps - Index)) + (Blue (Color2) * Index)) / TotalSteps; /*위 의 rød, grøn, blå 값 으로 컬러 를 셋팅/*/ ColorSet (farve (rød, grøn, blå)); / *애니메이션 을 보여주는 함수 */ show (); Forøgelse (); }

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

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

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

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

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

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

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

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

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

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

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

void Rainbowsparkle (uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 RAINBOWSPARKLE* / ActivePattern = RAINBOWSPARKLE; /*시간 은 void Rainbowsparkle () 안에 입력 되는 interval 과 같음*/ Interval = interval; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Indeks = 0; /*방향 은 void Rainbowsparkle () 안에 입력 되는 retning 과 같음*/ 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); } ellers {setPixelColor (i, tilfældig (255)); }} / *애니메이션 을 보여주는 함수 * / show (); Forøgelse (); } /*Meteor 의 시간 과 방향 을 입력* / void Meteor (uint32_t color1) { /*실행 되는 패턴 은 METEOR* / ActivePattern = METEOR; /*시간 설정*/ Interval = Interval; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Farve1 = farve1; Indeks = 0; }

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

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

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

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

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

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

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

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

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

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

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

/ *네오 픽셀 의 켜지 는 위치 와 색 을 지정 해주는/ */ void setAll (byte rød, byte grøn, byte blå) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, rød, grøn, blå); } at vise(); }

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

uint32_t DimColor (uint32_t farve) {// Shift R, G og B komponenter en bit til højre uint32_t dimColor = farve (rød (farve) >> 1, grøn (farve) >> 1, blå (farve) >> 1); returner dimColor; }

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

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

/*레드 값 을 불러 옴*/

uint8_t Rød (uint32_t farve) {return (farve >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Grøn (uint32_t farve) {return (farve >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t Blå (uint32_t farve) {return color & 0xFF; }

/*Rainbow 컬러 를 불러 옴*/

uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; hvis (WheelPos <85) {return Color (255 - WheelPos * 3, 0, WheelPos * 3); } ellers hvis (WheelPos <170) {WheelPos -= 85; returfarve (0, WheelPos * 3, 255 - WheelPos * 3); } ellers {WheelPos -= 170; returfarve (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

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

void strip1Complete (); void strip2Complete (); void 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, & 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 -knapStat [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 læsning [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 forsinkelse50 과 같음*/ usigneret lang debounceDelay = 50;

ugyldig opsætning () {

/*복잡 하게 저항 연결 이 필요 없도록 인풋 풀업 방식 의 버튼 설정 GN: GND - 5V (Opret forbindelse til pin -nummer)*/ for (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Serial.begin (9600); /*스트립 1 ~ 5 를 셋팅*/ strip1.begin (); strip2.begin (); strip3.begynd (); strip4.begin (); strip5.begynd ();

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

}

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

int tæller = 5; void loop () { /*버튼 수 보다 i 가 작 으면 i 를 증가 시키고* / for (int i = 0; i debounceDelay) {if (læsning ! = buttonState ) {buttonState = læsning ; buttonCounter ++; /*버튼 카운팅 이 위에서 설정 한 Max 값 5 를 넘으면 0 으로 초기화 시켜라.*/ If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = læser ; } /*모든 스트립 을 업데이트 함.* / Strip1. Update (); strip2. Update (); strip3. Update (); strip4. Update (); strip5. Update ();

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

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

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

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

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

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

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

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

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

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

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

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

// strip1 Fuldførelse Tilbagekald

void strip1Complete () {strip1. Color1 = strip1. Wheel (random (255)); strip1. Color2 = strip1. Wheel (tilfældig (255)); strip1. Index = 0; }

// strip2 Fuldførelse Tilbagekald

void strip2Complete () {strip2. Color1 = strip2. Wheel (random (255)); strip2. Color2 = strip2. Wheel (tilfældig (255)); strip2. Index = 0; }

// strip3 Gennemførelse Tilbagekald

void strip3Complete () {strip3. Color1 = strip3. Wheel (random (255)); strip3. Color2 = strip3. Wheel (tilfældig (255)); strip3. Index = 0; }

// strip4 Gennemførelse af tilbagekald

void strip4Complete () {strip4. Color1 = strip4. Wheel (random (255)); strip4. Color2 = strip4. Wheel (tilfældig (255)); strip4. Index = 0; }

// strip5 Gennemførelse af tilbagekald

void strip5Complete () {strip5. Color1 = strip5. Wheel (random (255)); strip5. Color2 = strip5. Wheel (tilfældig (255)); strip5. Index = 0; }

Trin 6: Resultat og fremstilling af film

Tak for din interesse i vores projekt, selvom det ikke er nok.