Vuta Nuru - Moduli ya Mwanga Kutumia Neopixel & Kuvuta Kubadilisha: Hatua 6 (na Picha)

2024 Mwandishi: John Day | [email protected]. Mwisho uliobadilishwa: 2024-01-30 12:52

Makala ya moduli ya Mwanga

• Arduino Uno
• Vifaa na faragha iliyonunuliwa kutoka kwa mtandao
• Usambazaji wa Neopixel na Umeme uliokopwa kutoka Shule ya Informatics na Ubunifu wa Bidhaa
• Moduli nyepesi inayodhibitiwa na usambazaji wa umeme
• Kazi zote zinadhibitiwa kupitia mwingiliano wa watumiaji
• Aina za michoro ya Ukanda wa Neopikseli: Aina ya mvua, Aina ya kuoga, Aina ya umeme wa Spark, Aina ya picha, Aina isiyo ya kawaida
• Kitufe cha kuvuta kimeunganishwa na ukanda wa Neopixel na mabadiliko ya uhuishaji wakati wa kuvutwa mkanda wa Neopixel

Hatua ya 1: Kabla ya kuanza

Halo Maagizo na Watengenezaji.

Tulianza na mradi wa maingiliano ya kubuni kwa suala la kile kitatokea ikiwa tunaweza kuhisi hisia za mvua kupitia uhuishaji wa nuru. Nilidhani kuwa unyeti wa mtumiaji utakuzwa kupitia kiolesura ambacho huvuta nuru moja kwa moja.

Wasije wakafanya kazi

Hatua ya 2: Sehemu Zinazohitajika

Kulingana na Moduli moja ya Nuru

*** Neopixels na Ugavi wa umeme zilitumika kwa msaada wa idara yetu.

Umeme:

1. Arduino Uno
2. Waya ya rangi 3 (Nyeusi, Nyekundu, Rangi yoyote)
3. 3pin kontakt (Kiungo cha kununua)
4. Vuta swichi 1 (Kiungo cha kununua)
5. kushuka kwa bomba
6. Ukanda wa LED wa WS2812b unaoweza kuongezewa na 74 LED (ukanda wa Neopixel) * 2
7. Ugavi wa umeme (5V 350A) 1

Seti 50 zinahitajika kwa Arduino, Kitufe cha Kuvuta na NeoPixels.

Vifaa:

1. Bar ya akriliki 2t (10mm * 1000mm) 1
2. Bodi ya Acrylic 5t (60mm * 60mm) 1
3. Foemax 10t (1200mm * 1800mm) 1
4. Dawa nyeusi
5. Cable tie
6. Kamba
7. Hardboard
8. Bodi ya gridi

Hatua ya 3: Uunganisho na Ujenzi wa vifaa

Kwanza, tunahitaji Kukata kwa Akriliki kutengeneza moduli moja ya taa.

• Kama njia ya uzoefu wa uhuishaji wa taa, andika moduli ya taa ambayo imewekwa kwa kushikamana na LED za 74 kwa njia ya ukanda wa neopixel kwenye bar ya akriliki yenye nene ya 2mm na eneo la 1M. Tumezalisha aina mbili za moduli za taa: kawaida ya mstari na ond.
• Kwa aina za laini, vipande vya neopixel zilizopo vinaweza kushikiliwa na kuulinda, lakini aina za ond zinahitaji operesheni ya mikono. Kila moja ya LED 74 imegawanyika vipande vipande, imeambatanishwa na akriliki ya ond, na imefungwa pamoja na risasi.

Ambatisha ukanda wa Neopikseli kwa akriliki na salama kila ukanda ili kuizuia isienezwe na joto, au funga na laini nyembamba ya uvuvi. Katika kesi ya aina ya laini, uwanja ulihitaji kuvutwa hadi mwisho wa moduli iliwekwa ili kubuni sura ya urembo na tukamaliza mpira wa ping pong na dawa nyeusi. Kisha wakachimba shimo dogo kwenye mpira wa ping pong na wakaunganisha na kamba. Sehemu inayofuata muhimu zaidi, swichi na neopixel, imeunganishwa kama inavyoonyeshwa. Kubadilisha basi kulindwa kwenye rafu ya dari.

Katika kesi ya aina ya ond, kuna hatari kwamba kuvuta moja kwa moja moduli ya ond kunaweza kuvunja akriliki chini ya shinikizo, kwa hivyo sehemu ya kuvuta (Ingizo) na moduli (Pato) zilitengwa. Ili kuongeza kuanguka kwa taa, moduli ziliwekwa kwa wima kwenye dari, moduli zenye laini ziliwekwa hewani, spirals ziliwekwa moja kwa moja kwenye dari. Na tuliunganisha mpira wa ping pong na swichi kwa laini ya uvuvi ili iweze kuendeshwa.

Ukataji wa akriliki kama inavyoonyeshwa kwenye mchoro hapo juu unahitajika kupata swichi kwenye rafu. Kubadilisha umbo la mraba 6cm ni takriban 5mm nene, na swichi imejikita na tai ya waya imeingizwa kupitia mashimo pande zote mbili ili kupata swichi kwa nguvu. Shimo la mviringo chini ya kituo hufunua kuvuta kwa swichi, chini ambayo kebo ya waya tatu hutolewa nje na kushikamana na kituo cha kebo cha moduli. Na vile vile, kupitia shimo kwenye pembe nne, rafu na akriliki zimehifadhiwa na vifungo vya kebo. Kama ilivyoelezewa hapo juu, moduli ya laini imeunganishwa moja kwa moja na kuvuta, lakini moduli ya ond inaunganisha pini na swichi kando.

Hatua ya 4: Unda Kutumia Moduli 50 za Nuru

Tumeunda uzoefu wa mtumiaji kwa nuru tajiri kwa kupeleka jumla ya moduli 50

Tulikuwa na rafu ambayo ilikuwa 1, 800mm upana na 1, 200mm kwa muda mrefu, na tuliunganisha kila swichi na moduli ili uweze kupata mazingira ya mvua na mvua ambayo tulipanga hapo awali, na tulikuwa na kila moduli kusimama peke yake kuwezesha kazi nyingi.

Kulingana na mchoro wa muundo, shimo pande zote lilichimbwa kwenye foemax ili kuficha usanikishaji na kuhakikisha kuwa eneo lililounganishwa la moduli ya LED haionekani. Kwa kuwa umbali kutoka kwa bodi ya akriliki hadi unganisho la moduli ya LED ambapo swichi imeunganishwa ni karibu 1cm, foemax nene ya 1cm ilitumika.

Sura ya mraba ya chuma ilitumika kushikilia usanikishaji pamoja na visu na vifungo vya kebo wakati wa kudumisha uzito wa jumla na usawa. Ikiwa urefu wa miunganisho iliyo wazi ni zaidi ya ile wakati mtengenezaji anajaribu, bodi nene haina tija na miundo mingine inapendekezwa.

Ili kuwezesha uzoefu wa mtumiaji katika kiwango cha jicho, usakinishaji uliokamilishwa umewekwa kwa msaada wa takriban 2m juu, lakini tahadhari ni kwamba ni ngumu sana kusanikisha moduli ya LED iliyoingizwa na swichi, kwa hivyo unganisho wote unapaswa kuondolewa. Tulipanda ngazi na tukaunganisha moduli na ufungaji uliowekwa kwenye msaada.

Sehemu muhimu zaidi ya mchakato huu wote ni kuhakikisha kuwa kazi inafanywa kwa usalama na salama kamili ili kuhakikisha kuwa uzoefu unawezekana katika mazingira salama

Jumla ya moduli 10 za arduino na 50 za LED zilitumika na moduli tano za LED ziliunganishwa kwa arduino kwa kazi nyingi za ufanisi na zisizo na mshono. Angalia ramani iliyoambatishwa kwa maelezo. Uwekaji wa alama nyingi za kutumia Neopixel ukitumia ubadilishaji kamili kulingana na mchoro wa muundo utajadiliwa kwa kina katika hatua inayofuata.

Hatua ya 5: Arduino Coding & Wiring

Wiring

• Moduli 50 ziliunganishwa kulingana na mpangilio wa hatua ya 4.
• Kila moduli iligawanywa katika seti 10 za moduli 50 kuwezesha kazi nyingi na kutoa unganisho wazi.
• Kama inavyoonyeshwa kwenye picha 1 iliyowekwa hapo juu, moduli tano ziliunganishwa na arduino moja, na pini 5v za neopixel zilifungwa pamoja mara moja kuunganisha usambazaji wa umeme.
• GND ya neopixels na swichi pia zilifungwa pamoja na, kwa urahisi wa mtazamo, swichi ziliunganishwa kwenye pini 2, 3, 4, 5, 6 na neopixels zilichomekwa kwenye pini 9, 10, 11, 12, 13.
• Swichi na neopixels ziliunganishwa kwa njia 2-9, 3-10, 4-11, 5-12, 6-13, mtawaliwa.
• Ikumbukwe kwamba kwa kuwa unganisho la laini ni ngumu na kuna hatari ya moto kwa sababu ya nyaya fupi, bomba linalopungua lilikuwa moto ili kuhakikisha kuwa sehemu dhaifu hazikuvunjika.

Uwekaji wa alama nyingi wa kazi ya Neopixel na swichi ya kuvuta

Uhuishaji 5 nyepesi (Aina ya Mvua, Aina ya kuoga, Aina ya umeme wa Spark, Aina ya picha, Aina isiyo ya kawaida)

# pamoja

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

muundo wa Enum / * 네오 픽셀 을 방향 을 설정 함 * / enum mwelekeo {MBELE, TENGENEZA};

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

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

/ * 변수 Muda 을 추가 * / muda usiosainiwa; / * 변수 mwishoSasisha 를 추가 * / haijasainishwa mwisho wa mwisho / * 변수 Rangi1, Rangi2 를 추가 * / uint32_t Rangi1, Rangi2; / * 변수 Jumla ya Hatua 를 추가 * / uint16_t Jumla ya Hatua; / * 변수 Kielelezo 를 추가 * / uint16_t Index;

/ * 패턴 을 완료 했을 시 다시 불러오는 함수 * / utupu (* OnComplete) (); / * 네오 패턴 에서 네오 픽샐 의, 핀, 타입, 콜백, 콜백 을 불러오는 함수 * / NeoPatterns (saizi uint16_t, uint8_t pin, uint8_t aina, batili (* callback) ()): Adafruit_NeoPixel (saizi, pini, chapa) { OnComplete = kupiga tena simu; }

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

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

/ * kesi THEATER_CHASE 에서는 TheatreChaseUpdate 를 실행 하라 * /

kesi THEATER_CHASE: TheatreChaseUpdate (); / * kesi THEATER_CHASE 에서 나와라 * / kuvunja;

/ * kesi COLOR_WIPE, Upakuaji wa Rangi ya Rangi 를 실행 하라 * /

kesi COLOR_WIPE: ColourWipeUpdate (); / * kesi COLOR_WIPE 에서 나와라 * / kuvunja; / * kesi ya skena 에서는 Sasisho la skana / * kesi ya skena 에서 나와라 * / mapumziko;

/ * kesi FADE, FadeUpdate 를 실행 하라 * /

kesi FADE: FadeUpdate (); / * kesi FADE 에서 나와라 * / kuvunja;

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

kesi TWINKLE: TwinkleUpdate (); / * kesi TWINKLE 에서 나와라 * / kuvunja;

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

kesi STAR: StarUpdate (); / * kesi STAR 에서 나와라 * / mapumziko;

/ * kesi RAINBOWSPARKLE 에서는 RainbowsparkleSasisha 를 실행 하라 * /

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

/ * kesi MWANGA 에서는 Mwisho Upya 를 실행 하라 * /

kesi MWANGA: LightUpdate (); / * kesi MWANGA 에서 나와라 * / kuvunja;

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

kesi BLOSSOM: BlossomUpdate (); / * kesi BLOSSOM 에서 나와라 * / kuvunja; }}}

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

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

Ongezeko batili () {/ * 만약 정방향 이면 인덱스 를 증가 시켜라 * / if (Direction == FORWARD) {Index ++; / * 만약 인덱스 전체 네오 픽셀 픽셀 갯수 갯수 와 거나 많다 면 0 으로 초기화 시켜라 * / if (Index> = Jumla ya Hatua) {Index = 0; / * 패턴 을 완료 시키는 함수 * / ikiwa (Imekamilika! = NULL) {InComplete (); }}}

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

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

Batili Reverse () {/ *; Index = Jumla ya Hatua - 1; } / * 그 외의 방향 이 정방향 이면 인덱스 를 0 으로 설정 해라 * / mwingine {Mwelekeo = MBELE; Kielelezo = 0; }}

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

* Mzunguko wa Upinde wa mvua 의 시간 과 방향 을 입력 * /

utupu wa RainbowCycle (uint8_t interval, mwelekeo dir = MBELE) {/ * 되는 되는 은 RainbowCycle 임 * / ActivePattern = RAINBOW_CYCLE; / * 시간 은 utupu wa Upinde wa mvua () 안에 입력 되는 muda 과 같음 * / Muda = muda; / * 총 구동 갯수 는 255 임 * / Jumla ya Hatua = 255; / * 인덱스 는 0 으로 설정 함 * / Index = 0; / * 은 id utupu wa Upinde wa mvua () 안에 입력 되는 dir = MBELE 과 같음 * / Mwelekeo = dir; }

/ * Upinde wa mvua Rainbow 를 업데이트 했을 경우 * /

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

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

TheatreChase (uint32_t color1, uint32_t color2, uint8_t interval, mwelekeo dir = MBELE) {/ * 되는 되는 패턴 은 RTHEATER_CHASE * / ActivePattern = THEATER_CHASE; / * 시간 은 batili TheatreChase () 안에 입력 되는 muda 과 같음 * / Interval = muda; / * 총 구동 갯수 는 numPixels 갯수 임 * / Jumla ya Hatua = numPixels (); / * 컬러 1, 2 를 설정 * / Rangi1 = rangi1; Rangi2 = rangi2; / * 인덱스 는 0 으로 설정 함 * / Index = 0; / * 은 id batili TheatreChase () 안에 입력 되는 dir = MBELE 과 같음 * / Mwelekeo = dir; }

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

batili TheatreChaseUpdate () {/ * 변수 i 가 픽셀 픽셀 개수 보다 작 i 를 증가 시켜라 * / for (int i = 0; i <numPixels (); i ++) {/ * 만약 변수 i 에 인덱스 를 더해서 3 으로 나눈 0이 0 과 같다 면 i 를 Rangi 로 변환 시켜라 * / ikiwa ((i + Index)% 3 == 0) {setPixelColor (i, Colour1); } / * 그렇지 않다면 i 를 Rangi 로 변환 시켜라 * / mwingine {setPixelColor (i, Colour2); }} / * 애니메이션 을 보여주는 함수 * / onyesha (); Ongezeko (); }

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

utupu ColourWipe (uint32_t color, uint8_t interval, direction dir = FORWARD) {/ * 실행 되는 패턴 은 COLOR_WIPE * / ActivePattern = COLOR_WIPE; / * 시간 은 batili ColorWipe () 안에 입력 되는 muda 과 같음 * / Interval = muda; / * 총 구동 갯수 는 numPixels 갯수 임 * / Jumla ya Hatua = numPixels (); / * 컬러 1 을 설정 * / Rangi1 = rangi; / * 인덱스 는 0 으로 설정 함 * / Index = 0; / * 은 은 batili ColorWipe () 안에 입력 되는 dir = MBELE 과 같음 * / Mwelekeo = dir; }

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

tupu ya ColorWipeUpdate () {/ * index 를 컬러 1 로 변환 시켜라 * / setPixelColor (Index, Colour1); / * 애니메이션 을 보여주는 함수 * / onyesha (); Ongezeko (); }

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

Skana tupu (uint32_t color1, uint8_t interval) {/ * 실행 되는 패턴 ANN SCANNER * / ActivePattern = SCANNER; / * 시간 은 tupu Scanner () 안에 입력 되는 muda 과 같음 * / Interval = muda; / * 구동 갯수 는 총 갯수 에서 1 을 빼고 2 를 곱 해라 * / Jumla ya Hatua = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Rangi1 = rangi1; / * 인덱스 는 0 으로 설정 함 * / Index = 0; }

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

ScannerUpdate ya batili () {/ * 변수 i 는 영 이고 총 갯수 보다 작을 i 를 증가 시켜라 * / for (int i = 0; i <numPixels (); i ++) {/ * 만약 i 가 인덱스 와 같다 면 i 를 color1 로 변환 시켜라 * / ikiwa (i == Index) {setPixelColor (i, Colour1); } / * 그렇지 않다면 변수 i 를 전체 구동 갯수 에서 인덱스 를 뺀값 과 같다 같다 * / mwingine ikiwa (i == TotalSteps - Index) {setPixelColor (i, Colour1); } / * 그 밖에는 i 를 디밍 시켜라 i 의 값 만큼 * / mwingine {setPixelColor (i, DimColor (getPixelColor (i))); }} / * 애니메이션 을 보여주는 함수 * / onyesha (); Ongezeko (); }

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

batili Fade (uint32_t color1, uint32_t color2, uint16_t hatua, uint8_t interval, mwelekeo dir = FORWARD) {/ * 실행 되는 패턴 은 FADE * / ActivePattern = FADE; / * 시간 은 batili Fade () 안에 입력 되는 muda 과 같음 * / Interval = muda; / * 구동 갯수 는 스텝 값임 * / Jumla ya Hatua = hatua; / * 컬러 1, 2 를 설정 * / Rangi1 = rangi1; Rangi2 = rangi2; / * 인덱스 는 0 으로 설정 함 * / Index = 0; / * 은 은 batili Fade () 안에 입력 되는 dir = MBELE 과 같음 * / Mwelekeo = dir; } / * FadeUpdate 를 업데이트 했을 경우 * / batili FadeUpdate () {/ * 변수 nyekundu 값 은 다음 과 같음 * / uint8_t red = ((Nyekundu (Rangi1) * (Jumla ya Hatua - Kiashiria)) + (Nyekundu (Rangi2) * Kiashiria Hatua za Jumla; / * 변수 kijani 값 은 다음 과 같음 * / uint8_t kijani = ((Kijani (Rangi1) * (Jumla ya Hatua - Kiashiria)) + (Kijani (Rangi2) * Kiashiria)) / Jumla ya Hatua; / * 변수 bluu 값 은 다음 과 같음 * / uint8_t bluu = ((Bluu (Rangi1) * (Jumla ya Hatua - Kiashiria)) + (Bluu (Rangi2) * Kiashiria)) / Jumla ya Hatua; / * 위 의 nyekundu, kijani, bluu 값 으로 컬러 를 셋팅 함 * / RangiSeti (Rangi (nyekundu, kijani, bluu)); / * 애니메이션 을 보여주는 함수 * / onyesha (); Ongezeko (); }

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

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

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

utupu Twinkle (uint32_t color1, uint8_t interval) {/ * 실행 되는 패턴 은 TWINKLE * / ActivePattern = TWINKLE; / * 은 은 tupu Twinkle () 안에 입력 되는 muda 과 같음 * / Interval = muda; / * 컬러 1 를 설정 * / Rangi1 = rangi1; / * 총 구동 갯수 는 numPixels 갯수 임 * / Jumla ya Hatua = numPixels (); Kielelezo = 0; }

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

utupu TwinkleUpdate () {/ * 모든 네오 픽셀 의 컬러 를 0 으로 셋팅 * / setAll (0, 0, 0); / * 변수 Pixel 은 bila mpangilio 74 * / int Pixel = nasibu (74); / * nasibu 74 개 에서 2 로나 눈 수 를 랜덤 하게 켜라 * / setPixelColor (Pixel / 2, 50, 100, 255); setiPixelColor (Pixel, 250, 255, 250); setiPixelColor (Pixel / 2, 200, 250, 255); setiPixelColor (Pixel, 255, 255, 255); setiPixelColor (Pixel, 250, 230, 250); setiPixelColor (Pixel / 2, 150, 200, 255); / * 애니메이션 을 보여주는 함수 * / onyesha (); / * 랜덤 하게 끄는 함수 * / setPixelColor (Pixel, 0, 0, 0); / * 애니메이션 을 보여주는 함수 * / onyesha (); Ongezeko (); }

/ * Nyota 컬러 컬러 1 값 을 입력 * /

Star batili (uint32_t color1) {/ * 실행 되는 패턴 은 STAR * / ActivePattern = STAR; / * 시간 은 batili Nyota () 안에 입력 되는 muda 과 같음 * / Interval = Muda; / * 총 구동 갯수 는 numPixels 갯수 임 * / Jumla ya Hatua = numPixels (); / * 컬러 1 을 설정 * / Rangi1 = rangi1; Kielelezo = 0; }

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

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

/ * Upinde wa mvua 의 시간 과 방향 을 입력 * /

utupu wa upinde wa mvua (uint8_t interval, mwelekeo dir = MBELE) {/ * 되는 되는 패턴 IN RAINBOWSPARKLE * / ActivePattern = RAINBOWSPARKLE; / * 시간 은 utupu wa mvua () 안에 입력 되는 muda 과 같음 * / Muda = muda; / * 총 구동 갯수 는 numPixels 갯수 임 * / Jumla ya Hatua = numPixels (); Kielelezo = 0; / * 방향 은 utupu wa mvua () 안에 입력 되는 mwelekeo 과 같음 * / Mwelekeo = dir; }

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

batili RainbowsparkleUpdate () {/ * 변수 i 가 0 이고 구동 갯수 보다 작 으면 i 값 을 증가 하는데 * / for (int i = 0; i <numPixels (); i ++) {/ * 변수 i 가 0 이고 구동 갯수 보다 If 으면 i 값 을 증가 하는데 * / ikiwa ((i + Index)% 2 == 0) {uint32_t c = nasibu (255); setiPixelColor (i, c); } mwingine {setPixelColor (i, nasibu (255)); }} / * 애니메이션 을 보여주는 함수 * / onyesha (); Ongezeko (); } / * Kimondo 의 시간 과 방향 을 입력 * / Utupu wa Kimondo (uint32_t color1) {/ * 실행 되는 패턴 은 METEOR * / ActivePattern = METEOR; / * 시간 설정 * / Muda = Muda; / * 총 구동 는 numPixels 갯수 에서 1 일뺀 후, * 2 를 한 것과 같음 * / TotalSteps = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Rangi1 = rangi1; Kielelezo = 0; }

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

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

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

Mwanga batili (uint32_t color1) {/ * 실행 되는 패턴 IGHT MWANGA * / ActivePattern = MWANGA; / * 시간 설정 * / Muda = Muda; / * 총 구동 는 P numPixels 갯수 에서 1 일뺀 후, * 2 를 한 것과 같음 * / Jumla ya Hatua = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Rangi1 = rangi1; Kielelezo = 0; }

/ * Mwisho wa Mwangaza 를 업데이트 했을 경우 * /

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

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

Blossom tupu (uint32_t color1) {/ * 실행 되는 패턴 은 BLOSSOM * / ActivePattern = BLOSSOM; / * 시간 설정 * / Muda = Kipindi; / * 총 구동 는 P numPixels 갯수 에서 1 일뺀 후, * 2 를 한 것과 같음 * / Jumla ya Hatua = (numPixels () - 1) * 2; / * 컬러 1 을 설정 * / Rangi1 = rangi1; Kielelezo = 0; }

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

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

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

/ * 네오 픽셀 켜지 는 위치 위치 색 을 지정지정, kijani, bluu); } onyesha (); }

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

uint32_t DimColor (rangi ya uint32_t) {// Shift R, G na B sehemu moja hadi kulia uint32_t dimColor = Rangi (Nyekundu (rangi) >> 1, Kijani (rangi) >> 1, Bluu (rangi) >> 1); kurudi dimColor; }

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

utupu ColourSet (uint32_t color) {for (int i = 0; i <numPixels (); i ++) {setPixelColor (i, color); } onyesha (); }

/ * 레드 값 을 불러 옴 * /

uint8_t Nyekundu (rangi ya uint32_t) {kurudi (rangi >> 16) & 0xFF; } / * 그린 값 을 불러 옴 * / uint8_t Kijani (rangi ya uint32_t) {kurudi (rangi >> 8) & 0xFF; } / * 블루 값 을 불러 옴 * / uint8_t Bluu (rangi ya uint32_t) {rangi ya kurudi & 0xFF; }

/ * Upinde wa mvua 컬러 를 불러 옴 * /

uint32_t Gurudumu (byte WheelPos) {WheelPos = 255 - WheelPos; ikiwa (WheelPos <85) {rangi ya kurudi (255 - WheelPos * 3, 0, WheelPos * 3); } kingine ikiwa (WheelPos <170) {WheelPos - = 85; Rudisha Rangi (0, WheelPos * 3, 255 - WheelPos * 3); } mwingine {WheelPos - = 170; Rudisha Rangi (WheelPos * 3, 255 - WheelPos * 3, 0); }}}};

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

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

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

#fafanua NUMPIXELS 74 / * 사용 하는 버튼 의 갯수 설정 * / #fafanua B_NUM 5 / * Ingiza strip1 ~ 5 까지, 는 는 74 개 스트립 연결 핀 은 strip1 은 8 ~ strip5 까지 12 * / NeoPatterns strip1 (74, 8, NEO_GRB + NEO_KHZ800, & strip1Kukamilika); Ukanda wa NeoPatterns2 (74, 9, NEO_GRB + NEO_KHZ800, & strip2Complete); Ukanda wa NeoPatterns3 (74, 10, NEO_GRB + NEO_KHZ800, & strip3Complete); Ukanda wa NeoPatterns4 (74, 11, NEO_GRB + NEO_KHZ800, & strip4Complete); Ukanda wa NeoPatterns5 (74, 12, NEO_GRB + NEO_KHZ800, & strip5Complete); / * 배열 을 사용한 연결 버튼 핀 설정 * / const int buttonPin [B_NUM] = {2, 3, 4, 5, 6}; / * 배열 을 사용 하여 버튼 상태 를 지정 해줌 * / kitufe cha Jimbo [B_NUM]; / * 2 번핀 부터 6 번핀 까지 상태 는 순서 대로 CHINI 임 * / int lastButtonState [B_NUM] = {CHINI, CHINI, CHINI, CHINI, CHINI}; / * 2 번핀 부터 6 번핀 까지 버튼 카운터 를 초기화 시킴 * / int buttonCounter [B_NUM] = {0, 0, 0, 0, 0}; / * 2 번핀 부터 6 번핀 까지 최대 버튼 카운터 는 5 임 * / int kifungoCounterMax = 5; / * 모든 버튼 핀 을 읽 일수 있도록 변수 추가 * / int kusoma [B_NUM]; muda usiotiwa saini wa mwishoWakati wa Kukataliwa [B_NUM] = {0, 0, 0, 0, 0}; / * 모든 버튼 핀 을 읽는 시간 간격 kuchelewesha50 과 같음 * / kutolewa kwa muda mrefu kusitishwaDelay = 50;

usanidi batili () {

/ * 복잡 하게 저항 연결 이 필요 없도록 인풋 풀업 방식 의 버튼 설정: GND - 5V (Unganisha kwa Nambari ya siri) * / for (int i = 0; i <B_NUM; i ++) {pinMode (buttonPin , INPUT_PULLUP); } Serial. Kuanza (9600); / * 스트립 1 ~ 5 를 셋팅 * / strip1.anza (); strip2.anza (); strip3.anza (); strip4.anza (); mkanda 5. anza ();

//strip1TheaterChase (strip1. Color(255, 0, 255), strip1. Color (255, 50, 0), 20, MBELE);

}

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

int counter = 5; kitanzi batili () {/ * 버튼 수 보다 i 가 작 i 를 증가 증가 시키고 * / for (int i = 0; i debounceDelay) {if (reading ! = buttonState ) {buttonState = kusoma ; kifungoCounter ++; / * 버튼 카운팅 이 위에서 설정 한 Max 값 5 를 넘으면 0 으로 초기화 시켜라. * / If (buttonCounter > buttonCounterMax) buttonCounter = 0; }} lastButtonState = kusoma ; } / * 모든 스트립 을 업데이트 함. * / Strip1. Sasisha (); mkanda 2. Sasisha (); ukanda 3. Sasisha (); mkanda 4. Sasisha (); mkanda 5. Sasisha ();

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

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

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

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

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

kubadili (buttonCounter [1]) {kesi 0: strip2. ActivePattern = STAR; strip2. Interval = 50; strip2. TotalSteps = strip2.numPixels (); kuvunja; kesi 1: strip2. ActivePattern = RAINBOWSPARKLE; strip2. Interval = 100; strip2. TotalSteps = strip2.numPixels (); kuvunja; kesi 2: strip2. ActivePattern = SCANNER; strip2. Interval = 20; strip2. TotalSteps = (strip2.numPixels () - 1) * 2; kuvunja; kesi 3: strip2. ActivePattern = TWINKLE; strip2. Interval = 5; strip2. TotalSteps = strip2.numPixels (); kuvunja; kesi ya 4: strip2. ActivePattern = METEOR; strip2. Interval = 40; strip2. TotalSteps = strip2.numPixels (); kuvunja; } Serial.print (kifungoCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

kubadili (buttonCounter [2]) {kesi 0: strip3. ActivePattern = STAR; strip3. Interval = 50; strip3. TotalSteps = strip3.numPixels (); kuvunja; kesi 1: strip3. ActivePattern = RAINBOWSPARKLE; strip3. Interval = 100; strip3. TotalSteps = strip3.numPixels (); kuvunja; kesi 2: strip3. ActivePattern = SCANNER; strip3. Interval = 20; strip3. TotalSteps = (strip3.numPixels () - 1) * 2; kuvunja; kesi 3: strip3. ActivePattern = TWINKLE; strip3. Interval = 5; strip3. TotalSteps = strip3.numPixels (); kuvunja; kesi ya 4: strip3. ActivePattern = METEOR; strip3. Interval = 25; strip3. TotalSteps = strip3.numPixels (); kuvunja; } Serial.print (kifungoCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

kubadili (buttonCounter [3]) {kesi 0: strip4. ActivePattern = STAR; strip4. Interval = 50; strip4. TotalSteps = strip4.numPixels (); kuvunja; kesi 1: strip4. ActivePattern = RAINBOWSPARKLE; strip4. Interval = 100; strip4. TotalSteps = strip4.numPixels (); kuvunja; kesi 2: strip4. ActivePattern = SCANNER; strip4. Interval = 20; strip4. TotalSteps = (strip4.numPixels () - 1) * 2; kuvunja; kesi 3: strip4. ActivePattern = TWINKLE; strip4. Interval = 5; strip4. TotalSteps = strip4.numPixels (); kuvunja; kesi ya 4: strip4. ActivePattern = METEOR; strip4. Interval = 25; strip4. TotalSteps = strip4.numPixels (); kuvunja; } Serial.print (kifungoCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]);

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

kubadili (buttonCounter [4]) {kesi 0: strip5. ActivePattern = STAR; strip5. Interval = 50; strip5. TotalSteps = strip5.numPixels (); kuvunja; kesi 1: strip5. ActivePattern = RAINBOWSPARKLE; strip5. Interval = 100; strip5. TotalSteps = strip5.numPixels (); kuvunja; kesi 2: strip5. ActivePattern = SCANNER; strip5. Interval = 20; strip5. TotalSteps = (strip5.numPixels () - 1) * 2; kuvunja; kesi 3: strip5. ActivePattern = TWINKLE; ukanda 5. Interval = 5; strip5. TotalSteps = strip5.numPixels (); kuvunja; kesi ya 4: strip5. ActivePattern = METEOR; ukanda 5. Interval = 25; strip5. TotalSteps = strip5.numPixels (); kuvunja; } Serial.print (kifungoCounter [0]); Serial.print (","); Serial.println (buttonCounter [1]); }

// strip1 Kukamilisha Kupiga tena

utupu strip1Complete () {strip1. Color1 = strip1. Wheel (nasibu (255)); strip1. Color2 = strip1. Weel (random (255)); strip1. Index = 0; }

// strip2 Kukamilisha Kupiga tena

utupu strip2Complete () {strip2. Color1 = strip2. Wheel (random (255)); strip2. Color2 = strip2. Wheel (bila mpangilio (255)); strip2. Index = 0; }

// strip3 Kukamilisha Kupiga tena

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

// strip4 Kukamilisha Kupiga tena

utupu strip4Complete () {strip4. Color1 = strip4. Wheel (nasibu (255)); strip4. Color2 = strip4. Weel (random (255)); strip4. Index = 0; }

// strip5 Kukamilisha Kupiga tena

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

Hatua ya 6: Matokeo na Kutengeneza Filamu

Asante kwa masilahi yako katika mradi wetu ingawa haitoshi.