Pull the Light - Lichtmodul mit Neopixel & Pull Up Schalter - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

Merkmale des Lichtmoduls

• Arduino Uno
• Hardware und Gehäuse aus dem Internet gekauft
• Neopixel & Netzteil geliehen von School of Informatics & Product Design
• Lichtmodul über Netzteil gesteuert
• Alle Funktionen werden über die Benutzerinteraktion gesteuert
• Animationstypen des Neopixel-Streifens: Regentyp, Duschtyp, Funkenblitztyp, Poptyp, Unregelmäßiger Typ
• Der Pull-Up-Schalter ist mit dem Neopixel-Streifen verbunden und die Animation ändert sich beim Ziehen des Neopixel-Streifens

Schritt 1: Bevor wir beginnen

Hallo Instructables und Maker.

Wir starteten ein interaktives Designprojekt im Hinblick darauf, was passieren würde, wenn wir die Emotion des Regens durch die Animation von Licht spüren könnten. Ich dachte, dass die Sensibilität des Benutzers durch eine Schnittstelle maximiert würde, die das Licht direkt anzieht.

Lass uns an die Arbeit gehen

Schritt 2: Benötigte Teile

Basierend auf einem Lichtmodul

***Neopixel und Netzteil wurden mit Unterstützung unserer Abteilung verwendet.***

Elektronik:

1. Arduino Uno
2. 3-Farben-Draht (Schwarz, Rot, jede Farbe)
3. 3-Pin-Anschluss (Link zum Kauf)
4. Schalter 1 hochziehen (Link zum Kaufen)
5. Schrumpfschlauch
6. WS2812b adressierbarer LED-Streifen mit 74 LEDs (Neopixel-Streifen)*2
7. Stromversorgung (5V 350A) 1

***Für Arduino, Pull Switch und NeoPixels werden 50 Sets benötigt.***

Hardware:

1. Acrylstange 2t (10mm*1000mm) 1
2. Acrylplatte 5t (60mm*60mm) 1
3. Foemax 10t (1200mm*1800mm) 1
4. Schwarzes Spray
5. Kabelbinder
6. Zeichenfolge
7. Hartfaserplatte
8. Rastertafel

Schritt 3: Konnektivität und Aufbau der Hardware

Zuerst benötigen wir das Acrylic Cutting, um ein Beleuchtungsmodul herzustellen.

• Um die Lichtanimation zu erleben, entwerfen Sie ein Beleuchtungsmodul, das durch Anbringen von 74 LEDs in Form eines Neopixel-Streifens auf einer 2 mm dicken Acrylleiste mit einer Fläche von 1 m befestigt wird. Wir haben zwei Arten von Beleuchtungsmodulen hergestellt: typisch linear und spiralförmig.
• Bei linearen Typen können die vorhandenen Neopixel-Streifen gehalten und befestigt werden, aber spiralförmige Typen erfordern eine manuelle Bedienung. Jede der 74 LEDs ist in Stücke geteilt, an einem spiralförmigen Acryl befestigt und mit Blei verbunden.

Befestigen Sie den Neopixel-Streifen am Acryl und sichern Sie jeden Streifen, um zu verhindern, dass er sich durch Hitze ausbreitet, oder binden Sie ihn mit einer dünnen Angelschnur. Beim linearen Typ wurde die Kugel, die auf das Ende des Moduls gezogen werden musste, installiert, um das ästhetische Aussehen zu gestalten, und wir beendeten den Tischtennisball mit einem schwarzen Spray. Dann bohrten sie ein kleines Loch in den Tischtennisball und verbanden ihn mit einem Seil. Der nächste wichtige Teil, der Schalter und das Neopixel, wird wie abgebildet angeschlossen. Der Schalter wird dann am Deckenregal befestigt.

Beim Spiraltyp besteht die Gefahr, dass durch direktes Ziehen des Spiralmoduls das Acryl unter Druck bricht, sodass der Zugabschnitt (Eingang) und das Modul (Ausgang) getrennt wurden. Um den Lichteinfall zu maximieren, wurden Module vertikal an der Decke installiert, Linearmodule wurden an der Luft befestigt, Spiralen wurden direkt an der Decke befestigt. Und wir haben den Tischtennisball und den Schalter an die Angelschnur angeschlossen, damit sie bedient werden konnte.

Der Acrylschnitt, wie in der obigen Zeichnung gezeigt, ist erforderlich, um den Schalter am Regal zu befestigen. Ein 6 cm großer quadratischer Schalter ist ungefähr 5 mm dick, wobei der Schalter zentriert ist und ein Kabelbinder durch die Löcher auf beiden Seiten geführt wird, um den Schalter sicher zu befestigen. Ein kreisförmiges Loch unten in der Mitte gibt den Zug des Schalters frei, unter dem ein dreiadriges Kabel herausgezogen und an die Kabelklemme des Moduls angeschlossen wird. Ebenso werden Regal und Acryl durch ein Loch in den vier Ecken mit Kabelbindern befestigt. Wie oben beschrieben, wird das Linearmodul direkt mit dem Zug verbunden, das Spiralmodul jedoch den Stift und den Schalter separat.

Schritt 4: Erstellen Sie mit 50 Lichtmodulen

Wir haben eine Benutzererfahrung für satteres Licht entwickelt, indem wir insgesamt 50 Module bereitgestellt haben

Wir hatten ein Regal mit einer Breite von 1.800 mm und einer Länge von 1.200 mm, und wir haben jeden Schalter und jedes Modul verbunden, damit Sie die ursprünglich geplante Regen- und Regenumgebung erleben können, und wir hatten jedes Modul für sich alleinstehend, um Multitasking zu ermöglichen.

Je nach Konstruktionszeichnung wurde in den foemax ein rundes Loch gebohrt, um die Installation zu verbergen und sicherzustellen, dass der Anschlussbereich des LED-Moduls nicht sichtbar ist. Da der Abstand von der Acrylplatte zum LED-Modul-Anschluss, an dem der Schalter angebracht ist, ca. 1cm beträgt, wurde ein 1cm dicker Foemax verwendet.

Der quadratische Metallrahmen wurde verwendet, um die Installation mit Schrauben und Kabelbindern zusammenzuhalten, während das Gesamtgewicht und die Balance beibehalten wurden. Wenn die Länge der freiliegenden Verbindungen beim Hersteller größer ist, ist die dickere Platte ineffizient und andere Strukturen werden empfohlen.

Um dem Benutzer die Erfahrung auf Augenhöhe zu erleichtern, wird die fertige Installation auf einer ca. 2 m hohen Unterlage platziert, jedoch ist zu beachten, dass die Installation des eingebetteten LED-Moduls mit dem Schalter sehr umständlich ist, daher sollten alle Verbindungen entfernt werden. Wir kletterten die Leiter hoch und verbanden das Modul mit der auf der Stütze befestigten Installation.

Der wichtigste Teil dieses gesamten Prozesses besteht darin, sicherzustellen, dass die Arbeit sicher und vollständig gesichert ausgeführt wird, um sicherzustellen, dass die Erfahrung in einer sicheren Umgebung möglich ist

Insgesamt wurden 10 Arduino- und 50 LED-Module verwendet und fünf LED-Module pro Arduino für effizienteres und nahtloses Multitasking verbunden. Details siehe beigefügte Blaupause. Im nächsten Schritt wird die Neopixel-Multitasking-Codierung mit dem Full-Switch gemäß dem Design-Diagramm ausführlich besprochen.

Schritt 5: Arduino-Kodierung und Verkabelung

Verdrahtung

• 50 Module wurden gemäß dem Layout von Schritt 4 verbunden.
• Jedes Modul wurde in 10 Sets zu je 50 Modulen unterteilt, um Multitasking zu ermöglichen und eine klare Verbindung herzustellen.
• Wie im obigen Bild von Set 1 gezeigt, wurden fünf Module an ein einzelnes Arduino angeschlossen, und die 5-V-Pins von Neopixel wurden gleichzeitig miteinander verbunden, um die Stromversorgung anzuschließen.
• Der GND der Neopixel und der Schalter wurden ebenfalls miteinander verbunden und zur besseren Wahrnehmung wurden die Schalter an die Pins 2, 3, 4, 5, 6 und die Neopixel an die Pins 9, 10, 11, 12, 13 gesteckt.
• Die Schalter und Neopixel wurden auf 2-9, 3-10, 4-11, 5-12 bzw. 6-13 verbunden.
• Da die Verbindungen der Leitungen aufwendig sind und Brandgefahr durch Kurzschlüsse besteht, ist zu beachten, dass der Schrumpfschlauch erwärmt wurde, um sicherzustellen, dass die Schwachstellen nicht brechen.

Neopixel-Multitasking-Codierung mit Pull-Up-Schalter

5 Lichtanimationen (Regentyp, Duschtyp, Funkenblitztyp, Poptyp, Unregelmäßiger Typ)

#enthalten

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

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

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

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

/*변수 Intervall을 추가*/ unsigned long Intervall; /*변수 lastUpdate를 추가*/ unsigned long lastUpdate; /*변수 Farbe1, Farbe2를 추가*/ uint32_t Farbe1, Farbe2; /*변수 TotalSteps를 추가*/ uint16_t TotalSteps; /*변수 Index를 추가*/ uint16_t Index;

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

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

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

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

Fall 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를 실행하라*/

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

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

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

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

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

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

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

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

Fall LICHT: LightUpdate(); /*case LICHT에서 나와라*/ break;

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

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

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

/*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 = Gesamtschritte - 1; } /*그 외의 방향이 정방향이면 인덱스를 0으로 설정해라*/ else{ Direction = FORWARD; Index = 0; } }

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

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

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

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

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

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

void TheaterChase(uint32_t color1, uint32_t color2, uint8_t interval, Direction dir = FORWARD){ /*실행되는 패턴은 RTHEATER_CHASE*/ ActivePattern = THEATER_CHASE; /*시간은 void TheaterChase()안에 입력되는 Intervall과 같음*/ Intervall = Intervall; /*총 numPixels갯수임*/ TotalSteps = numPixels(); /*컬러 1, 2를 설정*/ Farbe1 = Farbe1; Farbe2 = Farbe2; /*인덱스는 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를 Farbe로 변환시켜라*/ if ((i + Index) % 3 == 0){ setPixelColor(i, Color1); } /*그렇지 않다면 i를 Farbe로 변환시켜라*/ else{ setPixelColor(i, Color2); } } /*애니메이션을 함수 */ show(); Zuwachs(); }

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

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

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

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

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

/*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()안에 입력되는 Intervall과 같음*/ Intervall = Intervall; /*구동갯수는 스텝값임*/ TotalSteps = Schritte; /*컬러 1, 2를 설정*/ Farbe1 = Farbe1; Farbe2 = Farbe2; /*인덱스는 0으로 설정함*/ Index = 0; /*방향은 void Fade()안에 입력되는 dir = FORWARD과 같음*/ Direction = dir; } /*FadeUpdate를 업데이트했을 경우*/ void FadeUpdate(){ /*변수 red값은 다음과 같음*/ uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / Gesamtschritte; /*변수 green값은 다음과 같음*/ uint8_t green = ((Green(Color1) * (TotalSteps - Index)) + (Green(Color2) * Index)) / TotalSteps; /*변수 blue값은 다음과 같음*/ uint8_t blue = ((Blue(Color1) * (TotalSteps - Index)) + (Blue(Color2) * Index)) / TotalSteps; /*위의 rot, grün, blau 컬러를 셋팅함*/ ColorSet(Color(rot, grün, blau)); /*애니메이션을 함수 */ show(); Zuwachs(); }

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

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를 설정*/ Farbe1 = Farbe1; /*총 numPixels갯수임*/ TotalSteps = numPixels(); Index = 0; }

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

void TwinkleUpdate(){ /*모든 컬러를 0으로 셋팅*/ setAll(0, 0, 0); /*변수 Pixel은 random 74*/ int Pixel = random(74); /*zufällig 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(); Zuwachs(); }

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

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

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

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

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

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

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

Void MeteorUpdate () { for (int i = 0; i < numPixels (); i ++) { if (i == Index) { setPixelColor (i, 100, random (255), 255); aufrechtzuerhalten. Else { setPixelColor (i, DimColor (getPixelColor (i))); } } /*애니메이션을 함수 */ show(); Zuwachs(); }

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

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

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

Void LightUpdate () { for (int i = 0; i < numPixels (); i ++) { if (i == TotalSteps - Index) { setPixelColor (i, 150, random (200), 40); aufrechtzuerhalten. Else { setPixelColor (i, DimColor (getPixelColor (i))); } } /*애니메이션을 함수 */ show(); Zuwachs(); }

/*Blüte의 시간과 방향을 입력*/

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

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

Void BlossomUpdate () { for (int i = 0; i < numPixels (); i ++) { if (i == TotalSteps - Index) { setPixelColor (i, 255, random (255), 100); aufrechtzuerhalten. Else { setPixelColor (i, DimColor (getPixelColor (i))); } } /*애니메이션을 함수 */ show(); Zuwachs(); }

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

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

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

uint32_t DimColor(uint32_t color){ // R-, G- und B-Komponenten ein Bit nach rechts verschieben uint32_t dimColor = Color(Red(color) >> 1, Green(color) >> 1, Blue(color) >> 1); geben Sie dimColor zurück; }

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

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

/*레드값을 불러옴*/

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

/*Regenbogen 컬러를 불러옴*/

uint32_t Wheel(byte WheelPos){ WheelPos = 255 - WheelPos; if (WheelPos < 85) { return Color (255 - WheelPos * 3, 0, WheelPos * 3); aufrechtzuerhalten. Sonst if (WheelPos <170) { WheelPos -= 85; Return Color(0, WheelPos * 3, 255 - WheelPos * 3); aufrechtzuerhalten. Sonst { WheelPos -= 170; Farbe zurückgeben (WheelPos * 3, 255 - WheelPos * 3, 0); } } };

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

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;

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임*/

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

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

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

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

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

/////SCHALTER_3////////////////////////////////////////// //////////////////////////////////////////////// ////////////////////////////////////////

Schalter (buttonCounter[1]) { Fall 0: strip2. ActivePattern = STAR; Streifen2. Intervall = 50; strip2. TotalSteps = strip2.numPixels(); brechen; Fall 1: strip2. ActivePattern = RAINBOWSPARKLE; Streifen2. Intervall = 100; strip2. TotalSteps = strip2.numPixels(); brechen; Fall 2: strip2. ActivePattern = SCANNER; Streifen2. Intervall = 20; strip2. TotalSteps = (strip2.numPixels() - 1) * 2; brechen; Fall 3: strip2. ActivePattern = TWINKLE; Streifen2. Intervall = 5; strip2. TotalSteps = strip2.numPixels(); brechen; Fall 4: strip2. ActivePattern = METEOR; Streifen2. Intervall = 40; strip2. TotalSteps = strip2.numPixels(); brechen; } Serial.print (buttonCounter[0]); Serial.print (", "); Serial.println (buttonCounter[1]);

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

Schalter (buttonCounter[2]) { Fall 0: strip3. ActivePattern = STAR; Streifen3. Intervall = 50; strip3. TotalSteps = strip3.numPixels(); brechen; Fall 1: strip3. ActivePattern = RAINBOWSPARKLE; Streifen3. Intervall = 100; strip3. TotalSteps = strip3.numPixels(); brechen; Fall 2: strip3. ActivePattern = SCANNER; Streifen3. Intervall = 20; strip3. TotalSteps = (strip3.numPixels() - 1) * 2; brechen; Fall 3: strip3. ActivePattern = TWINKLE; Streifen3. Intervall = 5; strip3. TotalSteps = strip3.numPixels(); brechen; Fall 4: strip3. ActivePattern = METEOR; Streifen3. Intervall = 25; strip3. TotalSteps = strip3.numPixels(); brechen; } Serial.print (buttonCounter[0]); Serial.print (", "); Serial.println (buttonCounter[1]);

/////SCHALTER_5////////////////////////////////////////// //////////////////////////////////////////////// /////////////////////////////////////////

Schalter (buttonCounter[3]) { Fall 0: strip4. ActivePattern = STAR; Streifen4. Intervall = 50; strip4. TotalSteps = strip4.numPixels(); brechen; Fall 1: strip4. ActivePattern = RAINBOWSPARKLE; Streifen4. Intervall = 100; strip4. TotalSteps = strip4.numPixels(); brechen; Fall 2: strip4. ActivePattern = SCANNER; Streifen4. Intervall = 20; strip4. TotalSteps = (strip4.numPixels() - 1) * 2; brechen; Fall 3: strip4. ActivePattern = TWINKLE; Streifen4. Intervall = 5; strip4. TotalSteps = strip4.numPixels(); brechen; Fall 4: strip4. ActivePattern = METEOR; Streifen4. Intervall = 25; strip4. TotalSteps = strip4.numPixels(); brechen; } Serial.print (buttonCounter[0]); Serial.print (", "); Serial.println (buttonCounter[1]);

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

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

// strip1 Completion Callback

Void strip1Complete () { strip1. Color1 = strip1. Wheel (zufällig (255)); strip1. Color2 = strip1. Wheel (zufällig (255)); Streifen1. Index = 0; }

// strip2 Completion Callback

Void strip2Complete () { strip2. Color1 = strip2. Wheel (zufällig (255)); strip2. Color2 = strip2. Wheel (zufällig (255)); Streifen2. Index = 0; }

// strip3 Completion Callback

Void strip3Complete () { strip3. Color1 = strip3. Wheel (zufällig (255)); strip3. Color2 = strip3. Wheel (zufällig (255)); Streifen3. Index = 0; }

// strip4 Completion Callback

Void strip4Complete () { strip4. Color1 = strip4. Wheel (zufällig (255)); strip4. Color2 = strip4. Wheel (zufällig (255)); Streifen4. Index = 0; }

// strip5 Completion Callback

Void strip5Complete () { strip5. Color1 = strip5. Wheel (zufällig (255)); strip5. Color2 = strip5. Wheel (zufällig (255)); strip5. Index = 0; }

Schritt 6: Ergebnis und Filmherstellung

Vielen Dank für Ihr Interesse an unserem Projekt, obwohl es nicht ausreicht.