Trageți de lumină - Modul de lumină folosind comutatorul Neopixel & Pull Up: 6 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Caracteristicile modulului Light

• Arduino Uno
• Hardware și incinte achiziționate de pe internet
• Neopixel și sursă de energie împrumutată de la Școala de informatică și design de produs
• Modul de lumină controlat de sursa de alimentare
• Toate funcțiile controlate prin interacțiunea utilizatorilor
• Tipuri de animație de bandă Neopixel: tip ploaie, tip duș, tip fulger scânteie, tip pop, tip neregulat
• Comutatorul de tragere este conectat la banda Neopixel și animația se schimbă când se trage banda Neopixel

Pasul 1: Înainte de a începe

Bună, instructabili și producători.

Am început un proiect de design interactiv în ceea ce privește ceea ce s-ar întâmpla dacă am putea simți emoția ploii prin animația luminii. Am crezut că sensibilitatea utilizatorului va fi maximizată printr-o interfață care atrage lumina direct.

Să nu ne apucăm de treabă

Pasul 2: Piese necesare

Bazat pe un modul de lumină

*** Neopixeli și sursa de alimentare au fost utilizați cu sprijinul departamentului nostru. ***

Electronică:

1. Arduino Uno
2. Sârmă cu 3 culori (negru, roșu, orice culoare)
3. Conector 3 pini (Link pentru cumpărare)
4. Comutator 1 în sus (Link către cumpărare)
5. tub de micșorare
6. Benzi LED cu rezoluție WS2812b cu 74 LED (benzi Neopixel) * 2
7. Alimentare (5V 350A) 1

*** Sunt necesare 50 de seturi pentru Arduino, Pull Switch și NeoPixels. ***

Hardware:

1. Bara acrilică 2t (10mm * 1000mm) 1
2. Placă acrilică 5t (60mm * 60mm)
3. Foemax 10t (1200mm * 1800mm) 1
4. Spray negru
5. Cravată de cablu
6. Şir
7. Hardboard
8. Placă de rețea

Pasul 3: Conectivitate și construirea hardware-ului

În primul rând, avem nevoie de tăierea acrilică pentru a crea un modul de iluminare.

• Ca mijloc de a experimenta animația luminii, proiectați un modul de iluminare care se fixează prin atașarea a 74 de LED-uri sub forma unei benzi de neopixel pe o bară acrilică de 2 mm grosime cu o zonă de 1 M. Am produs două tipuri de module de iluminat: liniare tipice și spirale.
• Pentru tipurile liniare, benzile neopixel existente pot fi ținute și securizate, dar tipurile spiralate necesită funcționare manuală. Fiecare dintre cele 74 de LED-uri este împărțit în bucăți, atașat la o spirală acrilică și lipit împreună cu plumb.

Atașați banda Neopixel la acril și fixați fiecare bandă pentru a preveni răspândirea prin căldură sau legați cu o linie subțire de pescuit. În cazul tipului liniar, sfera care trebuia trasă pe capătul modulului a fost instalată pentru a proiecta aspectul estetic și am terminat mingea de ping pong cu un spray negru. Apoi au forat o mică gaură în mingea de ping pong și au conectat-o cu o frânghie. Următoarea parte importantă, comutatorul și neopixelul, este conectată așa cum se arată. Întrerupătorul este apoi fixat pe raftul de tavan.

În cazul tipului spiralat, există riscul ca tragerea directă a modulului spiralat să rupă acrilicul sub presiune, astfel încât secțiunea de tragere (intrare) și modulul (ieșire) au fost separate. Pentru a maximiza căderea luminii, modulele au fost instalate vertical pe tavan, modulele liniare au fost fixate pe aer, spiralele au fost fixate direct pe tavan. Și am conectat mingea de ping pong și comutatorul la linia de pescuit pentru a putea fi acționată.

Tăierea acrilică așa cum se arată în desenul de mai sus este necesară pentru a fixa comutatorul pe raft. Un comutator în formă pătrată de 6 cm are o grosime de aproximativ 5 mm, cu comutatorul centrat și o legătură de cablu introdusă prin găuri de ambele părți pentru a fixa ferm comutatorul. O gaură circulară în partea de jos a centrului expune tracțiunea comutatorului, sub care este extras un cablu cu trei fire și conectat la terminalul de cablu al modulului. Și în mod similar, printr-o gaură în cele patru colțuri, raftul și acrilul sunt fixate cu legături de cablu. Așa cum s-a descris mai sus, modulul liniar este conectat direct la tracțiune, dar modulul spiralat conectează pinul și comutatorul separat.

Pasul 4: Creați folosind 50 de module de lumină

Am proiectat o experiență de utilizare pentru o lumină mai bogată, implementând un total de 50 de module

Aveam un raft care avea o lățime de 1, 800 mm și o lungime de 1, 200 mm și am conectat fiecare comutator și modul, astfel încât să puteți experimenta ploaia și mediul de ploaie pe care le-am planificat inițial și am avut fiecare modul în sine pentru a permite multi-tasking.

În funcție de desenul de proiectare, o gaură rotundă a fost forată în foemax pentru a ascunde instalația și pentru a vă asigura că zona conectată a modulului LED nu este vizibilă. Deoarece distanța de la placa acrilică la conexiunea modulului LED unde este atașat comutatorul este de aproximativ 1cm, s-a folosit un foemax gros de 1cm.

Cadrul metalic pătrat a fost utilizat pentru a ține instalația împreună cu șuruburi și legături de cablu, menținând în același timp greutatea și echilibrul total. Dacă lungimea conexiunilor expuse este mai mare decât atunci când producătorul încearcă, placa mai groasă este ineficientă și se recomandă alte structuri.

Pentru a facilita experiența utilizatorului la nivelul ochilor, instalarea finalizată este plasată pe un suport de aproximativ 2 m înălțime, dar precauția este că este foarte greoaie să instalați modulul LED încorporat cu comutatorul, astfel încât toate conexiunile ar trebui eliminate. Am urcat pe scară și am conectat modulul cu instalația fixată pe suport.

Cea mai importantă parte a întregului proces este asigurarea faptului că lucrarea este realizată în siguranță și pe deplin securizată pentru a se asigura că experiența este posibilă într-un mediu sigur

Au fost utilizate un total de 10 module arduino și 50 de LED-uri și cinci module LED-uri au fost conectate pe arduino pentru multitasking mai eficient și mai uniform. Consultați planul atașat pentru detalii. Codificarea multi-tasking Neopixel folosind comutatorul complet conform schemei de proiectare va fi discutată în detaliu în pasul următor.

Pasul 5: Arduino Coding & Wiring

Cablare

• 50 de module au fost conectate în conformitate cu aspectul pasului 4.
• Fiecare modul a fost împărțit în 10 seturi de 50 de module pentru a permite multi-tasking și pentru a oferi o conexiune clară.
• Așa cum se arată în imaginea din setul 1 de mai sus, cinci module au fost conectate la un singur arduino, iar pinii de 5v ai neopixelului au fost legați simultan pentru a conecta sursa de alimentare.
• GND-ul neopixelelor și comutatoarele au fost, de asemenea, legate între ele și, pentru ușurința percepției, comutatoarele au fost conectate la pinii 2, 3, 4, 5, 6, iar neopixelii au fost conectați la pinii 9, 10, 11, 12, 13.
• Comutatoarele și neopixelii au fost conectate în 2-9, 3-10, 4-11, 5-12, respectiv 6-13 căi.
• Trebuie remarcat faptul că, deoarece conexiunile liniilor sunt complexe și există riscul de incendiu din cauza scurtcircuitelor, tubul de contracție a fost încălzit pentru a se asigura că părțile slabe nu se rup.

Codificare multi-tasking Neopixel cu comutator pull-up

5 animații luminoase (tip ploaie, tip duș, tip fulger scânteie, tip pop, tip neregulat)

#include

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

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

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

clasa NeoPatterns: public Adafruit_NeoPixel {/ * 패턴 을 추가 하고 업데이트 하기 위한 함수 * / public: model ActivePattern; / * 클레스 함수 에 패턴 의 방향 을 입력 * / direcția Direcție;

/ * 변수 Interval 을 추가 * / nesemnat Interval lung; / * 변수 lastUpdate 를 추가 * / unsigned long lastUpdate; / * 변수 Color1, Color2 를 추가 * / uint32_t Color1, Color2; / * 변수 TotalSteps 를 추가 * / uint16_t TotalSteps; / * 변수 Index 를 추가 * / uint16_t Index;

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

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

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

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

case THEATER_CHASE: TheaterChaseUpdate (); / * caz THEATER_CHASE 에서 나와라 * / pauză;

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

carcasă COLOR_WIPE: ColorWipeUpdate (); / * caz COLOR_WIPE 에서 나와라 * / pauză; / * case SCANNER 에서는 ScannerUpdate 를 실행 하라 * / case SCANNER: ScannerUpdate (); / * caz SCANNER 에서 나와라 * / pauză;

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

caz FADE: FadeUpdate (); / * caz FADE 에서 나와라 * / pauză;

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

caz TWINKLE: TwinkleUpdate (); / * caz TWINKLE 에서 나와라 * / pauză;

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

caz STAR: StarUpdate (); / * caz STAR 에서 나와라 * / pauză;

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

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

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

carcasa LIGHT: LightUpdate (); / * carcasă LUMINĂ 에서 나와라 * / pauză;

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

caz BLOSSOM: BlossomUpdate (); / * caz BLOSSOM 에서 나와라 * / pauză; }}}

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

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

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

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

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

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

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

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

void RainbowCycle (interval uint8_t, direcția dir = FORWARD) {/ * 실행 되는 패턴 은 RainbowCycle 임 * / ActivePattern = RAINBOW_CYCLE; / * 시간 은 void RainbowCycle () 안에 입력 되는 interval 과 같음 * / Interval = interval; / * 총 구동 갯수 는 255 임 * / TotalSteps = 255; / * 인덱스 는 0 으로 설정 함 * / Index = 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 (); Creştere(); }

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

void TheaterChase (uint32_t color1, uint32_t color2, uint8_t interval, direcția dir = FORWARD) {/ * 실행 되는 패턴 은 RTHEATER_CHASE * / ActivePattern = THEATER_CHASE; / * 시간 은 void TheaterChase () 안에 입력 되는 interval 과 같음 * / Interval = interval; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); / * 컬러 1, 2 를 설정 * / Culoare1 = culoare1; Culoare2 = culoare2; / * 인덱스 는 0 으로 설정 함 * / Index = 0; / * 방향 은 void TheaterChase () 안에 입력 되는 dir = FORWARD 과 같음 * / Direction = dir; }

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

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

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

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

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

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

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

/ * 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 = pași; / * 컬러 1, 2 를 설정 * / Culoare1 = culoare1; Culoare2 = culoare2; / * 인덱스 는 0 으로 설정 함 * / Index = 0; / * 방향 은 void Fade () 안에 입력 되는 dir = FORWARD 과 같음 * / Direction = dir; } / * FadeUpdate 를 업데이트 했을 경우 * / void FadeUpdate () {/ * 변수 roșu 값 은 다음 과 같음 * / uint8_t roșu = ((Roșu (Color1) * (TotalSteps - Index)) + (Roșu (Color2) * Index)) / TotalSteps; / * 변수 verde 값 은 다음 과 같음 * / uint8_t verde = ((Verde (Color1) * (TotalSteps - Index)) + (Green (Color2) * Index)) / TotalSteps; / * 변수 albastru 값 은 다음 과 같음 * / uint8_t albastru = ((Albastru (Color1) * (TotalSteps - Index)) + (Blue (Color2) * Index)) / TotalSteps; / * 위 의 roșu, verde, albastru 값 으로 컬러 를 셋팅 함 * / ColorSet (Color (roșu, verde, albastru)); / * 애니메이션 을 보여주는 함수 * / show (); Creştere(); }

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

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 를 설정 * / Color1 = color1; / * 총 구동 갯수 는 numPixels 갯수 임 * / TotalSteps = numPixels (); Index = 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 (); Creştere(); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/ * 네오 픽셀 의 켜지 는 위치 와 색 을 지정 해주는 함수 * / void setAll (octet roșu, octet verde, octet albastru) {pentru (int i = 0; i <numPixels (); i ++) {setPixelColor (i, roșu, verde albastru); } spectacol(); }

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

uint32_t DimColor (uint32_t color) {// Shift R, G and B components one bit to the right uint32_t dimColor = Culoare (Roșu (culoare) >> 1, Verde (culoare) >> 1, Albastru (culoare) >> 1); returnează dimColor; }

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

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

/ * 레드 값 을 불러 옴 * /

uint8_t Roșu (uint32_t culoare) {return (culoare >> 16) & 0xFF; } / * 그린 값 을 불러 옴 * / uint8_t Verde (uint32_t culoare) {return (culoare >> 8) & 0xFF; } / * 블루 값 을 불러 옴 * / uint8_t Albastru (uint32_t color) {return color & 0xFF; }

/ * Rainbow 컬러 를 불러 옴 * /

uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return Culoare (255 - WheelPos * 3, 0, WheelPos * 3); } else if (WheelPos <170) {WheelPos - = 85; return Culoare (0, WheelPos * 3, 255 - WheelPos * 3); } else {WheelPos - = 170; return Color (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 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 reading [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; / * 모든 버튼 핀 을 읽는 시간 간격 은 delay50 과 같음 * / unsigned long debounceDelay = 50;

configurare nulă () {

/ * 복잡 하게 저항 연결 이 필요 없도록 인풋 풀업 방식 의 버튼 설정: GND - 5V (Conectare la numărul Pin) * / pentru (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 임 * /

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

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

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

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

caz 0: strip1. ActivePattern = BLOSSOM; / * 해당 애니메이션 의 시간 을 설정 * / strip1. Interval = 20; / * 구동 되는 네오 픽셀 의 갯수 를 설정 * / strip1. TotalSteps = strip1.numPixels (); pauză; / * 두번째 버튼 을 활동 시키면 구동 되는 애니메이션 * / cazul 1: strip1. ActivePattern = RAINBOWSPARKLE; strip1. Interval = 50; strip1. TotalSteps = strip1.numPixels (); pauză; / * 세번째 버튼 을 활동 시키면 구동 되는 애니메이션 * / cazul 2: strip1. ActivePattern = SCANNER; strip1. Interval = 10; strip1. TotalSteps = (strip1.numPixels () - 1) * 2; pauză; / * 네번째 버튼 을 활동 시키면 구동 되는 애니메이션 * / cazul 3: strip1. ActivePattern = TWINKLE; strip1. Interval = 1; strip1. TotalSteps = strip1.numPixels (); pauză; / * 다섯 번째 버튼 을 활동 시키면 구동 되는 애니메이션 * / cazul 4: strip1. ActivePattern = METEOR; strip1. Interval = 10; strip1. TotalSteps = strip1.numPixels (); pauză; } 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 (); pauză; cazul 1: strip2. ActivePattern = RAINBOWSPARKLE; strip2. Interval = 100; strip2. TotalSteps = strip2.numPixels (); pauză; cazul 2: strip2. ActivePattern = SCANNER; strip2. Interval = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; pauză; caz 3: strip2. ActivePattern = TWINKLE; strip2. Interval = 5; strip2. TotalSteps = strip2.numPixels (); pauză; cazul 4: strip2. ActivePattern = METEOR; strip2. Interval = 40; strip2. TotalSteps = strip2.numPixels (); pauză; } 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 (); pauză; cazul 1: strip3. ActivePattern = RAINBOWSPARKLE; strip3. Interval = 100; strip3. TotalSteps = strip3.numPixels (); pauză; cazul 2: strip3. ActivePattern = SCANNER; strip3. Interval = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; pauză; caz 3: strip3. ActivePattern = TWINKLE; strip3. Interval = 5; strip3. TotalSteps = strip3.numPixels (); pauză; cazul 4: strip3. ActivePattern = METEOR; strip3. Interval = 25; strip3. TotalSteps = strip3.numPixels (); pauză; } 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 (); pauză; cazul 1: strip4. ActivePattern = RAINBOWSPARKLE; strip4. Interval = 100; strip4. TotalSteps = strip4.numPixels (); pauză; cazul 2: strip4. ActivePattern = SCANNER; strip4. Interval = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; pauză; caz 3: strip4. ActivePattern = TWINKLE; strip4. Interval = 5; strip4. TotalSteps = strip4.numPixels (); pauză; cazul 4: strip4. ActivePattern = METEOR; strip4. Interval = 25; strip4. TotalSteps = strip4.numPixels (); pauză; } 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 (); pauză; cazul 1: strip5. ActivePattern = RAINBOWSPARKLE; strip5. Interval = 100; strip5. TotalSteps = strip5.numPixels (); pauză; cazul 2: strip5. ActivePattern = SCANNER; strip5. Interval = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; pauză; caz 3: strip5. ActivePattern = TWINKLE; strip5. Interval = 5; strip5. TotalSteps = strip5.numPixels (); pauză; caz 4: strip5. ActivePattern = METEOR; strip5. Interval = 25; strip5. TotalSteps = strip5.numPixels (); pauză; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Completare apel invers

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

// strip2 Completare apel invers

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

// strip3 Completare apel invers

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

// strip4 Completare apel invers

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

// strip5 Completare apel invers

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

Pasul 6: Rezultatul și realizarea filmului

Vă mulțumim pentru interesul acordat proiectului nostru, deși nu este suficient.