Издърпайте светлината - Светлинен модул с помощта на Neopixel & Pull Up Switch: 6 стъпки (със снимки)

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:52

Характеристики на модула Light

• Arduino Uno
• Хардуер и кутия, закупени от интернет
• Neopixel & захранване, заимствано от School of Informatics & Product Design
• Светлинен модул, управляван от захранване
• Всички функции се контролират чрез взаимодействие с потребителите
• Анимационни типове неопикселова лента: тип дъжд, тип душ, тип искрови светкавици, тип поп, нередовен тип
• Издърпващият превключвател е свързан към лентата Neopixel и анимацията се променя, когато се изтегли лентата Neopixel

Стъпка 1: Преди да започнем

Здравейте инструктори и създатели.

Започнахме интерактивен дизайнерски проект по отношение на това какво би се случило, ако почувстваме емоцията на дъжда чрез анимация на светлината. Мислех, че чувствителността на потребителя ще бъде максимално увеличена чрез интерфейс, който директно привлича светлина.

Да не се захващаме за работа

Стъпка 2: Необходими части

Въз основа на един светлинен модул

*** Неопикселите и захранването бяха използвани с подкрепата на нашия отдел. ***

Електроника:

1. Arduino Uno
2. 3 цветен проводник (черен, червен, всеки цвят)
3. 3 -пинов конектор (линк за закупуване)
4. Издърпайте превключвателя 1 (Връзка за покупка)
5. свиваща се тръба
6. WS2812b адресируема LED лента със 74 LED (неопикселова лента)*2
7. Захранване (5V 350A) 1

*** Необходими са 50 комплекта за Arduino, Pull Switch и NeoPixels. ***

Хардуер:

1. Акрилна лента 2t (10mm*1000mm) 1
2. Акрилна дъска 5t (60mm*60mm) 1
3. Foemax 10t (1200 мм*1800 мм) 1
4. Черен спрей
5. Кабелна връзка
6. Низ
7. ПДЧ
8. Решетка

Стъпка 3: Свързване и изграждане на хардуер

Първо, имаме нужда от акрилно рязане, за да направим един осветителен модул.

• Като средство за изживяване на анимацията на светлината, начертайте модул за осветление, който е фиксиран, като прикрепите 74 светодиода под формата на неопикселова лента към акрилна лента с дебелина 2 мм с площ 1 М. Ние сме произвели два вида осветителни модули: типични линейни и спирални.
• За линейни типове съществуващите неопикселови ленти могат да се държат и обезопасяват, но спиралните видове изискват ръчна работа. Всеки от 74 -те светодиода е разделен на парчета, прикрепен към спирален акрил и свързан заедно с олово.

Прикрепете лентата Neopixel към акрила и закрепете всяка лента, за да предотвратите разпространението й от топлина, или я завържете с тънка въдица. В случай на линеен тип, сферата, която трябваше да бъде изтеглена в края на модула, беше инсталирана, за да се създаде естетически вид, и завършихме топката за пинг -понг с черен спрей. След това пробиха малка дупка в топката за пинг -понг и я свързаха с въже. Следващата най -важна част, превключвателят и неопикселът, са свързани, както е показано. След това превключвателят е закрепен към таванския рафт.

В случай на спирален тип, съществува риск директното издърпване на спиралния модул да разчупи акрила под налягане, така че издърпващата секция (вход) и модулът (изход) бяха разделени. За да се увеличи максимално падането на светлината, модулите бяха инсталирани вертикално на тавана, линейните модули бяха фиксирани към въздуха, спиралите бяха фиксирани директно към тавана. И свързахме топката за пинг -понг и превключвателя към въдицата, за да може да се работи.

Акрилното рязане, както е показано на чертежа по -горе, е необходимо за закрепване на превключвателя към рафта. 6 -сантиметров превключвател с квадратна форма е с дебелина приблизително 5 мм, с превключвателя в центъра и с кабелна връзка, поставена през отвори от двете страни, за да закрепи превключвателя здраво. Кръгъл отвор в долната част на центъра показва издърпването на превключвателя, под който се издърпва трижилен кабел и се свързва към кабелния терминал на модула. И по подобен начин, през отвор в четирите ъгъла, рафтът и акрилът са закрепени с кабелни връзки. Както е описано по -горе, линейният модул е свързан директно към дърпането, но спираловидният модул свързва щифта и превключвателя отделно.

Стъпка 4: Създайте с помощта на 50 светлинни модула

Проектирахме потребителско изживяване за по -богата светлина, като разполагаме общо 50 модула

Имахме рафт с ширина 1 800 мм и дължина 1 200 мм и свързвахме всеки превключвател и модул, така че да можете да усетите дъжда и дъждовната среда, които първоначално планирахме, и всеки модул беше самостоятелен, за да даде възможност за многозадачност.

В зависимост от чертежа на проекта, във фумакса е пробита кръгла дупка, за да се скрие инсталацията и да се гарантира, че свързаната зона на LED модула не се вижда. Тъй като разстоянието от акрилната дъска до свързването на LED модула, където е прикрепен превключвателят, е около 1 см, беше използван фемакс с дебелина 1 см.

Металната квадратна рамка е използвана за закрепване на инсталацията заедно с винтове и кабелни връзки, като същевременно се поддържа общото тегло и баланс. Ако дължината на откритите връзки е повече от тази, когато производителят се опитва, по -дебелата дъска е неефективна и се препоръчват други структури.

За да се улесни потребителското изживяване на нивото на очите, завършената инсталация се поставя върху опора с височина приблизително 2 м, но вниманието е, че е много тромаво да се инсталира вградения LED модул с превключвателя, така че всички връзки трябва да бъдат премахнати. Изкачихме се по стълбата и свързахме модула с инсталацията, фиксирана върху опората.

Най -важната част от целия този процес е да се гарантира, че работата се извършва сигурно и напълно обезопасена, за да се гарантира, че преживяването е възможно в безопасна среда

Бяха използвани общо 10 arduino и 50 LED модула и пет LED модула бяха свързани към arduino за по-ефективен и безпроблемен многозадачност. Вижте приложения план за подробности. Неопикселовото многозадачно кодиране, използващо пълния превключвател според схемата на проектиране, ще бъде обсъдено подробно в следващата стъпка.

Стъпка 5: Кодиране и окабеляване на Arduino

Електрически инсталации

• 50 модула бяха свързани според оформлението на стъпка 4.
• Всеки модул беше разделен на 10 комплекта от 50 модула, за да се даде възможност за многозадачност и да се осигури ясна връзка.
• Както е показано на изображението в комплект 1 по -горе, пет модула са свързани към един arduino, а 5v щифтовете на неопиксела са свързани едновременно, за да свържат захранването.
• GND на неопикселите и превключвателите също бяха свързани заедно и за по -лесно възприемане превключвателите бяха включени в щифтове 2, 3, 4, 5, 6 и неопикселите бяха включени в щифтове 9, 10, 11, 12, 13.
• Превключвателите и неопикселите бяха свързани съответно по 2-9, 3-10, 4-11, 5-12, 6-13 начина.
• Трябва да се отбележи, че тъй като връзките на линиите са сложни и съществува опасност от пожар поради късо съединение, свиващата се тръба се нагрява, за да се гарантира, че слабите части не се счупиха.

Neopixel многозадачно кодиране с превключвател

5 светлинни анимации (тип дъжд, тип душ, искрови светкавици, тип поп, нередовен тип)

#включва

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

модел на изброяване {NONE, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 픽셀 을 방향 을 설정 함*/ посока на изброяване {НАПРЕД, НАЗАД};

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

клас NeoPatterns: обществен Adafruit_NeoPixel { /* 패턴 을 추가 하고 업데이트 하기 위한 함수* / public: модел ActivePattern; /*클레스 함수 에 패턴 의 방향 을 입력*/ посока посока;

/*변수 Интервал 을 추가*/ без подпис дълъг интервал; /*변수 lastUpdate 를 추가*/ unsigned long lastUpdate; /*변수 Цвят1, Цвят2 를 추가*/ uint32_t Цвят1, Цвят2; /*변수 TotalSteps 를 추가*/ uint16_t TotalSteps; /*변수 Индекс 를 추가*/ uint16_t Индекс;

/*패턴 을 을 했을 시 다시 불러오는 함수*/ void (*OnComplete) (); /*네오 패턴 에서 네오 픽샐 의 갯수, 핀 번호, 타입, 콜백 을 불러오는 함수*/ NeoPatterns (uint16_t пиксели, uint8_t щифт, uint8_t тип, void (*обратно повикване) ()): Adafruit_NeoPixel (пиксели, щифт, тип) { OnComplete = обратно повикване; }

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

void Update () { /*패턴 의 시간 설정. 멀티 태스킹 을 구현 하는 구문*/ if ((millis () - lastUpdate)> Интервал) {lastUpdate = millis (); /*ActivePattern 의 스위치 구문*/ switch (ActivePattern) {/*случай RAINBOW_CYCLE 에서는 RainbowCycleUpdate 를 실행 하라*/ случай RAINBOW_CYCLE: RainbowCycleUpdate (); /*случай RAINBOW_CYCLE 에서 나와라*/ break;

/*случай THEATER_CHASE 에서는 TheaterChaseUpdate 를 실행 하라*/

случай THEATER_CHASE: TheaterChaseUpdate (); /*случай THEATER_CHASE 에서 나와라*/ break;

/*калъф COLOR_WIPE 에서는 ColorWipeUpdate 를 실행 하라*/

случай COLOR_WIPE: ColorWipeUpdate (); /*случай COLOR_WIPE 에서 나와라*/ break; /*случай SCANNER 에서는 ScannerUpdate 를 실행 하라*/ case SCANNER: ScannerUpdate (); /*случай SCANNER 에서 나와라*/ break;

/*случай FADE 에서는 FadeUpdate 를 실행 하라*/

случай FADE: FadeUpdate (); /*случай FADE 에서 나와라*/ break;

/*калъф TWINKLE 에서는 TwinkleUpdate 를 실행 하라*/

случай TWINKLE: TwinkleUpdate (); /*случай TWINKLE 에서 나와라*/ break;

/*случай STAR 에서는 StarUpdate 를 실행 하라*/

случай STAR: StarUpdate (); /*случай STAR 에서 나와라*/ break;

/*калъф RAINBOWSPARKLE 에서는 RainbowsparkleUpdate 를 실행 하라*/

случай RAINBOWSPARKLE: RainbowsparkleUpdate (); /*калъф RAINBOWSPARKLE 에서 나와라*/ break; /*case METEOR 에서는 MeteorUpdate 를 실행 하라*/ case METEOR: MeteorUpdate (); /*случай METEOR 에서 나와라*/ break;

/*калъф LIGHT 에서는 LightUpdate 를 실행 하라*/

калъф LIGHT: LightUpdate (); /*калъф LIGHT 에서 나와라*/ почивка;

/*калъф BLOSSOM 에서는 BlossomUpdate 를 실행 하라*/

случай BLOSSOM: BlossomUpdate (); /*калъф BLOSSOM 에서 나와라*/ break; }}}

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

/*Индекс 를 증가 시키고 초기화 하는 함수*/

void Increment () { /*만약 정방향 이면 인덱스 를 증가 시켜라* / if (Посока == НАПРЕД) {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 == НАПРЕД) { /*방향 은 그 와 반대 이며 구동 갯수 갯수 일 1 일 빼라* / Direction = REVERSE; Индекс = TotalSteps - 1; } /*그 외의 방향 이 정방향 이면 인덱스 를 0 으로 설정 해라* / else {Direction = НАПРЕД; Индекс = 0; }}

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

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

void RainbowCycle (uint8_t интервал, посока dir = НАПРЕД) { /*실행 되는 패턴 은 RainbowCycle 임* / ActivePattern = RAINBOW_CYCLE; /*시간 은 void RainbowCycle () 안에 입력 되는 интервал 과 같음*/ Интервал = интервал; /*총 구동 갯수 는 255 임*/ TotalSteps = 255; /*인덱스 는 0 으로 설정 함*/ Индекс = 0; /*방향 은 void RainbowCycle () 안에 입력 되는 dir = НАПРЕД 과 같음*/ 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 (); Инкремент (); }

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

void TheaterChase (uint32_t color1, uint32_t color2, uint8_t интервал, посока dir = НАПРЕД) { /*실행 되는 패턴 은 RTHEATER_CHASE* / ActivePattern = THEATER_CHASE; /*시간 은 void TheaterChase () 안에 입력 되는 интервал 과 같음*/ Интервал = интервал; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1, 2 를 설정*/ Цвят1 = цвят1; Цвят2 = цвят2; /*인덱스 는 0 으로 설정 함*/ Индекс = 0; /*방향 은 void TheaterChase () 안에 입력 되는 dir = НАПРЕД 과 같음*/ Direction = dir; }

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

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

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

void ColorWipe (uint32_t цвят, uint8_t интервал, посока dir = НАПРЕД) { /*실행 되는 패턴 은 COLOR_WIPE* / ActivePattern = COLOR_WIPE; /*시간 은 void ColorWipe () 안에 입력 되는 интервал 과 같음*/ Интервал = интервал; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Color1 = цвят; /*인덱스 는 0 으로 설정 함*/ Индекс = 0; /*방향 은 void ColorWipe () 안에 입력 되는 dir = НАПРЕД НАПРЕД 과 같음*/ Direction = dir; }

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

void ColorWipeUpdate () { /*индекс 를 컬러 1 로 변환 시켜라* / setPixelColor (Index, Color1); / *애니메이션 을 보여주는 함수 */ show (); Инкремент (); }

/*Скенер 의 컬러 와 시간 을 입력*/

празен скенер (uint32_t color1, uint8_t интервал) { /*실행 되는 패턴 은 SCANNER* / ActivePattern = SCANNER; /*시간 은 void Scanner () 안에 입력 되는 интервал 과 같음*/ Interval = интервал; /*구동 갯수 는 총 갯수 에서 1 을 빼고 2 를 곱 해라*/ TotalSteps = (numPixels () - 1)*2; /*컬러 1 을 설정*/ Цвят1 = цвят1; /*인덱스 는 0 으로 설정 함*/ Индекс = 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 (); Инкремент (); }

/*Скенер 의 컬러 1, 2 와 스텝, 시간, 방향 을 입력*/

void Fade (uint32_t color1, uint32_t color2, uint16_t стъпки, uint8_t интервал, посока dir = НАПРЕД) { /*실행 되는 패턴 은 FADE* / ActivePattern = FADE; /*시간 은 void Fade () 안에 입력 되는 интервал 과 같음*/ Интервал = интервал; /*구동 갯수 는 스텝 값임*/ TotalSteps = стъпки; /*컬러 1, 2 를 설정*/ Цвят1 = цвят1; Цвят2 = цвят2; /*인덱스 는 0 으로 설정 함*/ Индекс = 0; /*방향 은 void Fade () 안에 입력 되는 dir = НАПРЕД НАПРЕД 과 같음*/ Direction = dir; } /*FadeUpdate 를 업데이트 했을 경우* / void FadeUpdate () { /*변수 червено 값 은 다음 과 /* / uint8_t червено = ((Червено (Color1)*(TotalSteps - Index)) + (Red (Color2)*Index)) / TotalSteps; / * 변수 зелено 값 은 다음 과 같음 * / uint8_t зелено = ((Зелено (Color1) * (TotalSteps - Index)) + (Green (Color2) * Index)) / TotalSteps; / * 변수 синьо 값 은 다음 과 같음 * / uint8_t синьо = ((Синьо (Color1) * (TotalSteps - Index)) + (Blue (Color2) * Index)) / TotalSteps; /*위 의 червено, зелено, синьо 값 으로 컬러 를 셋팅 함*/ ColorSet (Цвят (червено, зелено, синьо)); / *애니메이션 을 보여주는 함수 */ show (); Инкремент (); }

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

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 () 안에 입력 되는 интервал 과 같음*/ Интервал = интервал; /*컬러 1 를 설정*/ Цвят1 = цвят1; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Индекс = 0; }

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

void TwinkleUpdate () { /*모든 네오 픽셀 의 컬러 를 0 으로 셋팅* / setAll (0, 0, 0); /*변수 Пиксел 은 произволен 74*/ int Пиксел = случаен (74); /*произволно 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 (); Инкремент (); }

/*Звезда 의 컬러 1 값 을 입력*/

void Star (uint32_t color1) { /*실행 되는 패턴 은 STAR* / ActivePattern = STAR; /*시간 은 void Star () 안에 입력 되는 интервал 과 같음*/ Interval = Интервал; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); /*컬러 1 을 설정*/ Цвят1 = цвят1; Индекс = 0; }

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

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

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

void Rainbowsparkle (uint8_t интервал, посока dir = НАПРЕД) { /*실행 되는 패턴 은 RAINBOWSPARKLE* / ActivePattern = RAINBOWSPARKLE; /*시간 은 void Rainbowsparkle () 안에 입력 되는 интервал 과 같음*/ Интервал = интервал; /*총 구동 갯수 는 numPixels 갯수 임*/ TotalSteps = numPixels (); Индекс = 0; /*방향 은 void Rainbowsparkle () 안에 입력 되는 посока 과 같음*/ 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 = случайно (255); setPixelColor (i, c); } else {setPixelColor (i, random (255)); }} / *애니메이션 을 보여주는 함수 * / show (); Инкремент (); } /*Метеор 의 시간 과 방향 을 입력* / void Meteor (uint32_t color1) { /*실행 되는 패턴 은 METEOR* / ActivePattern = METEOR; /*시간 설정*/ Интервал = Интервал; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Цвят1 = цвят1; Индекс = 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 (); Инкремент (); }

/*Светлина 의 시간 과 방향 을 입력*/

void Light (uint32_t color1) { /*실행 되는 패턴 은 LIGHT* / ActivePattern = LIGHT; /*시간 설정*/ Интервал = Интервал; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Цвят1 = цвят1; Индекс = 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 (); Инкремент (); }

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

void Blossom (uint32_t color1) { /*실행 되는 패턴 은 BLOSSOM* / ActivePattern = BLOSSOM; /*시간 설정*/ Интервал = Интервал; / *총 구동 갯수 는 numPixels 갯수 에서 1 일뺀 후, *2 를 한 것과 같음 */ TotalSteps = (numPixels ()-1) *2; /*컬러 1 을 설정*/ Цвят1 = цвят1; Индекс = 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 (); Инкремент (); }

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

/ *네오 픽셀 의 켜지 는 위치 와 색 을 지정 해주는 함수 */ void setAll (байт червен, байт зелен, байт син) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, red, зелено, синьо); } show (); }

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

uint32_t DimColor (uint32_t цвят) {// Преместване на компонентите R, G и B с един бит надясно uint32_t dimColor = Цвят (червен (цвят) >> 1, зелен (цвят) >> 1, син (цвят) >> 1); връщане dimColor; }

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

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

/*레드 값 을 불러 옴*/

uint8_t Червен (uint32_t цвят) {return (цвят >> 16) & 0xFF; } /*그린 값 을 불러 옴* / uint8_t Зелено (uint32_t цвят) {връщане (цвят >> 8) & 0xFF; } /*블루 값 을 불러 옴* / uint8_t Синьо (uint32_t цвят) {цвят за връщане & 0xFF; }

/*Rainbow 컬러 를 불러 옴*/

uint32_t Wheel (байт WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {връщане на цвят (255 - WheelPos * 3, 0, WheelPos * 3); } else if (WheelPos <170) {WheelPos -= 85; връщане на цвят (0, WheelPos * 3, 255 - WheelPos * 3); } else {WheelPos -= 170; връщане на цвят (WheelPos * 3, 255 - WheelPos * 3, 0); }}};

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

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

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

#define NUMPIXELS 74 /*사용 하는 버튼 의 갯수 갯수 /* / #define B_NUM 5 /*Импортиране на лента1 ~ 5 까지, 갯수 는 74 개 스트립 연결 핀 лента1 은 8 ~ лента5 까지 12* / NeoPatterns лента1 (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 четене [B_NUM]; unsigned long lastDebounceTime [B_NUM] = {0, 0, 0, 0, 0}; /*모든 버튼 핀 을 읽는 시간 간격 은 забавяне50 과 같음*/ без подпис дълъг debounceDelay = 50;

void setup () {

/*복잡 하게 저항 연결 이 필요 없도록 인풋 풀업 방식 의 G G: GND - 5V (Свързване към пинов номер)*/ 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, НАПРЕД)

}

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

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

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

/*버튼 배열 의 0 번째 즉. 2 번핀 에 연결된 버튼 을 활용 하여 애니메이션 이 되도록 하는 스위치 케이스 구문*/ превключвател (buttonCounter [0]) {

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

случай 0: strip1. ActivePattern = BLOSSOM; /*해당 애니메이션 의 시간 을 설정*/ strip1. Interval = 20; /*구동 되는 되는 픽셀 의 갯수 를 설정*/ strip1. TotalSteps = strip1.numPixels (); прекъсване; /*두번째 버튼 버튼 활동 시키면 구동 되는 애니메이션*/ случай 1: лента1. ActivePattern = RAINBOWSPARKLE; strip1. Interval = 50; strip1. TotalSteps = strip1.numPixels (); прекъсване; /*세번째 버튼 버튼 활동 시키면 구동 되는 애니메이션*/ случай 2: лента1. ActivePattern = СКАНЕР; strip1. Interval = 10; strip1. TotalSteps = (strip1.numPixels () - 1) * 2; прекъсване; /*네번째 버튼 버튼 을 시키면 구동 되는 애니메이션/*/ случай 3: strip1. ActivePattern = TWINKLE; strip1. Interval = 1; strip1. TotalSteps = strip1.numPixels (); прекъсване; /*다섯 번째 번째 을 활동 시키면 구동 되는 애니메이션*/ случай 4: strip1. ActivePattern = METEOR; strip1. Interval = 10; strip1. TotalSteps = strip1.numPixels (); прекъсване; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

ключ (buttonCounter [1]) {случай 0: strip2. ActivePattern = STAR; strip2. Interval = 50; strip2. TotalSteps = strip2.numPixels (); прекъсване; случай 1: strip2. ActivePattern = RAINBOWSPARKLE; strip2. Interval = 100; strip2. TotalSteps = strip2.numPixels (); прекъсване; случай 2: strip2. ActivePattern = SCANNER; strip2. Interval = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; прекъсване; случай 3: strip2. ActivePattern = TWINKLE; strip2. Interval = 5; strip2. TotalSteps = strip2.numPixels (); прекъсване; случай 4: strip2. ActivePattern = METEOR; strip2. Interval = 40; strip2. TotalSteps = strip2.numPixels (); прекъсване; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

switch (buttonCounter [2]) {случай 0: strip3. ActivePattern = STAR; strip3. Interval = 50; strip3. TotalSteps = strip3.numPixels (); прекъсване; случай 1: strip3. ActivePattern = RAINBOWSPARKLE; strip3. Interval = 100; strip3. TotalSteps = strip3.numPixels (); прекъсване; случай 2: strip3. ActivePattern = SCANNER; strip3. Interval = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; прекъсване; случай 3: strip3. ActivePattern = TWINKLE; strip3. Interval = 5; strip3. TotalSteps = strip3.numPixels (); прекъсване; случай 4: strip3. ActivePattern = METEOR; strip3. Interval = 25; strip3. TotalSteps = strip3.numPixels (); прекъсване; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

ключ (buttonCounter [3]) {случай 0: strip4. ActivePattern = STAR; strip4. Interval = 50; strip4. TotalSteps = strip4.numPixels (); прекъсване; случай 1: strip4. ActivePattern = RAINBOWSPARKLE; strip4. Interval = 100; strip4. TotalSteps = strip4.numPixels (); прекъсване; случай 2: strip4. ActivePattern = SCANNER; strip4. Interval = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; прекъсване; случай 3: strip4. ActivePattern = TWINKLE; strip4. Interval = 5; strip4. TotalSteps = strip4.numPixels (); прекъсване; случай 4: strip4. ActivePattern = METEOR; strip4. Interval = 25; strip4. TotalSteps = strip4.numPixels (); прекъсване; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

ключ (buttonCounter [4]) {случай 0: strip5. ActivePattern = STAR; strip5. Interval = 50; strip5. TotalSteps = strip5.numPixels (); прекъсване; случай 1: strip5. ActivePattern = RAINBOWSPARKLE; strip5. Interval = 100; strip5. TotalSteps = strip5.numPixels (); прекъсване; случай 2: strip5. ActivePattern = SCANNER; strip5. Interval = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; прекъсване; случай 3: strip5. ActivePattern = TWINKLE; strip5. Interval = 5; strip5. TotalSteps = strip5.numPixels (); прекъсване; случай 4: strip5. ActivePattern = METEOR; strip5. Interval = 25; strip5. TotalSteps = strip5.numPixels (); прекъсване; } Serial.print (buttonCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Завършване Обратно повикване

void strip1Complete () {strip1. Color1 = strip1. Wheel (случаен (255)); лента1. Цвят2 = лента1. Колело (произволно (255)); strip1. Index = 0; }

// strip2 Completion Callback

void strip2Complete () {strip2. Color1 = strip2. Wheel (случаен (255)); лента2. Цвят2 = лента2. Колело (произволно (255)); strip2. Index = 0; }

// strip3 Завършване на обратно извикване

void strip3Complete () {strip3. Color1 = strip3. Wheel (случаен (255)); strip3. Color2 = strip3. Wheel (случаен (255)); strip3. Index = 0; }

// strip4 Завършване Обратно повикване

void strip4Complete () {strip4. Color1 = strip4. Wheel (случаен (255)); лента4. Цвят2 = лента4. Колело (произволно (255)); strip4. Index = 0; }

// strip5 Завършване Обратно повикване

void strip5Complete () {strip5. Color1 = strip5. Wheel (случаен (255)); лента5. Цвят2 = лента5. Колело (произволно (255)); strip5. Index = 0; }

Стъпка 6: Резултат и създаване на филм

Благодарим ви за интереса към нашия проект, макар че това не е достатъчно.