Pull the Light - Modulo luce utilizzando Neopixel e interruttore Pull Up: 6 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Caratteristiche del modulo Luce

• Arduino Uno
• Hardware e custodia acquistati da Internet
• Neopixel e alimentatore presi in prestito dalla School of Informatics & Product Design
• Modulo luce controllato da alimentatore
• Tutte le funzioni controllate tramite l'interazione degli utenti
• Tipi di animazione della striscia Neopixel: tipo pioggia, tipo doccia, tipo fulmine scintilla, tipo pop, tipo irregolare
• L'interruttore pull up è collegato alla striscia Neopixel e l'animazione cambia quando viene tirata la striscia Neopixel

Passaggio 1: prima di iniziare

Ciao Instructables e Makers.

Abbiamo avviato un progetto di design interattivo in termini di cosa accadrebbe se potessimo provare l'emozione della pioggia attraverso l'animazione della luce. Ho pensato che la sensibilità dell'utente sarebbe stata massimizzata attraverso un'interfaccia che attiri direttamente la luce.

Mettiamoci al lavoro

Passaggio 2: parti necessarie

Basato su un modulo luce

***Neopixel e alimentatore sono stati utilizzati con il supporto del nostro dipartimento.***

Elettronica:

1. Arduino Uno
2. Cavo a 3 colori (nero, rosso, qualsiasi colore)
3. Connettore a 3 pin (Link per acquistare)
4. Pull up switch 1 (Link per acquistare)
5. tubo termoretraibile
6. Striscia LED indirizzabile WS2812b con 74 LED (striscia Neopixel)*2
7. Alimentazione (5V 350A) 1

***Sono necessari 50 set per Arduino, Pull Switch e NeoPixel.***

Hardware:

1. Barra acrilica 2t (10mm*1000mm) 1
2. Pannello acrilico 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Spruzzo nero
5. Fascetta
6. Corda
7. Pannello rigido
8. Scheda griglia

Passaggio 3: connettività e creazione dell'hardware

Innanzitutto, abbiamo bisogno del taglio acrilico per realizzare un modulo di illuminazione.

• Come mezzo per sperimentare l'animazione della luce, disegna un modulo di illuminazione che viene fissato attaccando 74 LED sotto forma di una striscia di neopixel su una barra acrilica spessa 2 mm con un'area di 1 M. Abbiamo prodotto due tipologie di moduli luminosi: tipici lineari ea spirale.
• Per i tipi lineari, le strisce neopixel esistenti possono essere trattenute e fissate, ma i tipi a spirale richiedono l'operazione manuale. Ciascuno dei 74 LED è diviso in pezzi, attaccato a una spirale in acrilico e legato insieme con il piombo.

Attacca la striscia Neopixel all'acrilico e fissa ogni striscia per evitare che si diffonda a causa del calore, oppure legala con una lenza sottile. Nel caso di tipo lineare, è stata installata la sfera da tirare sull'estremità del modulo per disegnare l'aspetto estetico e abbiamo rifinito la pallina da ping pong con uno spray nero. Quindi hanno praticato un piccolo foro nella pallina da ping pong e l'hanno collegata con una corda. La parte successiva più importante, l'interruttore e il neopixel, è collegata come mostrato. L'interruttore viene quindi fissato al ripiano del soffitto.

Nel caso del tipo a spirale, c'è il rischio che la trazione diretta del modulo a spirale possa rompere l'acrilico sotto pressione, quindi la sezione di trazione (Input) e il modulo (Output) sono stati separati. Per massimizzare la caduta della luce, i moduli sono stati installati verticalmente sul soffitto, i moduli lineari sono stati fissati all'aria, le spirali sono state fissate direttamente al soffitto. E abbiamo collegato la pallina da ping pong e l'interruttore alla lenza in modo che potesse essere azionato.

Il taglio dell'acrilico come mostrato nel disegno sopra è necessario per fissare l'interruttore allo scaffale. Un interruttore di forma quadrata da 6 cm ha uno spessore di circa 5 mm, con l'interruttore centrato e una fascetta per cavi inserita attraverso i fori su entrambi i lati per fissare saldamente l'interruttore. Un foro circolare nella parte inferiore del centro espone la trazione dell'interruttore, al di sotto del quale viene estratto un cavo a tre fili e collegato al terminale del cavo del modulo. E allo stesso modo, attraverso un foro nei quattro angoli, la mensola e l'acrilico sono fissati con fascette. Come descritto sopra, il modulo lineare è collegato direttamente al pull, ma il modulo a spirale collega il pin e l'interruttore separatamente.

Passaggio 4: creare utilizzando 50 moduli luminosi

Abbiamo progettato un'esperienza utente per una luce più ricca distribuendo un totale di 50 moduli

Avevamo uno scaffale largo 1.800 mm e lungo 1.200 mm e abbiamo collegato ogni interruttore e modulo in modo che tu potessi sperimentare l'ambiente pioggia e pioggia che avevamo inizialmente pianificato, e ogni modulo era indipendente per consentire il multitasking.

A seconda del disegno di progetto, nel foemax è stato praticato un foro rotondo per nascondere l'installazione e per garantire che l'area collegata del modulo LED non sia visibile. Poiché la distanza dalla scheda acrilica alla connessione del modulo LED a cui è collegato l'interruttore è di circa 1 cm, è stato utilizzato un foemax di 1 cm di spessore.

Il telaio quadrato in metallo è stato utilizzato per tenere insieme l'installazione con viti e fascette per cavi, mantenendo il peso e l'equilibrio complessivi. Se la lunghezza delle connessioni esposte è superiore a quella del produttore, il pannello più spesso è inefficiente e si consigliano altre strutture.

Per facilitare l'esperienza dell'utente a livello degli occhi, l'installazione completata viene posizionata su un supporto di circa 2 m di altezza, ma l'attenzione è che è molto ingombrante installare il modulo LED integrato con l'interruttore, quindi tutte le connessioni dovrebbero essere rimosse. Siamo saliti sulla scala e abbiamo collegato il modulo con l'installazione fissata sul supporto.

La parte più importante di questo intero processo è garantire che il lavoro venga svolto in modo sicuro e completamente protetto per garantire che l'esperienza sia resa possibile in un ambiente sicuro

Sono stati utilizzati un totale di 10 moduli LED arduino e 50 e sono stati collegati cinque moduli LED per arduino per un multi-tasking più efficiente e senza interruzioni. Vedere il progetto allegato per i dettagli. La codifica multi-tasking Neopixel che utilizza l'interruttore completo secondo lo schema di progettazione sarà discussa in dettaglio nel passaggio successivo.

Passaggio 5: codifica e cablaggio Arduino

Cablaggio

• 50 moduli sono stati collegati secondo il layout del passaggio 4.
• Ogni modulo è stato suddiviso in 10 set da 50 moduli per consentire il multitasking e fornire una connessione chiara.
• Come mostrato nell'immagine del set 1 sopra, cinque moduli sono stati collegati a un singolo arduino e i pin 5v del neopixel sono stati collegati insieme per collegare l'alimentatore.
• Anche il GND dei neopixel e gli interruttori sono stati collegati insieme e, per facilità di percezione, gli interruttori sono stati collegati ai pin 2, 3, 4, 5, 6 e i neopixel ai pin 9, 10, 11, 12, 13.
• Gli interruttori e i neopixel sono stati collegati rispettivamente in 2-9, 3-10, 4-11, 5-12, 6-13 modi.
• Da notare che poiché i collegamenti delle linee sono complessi e vi è rischio di incendio per cortocircuito, il tubo termoretraibile è stato riscaldato per garantire che le parti deboli non si rompessero.

Codifica multi-tasking Neopixel con interruttore pull up

5 animazioni luminose (tipo pioggia, tipo doccia, tipo fulmine scintilla, tipo pop, tipo irregolare)

#includere

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

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

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

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

/*변수 Interval을 추가*/ unsigned long Interval; /*변수 lastUpdate를 추가*/ unsigned long lastUpdate; /*변수 Colore1, Colore2를 추가*/ uint32_t Colore1, Colore2; /*변수 TotalSteps를 추가*/ uint16_t TotalSteps; /*변수 Indice를 추가*/ uint16_t Indice;

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

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

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

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

case THEATER_CHASE: TheaterChaseUpdate(); /*case THEATER_CHASE에서 나와라*/ break;

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

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

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

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

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

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

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

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

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

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

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

case LUCE: LightUpdate(); /*case LIGHT에서 나와라*/ break;

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

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

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

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

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

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

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

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

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

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

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

/*Inseguimento a teatro의 컬러와 시간 방향을 입력*/

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

/*Inseguimento a teatro를 업데이트했을 경우*/

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

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

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

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

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

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

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

/*Aggiornamento scanner를 업데이트했을 경우*/

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(); Incremento(); }

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

void Fade(uint32_t color1, uint32_t color2, uint16_t step, uint8_t interval, direction dir = FORWARD){ /*실행되는 패턴은 FADE*/ ActivePattern = FADE; /*시간은 void Fade()안에 입력되는 intervallo과 같음*/ Interval = intervallo; /*구동갯수는 스텝값임*/ TotalStes = passi; /*컬러 1, 2를 설정*/ Colore1 = colore1; Colore2 = colore2; /*인덱스는 0으로 설정함*/ Indice = 0; /*방향은 void Fade()안에 입력되는 dir = FORWARD과 같음*/ Direction = dir; } /*FadeUpdate를 업데이트했을 경우*/ void FadeUpdate(){ /*변수 red값은 다음과 같음*/ uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / Totale passi; /*변수 green값은 다음과 같음*/ uint8_t green = ((Green(Color1) * (TotalSteps - Index)) + (Green(Color2) * Index)) / TotalSteps; /*변수 blue값은 다음과 같음*/ uint8_t blue = ((Blue(Color1) * (TotalSteps - Index)) + (Blue(Color2) * Index)) / TotalSteps; /*위의 rosso, verde, blu 값으로 컬러를 셋팅함*/ ColorSet(Color(rosso, verde, blu)); /*애니메이션을 보여주는 함수 */ mostra(); Incremento(); }

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

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

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

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

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

void TwinkleUpdate(){ /*모든 네오픽셀의 컬러를 0으로 셋팅*/ setAll(0, 0, 0); /*변수 Pixel은 random 74*/ int Pixel = random(74); /*casuale 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); /*애니메이션을 보여주는 함수 */ mostra(); /*랜덤하게 끄는 함수 */ setPixelColor(Pixel, 0, 0, 0); /*애니메이션을 보여주는 함수 */ mostra(); Incremento(); }

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

void Star(uint32_t color1){ /*실행되는 패턴은 STELLA*/ ActivePattern = STELLA; /*시간은 asterisco vuoto()안에 입력되는 intervallo과 같음*/ Intervallo = Intervallo; /*총 구동갯수는 numPixels갯수임*/ TotalSteps = numPixels(); /*컬러 1을 설정*/ Colore1 = colore1; Indice = 0; }

/*Aggiornamento Stella 업데이트했을 경우*/

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

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

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

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

void RainbowsparkleUpdate(){ /*변수 i가 0이고 구동 갯수보다 작으면 i값을 증가하는데*/ for (int i = 0; i < numPixels(); i++){ /*변수 i가 0이고 구동 갯수보다 작으면 i값을 증가하는데*/ if ((i + Indice) % 2 == 0){ uint32_t c = random(255); setPixelColor(i, c); } else{ setPixelColor(i, random(255)); } } /*애니메이션을 보여주는 함수 */ show(); Incremento(); } /*Meteor의 시간과 방향을 입력*/ void Meteor(uint32_t color1){ /*실행되는 패턴은 METEOR*/ ActivePattern = METEOR; /*시간 설정*/ Intervallo = Intervallo; /*총 구동갯수는 numPixels갯수에서 1일뺀 후, *2를 한것과 같음*/ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 설정*/ Colore1 = colore1; Indice = 0; }

/*Aggiornamento Meteor 업데이트했을 경우*/

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(); Incremento(); }

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

void Light(uint32_t color1){ /*실행되는 패턴은 LIGHT*/ ActivePattern = LIGHT; /*시간 설정*/ Intervallo = Intervallo; /*총 구동갯수는 numPixels갯수에서 1일뺀 후, *2를 한것과 같음*/ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 설정*/ Colore1 = colore1; Indice = 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(); Incremento(); }

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

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

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

/*네오픽셀의 켜지는 위치와 색을 지정해주는 함수 */ void setAll(byte red, byte green, byte blue) { for(int i = 0; i < numPixels(); i++) { setPixelColor(i, red, verde blu); } mostrare(); }

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

uint32_t DimColor(uint32_t color){ // Sposta i componenti R, G e B di un bit a destra uint32_t dimColor = Color(Red(color) >> 1, Green(color) >> 1, Blue(color) >> 1); return dimColor; }

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

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

/*레드값을 불러옴*/

uint8_t Rosso(uint32_t colore){ return (colore >> 16) & 0xFF; } /*그린값을 불러옴*/ uint8_t Green(uint32_t color){ return (color >> 8) & 0xFF; } /*블루값을 불러옴*/ uint8_t Blue(uint32_t color){ return color & 0xFF; }

/*Arcobaleno 컬러를 불러옴*/

uint32_t Wheel(byte WheelPos){ WheelPos = 255 - WheelPos; if (WheelPos < 85){ return Color(255 - WheelPos * 3, 0, WheelPos * 3); } else if (PosRuota < 170){ PosRuota -= 85; return Color(0, WheelPos * 3, 255 - WheelPos * 3); } else{ PosizioneRuota -= 170; return Color(WheelPos * 3, 255 - WheelPos * 3, 0); } } };

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

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

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

#define NUMPIXELS 74 /*사용하는 버튼의 갯수 설정*/ #define B_NUM 5 /*Importa striscia1~5까지, 갯수는 74개 스트립 연결핀은 striscia1은 8 ~ striscia5까지12*/ NeoPatterns striscia1(74, 8, NEO_GRB + NEO_KHZ800, &strip1Completo); 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 pulsanteContatoreMax = 5; /*모든 버튼핀을 읽일수있도록 변수 추가*/ lettura int[B_NUM]; unsigned long lastDebounceTime[B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼핀을 읽는 시간간격은 delay50과 같음*/ unsigned long debounceDelay = 50;

void setup(){

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

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

/////INTERRUTTORE_2//////////////////////////////////////////// ///////////////////////////////////////////////// /////////////////////////////////////////

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

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

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

/////INTERRUTTORE_3//////////////////////////////////////////// ///////////////////////////////////////////////// ////////////////////////////////////////

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

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

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

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

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

/////INTERRUTTORE_6//////////////////////////////////////////// ///////////////////////////////////////////////// /////////////////////////////////////////

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

// Richiamata completamento strip1

void strip1Complete(){ strip1. Color1 = strip1. Wheel(random(255)); striscia1. Colore2 = striscia1. Ruota(random(255)); striscia1. Indice = 0; }

// Richiamata completamento strip2

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

// Richiamata completamento strip3

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

// Richiamata completamento strip4

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

// Richiamata completamento strip5

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

Passaggio 6: risultato e realizzazione del film

Grazie per il tuo interesse nel nostro progetto anche se non è abbastanza.