Pull the Light - Light Module Using Neopixel & Pull Up Switch: 6 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:23

Funksjoner i lysmodulen

• Arduino Uno
• Maskinvare og kabinett kjøpt fra internett
• Neopixel og strømforsyning lånt fra School of Informatics & Product Design
• Lysmodul styrt av strømforsyning
• Alle funksjoner styres via brukerens interaksjon
• Animasjonstyper av Neopixel -stripe: Regntype, Dusjtype, Gnistlyntype, Poptype, Uregelmessig type
• Trekkbryteren er koblet til Neopixel -stripen, og animasjonen endres når den trekkes med Neopixel -stripen

Trinn 1: Før vi begynner

Hei instruktører og produsenter.

Vi startet og interaktivt designprosjekt når det gjelder hva som ville skje hvis vi kunne føle følelsen av regn gjennom animasjon av lys. Jeg trodde at brukerens følsomhet ville bli maksimert gjennom et grensesnitt som trekker lys direkte.

La oss komme på jobb

Trinn 2: Nødvendige deler

Basert på en lysmodul

*** Neopiksler og strømforsyning ble brukt med støtte fra vår avdeling. ***

Elektronikk:

1. Arduino Uno
2. 3 fargetråd (svart, rød, hvilken som helst farge)
3. 3 -pinners kontakt (lenke til kjøp)
4. Trekk opp bryter 1 (lenke for kjøp)
5. krympende rør
6. WS2812b tilleggs -LED -stripe med 74 LED (Neopixel -stripe)*2
7. Strømforsyning (5V 350A) 1

*** 50 sett er nødvendig for Arduino, Pull -bryteren og NeoPixels. ***

Maskinvare:

1. Akrylstang 2t (10mm*1000mm) 1
2. Akrylplate 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Svart spray
5. Buntebånd
6. String
7. Hardboard
8. Rutenett

Trinn 3: Tilkobling og bygging av maskinvare

Først trenger vi akrylskjæringen for å lage en belysningsmodul.

• Som et middel til å oppleve lysets animasjon, tegne en belysningsmodul som er fikset ved å feste 74 lysdioder i form av en neopikselstrimmel på en 2 mm tykk akrylstang med et 1M område. Vi har produsert to typer belysningsmoduler: typisk lineær og spiral.
• For lineære typer kan de eksisterende neopikselstrimlene holdes og sikres, men spiraltyper krever manuell drift. Hver av de 74 LED -er er delt i stykker, festet til en spiralakryl og limt sammen med bly.

Fest Neopixel -stripen til akryl og fest hver stripe for å forhindre at den sprer seg av varme, eller bind den med en tynn fiskesnøre. Når det gjelder lineær type, måtte kulen trekkes på enden av modulen for å designe det estetiske utseendet, og vi avsluttet bordtennisballen med en svart spray. Deretter borte de et lite hull i bordtennisballen og koblet den med et tau. Den neste viktigste delen, bryteren og neopiksen, er koblet til som vist. Bryteren festes deretter til takhyllen.

Når det gjelder spiraltype, er det en risiko for at direkte trekking av spiralmodulen kan bryte akryl under trykk, så trekkdelen (inngangen) og modulen (utgangen) ble skilt. For å maksimere lysfallet ble moduler installert vertikalt i taket, lineære moduler ble festet til luften, spiraler ble festet direkte til taket. Og vi koblet bordtennisballen og bryteren til fiskesnoren slik at den kunne betjenes.

Akrylskjæringen som vist på tegningen ovenfor er nødvendig for å feste bryteren til hyllen. En 6 cm firkantet bryter er omtrent 5 mm tykk, med bryteren sentrert og et kabelbånd stukket gjennom hull på begge sider for å sikre bryteren godt. Et sirkulært hull i bunnen av midten avslører trekket på bryteren, under hvilken en tre -ledningskabel trekkes ut og kobles til kabelterminalen til modulen. Og på samme måte, gjennom et hull i de fire hjørnene, er hyllen og akryl festet med kabelbindere. Som beskrevet ovenfor er den lineære modulen koblet direkte til trekket, men spiralmodulen kobler tappen og bryteren separat.

Trinn 4: Lag med 50 lysmoduler

Vi har designet en brukeropplevelse for rikere lys ved å distribuere totalt 50 moduler

Vi hadde en hylle som var 1, 800 mm bred og 1, 200 mm lang, og vi koblet hver bryter og modul slik at du kunne oppleve regn- og regnmiljøet som vi opprinnelig planla, og vi hadde hver modul frittstående for å muliggjøre multi-tasking.

Avhengig av designtegningen ble det boret et rundt hull i foemaxen for å skjule installasjonen og for å sikre at det tilkoblede området til LED -modulen ikke er synlig. Siden avstanden fra akrylplaten til LED -modulforbindelsen der bryteren er festet er omtrent 1 cm, ble en 1 cm tykk foemax brukt.

Den firkantede metallrammen ble brukt til å holde installasjonen sammen med skruer og kabelbånd samtidig som den opprettholdt totalvekt og balanse. Hvis lengden på de eksponerte tilkoblingene er mer enn det når produsenten prøver, er det tykkere brettet ineffektivt og andre strukturer anbefales.

For å lette brukerens opplevelse i øyehøyde, er den fullførte installasjonen plassert på en støtte på omtrent 2 m høy, men forsiktigheten er at det er veldig tungvint å installere den innebygde LED -modulen med bryteren, så alle tilkoblinger bør fjernes. Vi klatret opp stigen og koblet modulen med installasjonen festet til støtten.

Den viktigste delen av hele denne prosessen er å sikre at arbeidet utføres sikkert og fullt sikret for å sikre at opplevelsen blir mulig i et trygt miljø

Totalt 10 arduino og 50 LED moduler ble brukt og fem LED moduler ble koblet til per arduino for mer effektiv og sømløs multi-tasking. Se vedlagte blåkopi for detaljer. Neopixel multi-tasking koding ved hjelp av full bryteren i henhold til designdiagrammet vil bli diskutert i detalj i neste trinn.

Trinn 5: Arduino koding og ledninger

Kabling

• 50 moduler ble koblet til i henhold til oppsettet i trinn 4.
• Hver modul ble delt inn i 10 sett med 50 moduler for å muliggjøre multi-tasking og for å gi en klar forbindelse.
• Som vist i sett 1 -bildet ovenfor, ble fem moduler koblet til en enkelt arduino, og 5v -pinnene på neopiksel ble bundet sammen for å koble til strømforsyningen.
• GND for neopikslene og bryterne ble også knyttet sammen, og for enkel oppfatning ble bryterne plugget inn i pinne 2, 3, 4, 5, 6 og neopikslene ble plugget inn i pinne 9, 10, 11, 12, 13.
• Bryterne og neopikslene ble koblet til henholdsvis 2-9, 3-10, 4-11, 5-12, 6-13 måter.
• Det skal bemerkes at siden forbindelsene til ledningene er komplekse og det er fare for brann på grunn av kortslutninger, ble det krympende røret oppvarmet for å sikre at de svake delene ikke brøt.

Neopixel multi-tasking koding med pull up switch

5 lys animasjon (regntype, dusjtype, gnist lyn type, pop type, uregelmessig type)

#inkludere

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

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

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

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

/*변수 Intervall 을 추가*/ usignert langt intervall; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 Color1, Color2 를 추가*/ uint32_t Color1, Color2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Indeks 를 추가*/ uint16_t Indeks;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void RainbowCycle (uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 RainbowCycle 임* / ActivePattern = RAINBOW_CYCLE; /*시간 은 void RainbowCycle () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*총 구동 갯수 는 255 임*/ TotalTrinn = 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 (); Inkrement (); }

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

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

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

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

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

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

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

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

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

void Scanner (uint32_t color1, uint8_t interval) { /*실행 되는 패턴 은 SCANNER* / ActivePattern = SCANNER; /*시간 은 void Scanner () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*구동 갯수 는 총 갯수 에서 1 을 빼고 2 를 곱 해라*/ TotalSteps = (numPixels () - 1)*2; /*컬러 1 을 설정*/ Color1 = color1; /*인덱스 는 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 (); Inkrement (); }

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

void Fade (uint32_t color1, uint32_t color2, uint16_t steps, uint8_t interval, direction dir = FORWARD) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 void Fade () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*구동 갯수 는 스텝 값임*/ TotalSteps = trinn; /*컬러 1, 2 를 설정*/ Color1 = color1; Farge2 = farge2; /*인덱스 는 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ønn 값 은 다음 과 같음 * / 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ønn, blå 값 으로 컬러 를 셋팅/*/ ColorSet (farge (rød, grønn, blå)); / *애니메이션 을 보여주는 함수 */ show (); Inkrement (); }

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

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 () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*컬러 1 를 설정*/ Color1 = color1; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Indeks = 0; }

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

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

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

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

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

void StarUpdate () { /*인덱스 와 컬러 를 셋팅* / setPixelColor (Index, Color1); forestilling(); /*변수 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 () 안에 입력 되는 intervall 과 같음*/ Intervall = intervall; /*총 구동 갯수 는 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 = tilfeldig (255); setPixelColor (i, c); } annet {setPixelColor (i, tilfeldig (255)); }} / *애니메이션 을 보여주는 함수 * / show (); Inkrement (); } /*Meteor 의 시간 과 방향 을 입력* / void Meteor (uint32_t color1) { /*실행 되는 패턴 은 METEOR* / ActivePattern = METEOR; /*시간 설정*/ Intervall = Intervall; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Color1 = color1; Indeks = 0; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/*레드 값 을 불러 옴*/

uint8_t Rød (uint32_t farge) {retur (farge >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Grønn (uint32_t farge) {retur (farge >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t Blå (uint32_t farge) {returfarge & 0xFF; }

/*Rainbow 컬러 를 불러 옴*/

uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; hvis (WheelPos <85) {returfarge (255 - WheelPos * 3, 0, WheelPos * 3); } annet hvis (WheelPos <170) {WheelPos -= 85; returfarge (0, WheelPos * 3, 255 - WheelPos * 3); } annet {WheelPos -= 170; returfarge (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

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

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 -knappStat [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 reading [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 forsinkelse50 과 같음*/ usignert lang debounceDelay = 50;

ugyldig oppsett () {

/*복잡 하게 저항 연결 이 필요 인풋 인풋 풀업 방식 의 버튼 GN GN: GND - 5V (Koble 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.begin (); strip4.begin (); strip5.begin ();

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

}

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

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

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

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

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

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

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

switch (buttonCounter [1]) {case 0: strip2. ActivePattern = STAR; strip2. Intervall = 50; strip2. TotalSteps = strip2.numPixels (); gå i stykker; sak 1: strip2. ActivePattern = RAINBOWSPARKLE; strip2. Intervall = 100; strip2. TotalSteps = strip2.numPixels (); gå i stykker; sak 2: strip2. ActivePattern = SKANNER; strip2. Intervall = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; gå i stykker; sak 3: strip2. ActivePattern = TWINKLE; strip2. Intervall = 5; strip2. TotalSteps = strip2.numPixels (); gå i stykker; sak 4: strip2. ActivePattern = METEOR; strip2. Intervall = 40; strip2. TotalSteps = strip2.numPixels (); gå i stykker; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [2]) {case 0: strip3. ActivePattern = STAR; strip3. Intervall = 50; strip3. TotalSteps = strip3.numPixels (); gå i stykker; sak 1: strip3. ActivePattern = RAINBOWSPARKLE; strip3. Intervall = 100; strip3. TotalSteps = strip3.numPixels (); gå i stykker; sak 2: strip3. ActivePattern = SKANNER; strip3. Intervall = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; gå i stykker; sak 3: strip3. ActivePattern = TWINKLE; strip3. Intervall = 5; strip3. TotalSteps = strip3.numPixels (); gå i stykker; sak 4: strip3. ActivePattern = METEOR; strip3. Intervall = 25; strip3. TotalSteps = strip3.numPixels (); gå i stykker; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [3]) {case 0: strip4. ActivePattern = STAR; strip4. Intervall = 50; strip4. TotalSteps = strip4.numPixels (); gå i stykker; sak 1: strip4. ActivePattern = RAINBOWSPARKLE; strip4. Intervall = 100; strip4. TotalSteps = strip4.numPixels (); gå i stykker; sak 2: strip4. ActivePattern = SKANNER; strip4. Intervall = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; gå i stykker; sak 3: strip4. ActivePattern = TWINKLE; strip4. Interval = 5; strip4. TotalSteps = strip4.numPixels (); gå i stykker; sak 4: strip4. ActivePattern = METEOR; strip4. Intervall = 25; strip4. TotalSteps = strip4.numPixels (); gå i stykker; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [4]) {case 0: strip5. ActivePattern = STAR; strip5. Intervall = 50; strip5. TotalSteps = strip5.numPixels (); gå i stykker; sak 1: strip5. ActivePattern = RAINBOWSPARKLE; strip5. Interval = 100; strip5. TotalSteps = strip5.numPixels (); gå i stykker; sak 2: strip5. ActivePattern = SKANNER; strip5. Intervall = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; gå i stykker; sak 3: strip5. ActivePattern = TWINKLE; strip5. Intervall = 5; strip5. TotalSteps = strip5.numPixels (); gå i stykker; sak 4: strip5. ActivePattern = METEOR; strip5. Intervall = 25; strip5. TotalSteps = strip5.numPixels (); gå i stykker; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Fullføring tilbakeringing

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

// strip2 Fullføring tilbakeringing

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

// strip3 Fullføring tilbakeringing

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

// strip4 Fullføring tilbakeringing

void strip4Complete () {strip4. Color1 = strip4. Wheel (tilfeldig (255)); strip4. Color2 = strip4. Wheel (tilfeldig (255)); strip4. Index = 0; }

// strip5 Fullføring tilbakeringing

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

Trinn 6: Resultat og film

Takk for interessen for prosjektet vårt, selv om det ikke er nok.