लाइट खींचो - नियोपिक्सल और पुल अप स्विच का उपयोग करके लाइट मॉड्यूल: 6 कदम (चित्रों के साथ)

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:21

लाइट मॉड्यूल की विशेषताएं

• Arduino Uno
• इंटरनेट से खरीदा गया हार्डवेयर और संलग्नक
• स्कूल ऑफ इंफॉर्मेटिक्स एंड प्रोडक्ट डिजाइन से उधार लिया गया Neopixel और बिजली की आपूर्ति
• बिजली आपूर्ति द्वारा नियंत्रित लाइट मॉड्यूल
• उपयोगकर्ता इंटरैक्शन के माध्यम से नियंत्रित सभी कार्य
• नियोपिक्सल स्ट्रिप के एनिमेशन प्रकार: रेन टाइप, शावर टाइप, स्पार्क लाइटनिंग टाइप, पॉप टाइप, अनियमित टाइप
• पुल अप स्विच Neopixel स्ट्रिप से जुड़ा होता है और Neopixel स्ट्रिप खींचने पर एनिमेशन बदल जाता है

चरण 1: शुरू करने से पहले

हैलो इंस्ट्रक्शंस और मेकर्स।

यदि हम प्रकाश के एनीमेशन के माध्यम से बारिश की भावना को महसूस कर सकते हैं तो क्या होगा, इसके संदर्भ में हमने इंटरेक्टिव डिजाइन प्रोजेक्ट शुरू किया और शुरू किया। मैंने सोचा था कि उपयोगकर्ता की संवेदनशीलता को एक इंटरफ़ेस के माध्यम से अधिकतम किया जाएगा जो सीधे प्रकाश खींचता है।

चलो काम पर लग जाओ

चरण 2: भागों की आवश्यकता

एक लाइट मॉड्यूल पर आधारित

*** हमारे विभाग के सहयोग से नियोपिक्सल और बिजली आपूर्ति का उपयोग किया गया। ***

इलेक्ट्रॉनिक्स:

1. Arduino Uno
2. 3 रंग तार (काला, लाल, कोई भी रंग)
3. 3pin कनेक्टर (खरीदने के लिए लिंक)
4. पुल अप स्विच 1 (खरीदने के लिए लिंक)
5. सिकुड़ती नली
6. WS2812b 74 LED (नियोपिक्सल स्ट्रिप) के साथ एड्रेसेबल LED स्ट्रिप*2
7. बिजली की आपूर्ति (5V 350A) 1

*** Arduino, पुल स्विच और NeoPixels के लिए ५० सेट की आवश्यकता है।***

हार्डवेयर:

1. एक्रिलिक बार 2t (10 मिमी * 1000 मिमी) 1
2. एक्रिलिक बोर्ड 5t (60 मिमी * 60 मिमी) 1
3. फोमेक्स 10t (1200mm*1800mm) 1
4. काला स्प्रे
5. केबल टाई
6. डोरी
7. हार्डबोर्ड
8. ग्रिड बोर्ड

चरण 3: कनेक्टिविटी और हार्डवेयर का निर्माण

सबसे पहले, हमें एक प्रकाश मॉड्यूल बनाने के लिए ऐक्रेलिक कटिंग की आवश्यकता होती है।

• प्रकाश के एनीमेशन का अनुभव करने के साधन के रूप में, एक प्रकाश मॉड्यूल का मसौदा तैयार करें जो कि 1M क्षेत्र के साथ 2 मिमी मोटी एक्रिलिक बार पर एक नियोपिक्सल पट्टी के रूप में 74 एल ई डी संलग्न करके तय किया गया है। हमने दो प्रकार के प्रकाश मॉड्यूल तैयार किए हैं: विशिष्ट रैखिक और सर्पिल।
• रैखिक प्रकारों के लिए, मौजूदा नियोपिक्सल स्ट्रिप्स को पकड़कर सुरक्षित किया जा सकता है, लेकिन सर्पिल प्रकारों के लिए मैन्युअल ऑपरेशन की आवश्यकता होती है। 74 एलईडी में से प्रत्येक को टुकड़ों में विभाजित किया गया है, एक सर्पिल ऐक्रेलिक से जुड़ा हुआ है, और सीसा के साथ एक साथ बंधे हैं।

ऐक्रेलिक के लिए Neopixel पट्टी संलग्न करें और प्रत्येक पट्टी को गर्मी से फैलने से रोकने के लिए सुरक्षित करें, या एक पतली मछली पकड़ने की रेखा के साथ बांधें। रैखिक प्रकार के मामले में, मॉड्यूल के अंत में खींचने के लिए आवश्यक गोले को सौंदर्य रूप देने के लिए स्थापित किया गया था और हमने पिंग पोंग बॉल को एक काले स्प्रे के साथ समाप्त किया। फिर उन्होंने पिंग पोंग बॉल में एक छोटा सा छेद ड्रिल किया और उसे रस्सी से जोड़ दिया। अगला सबसे महत्वपूर्ण हिस्सा, स्विच और नियोपिक्सल, दिखाए गए अनुसार जुड़ा हुआ है। फिर स्विच को सीलिंग शेल्फ पर सुरक्षित किया जाता है।

सर्पिल प्रकार के मामले में, एक जोखिम है कि सर्पिल मॉड्यूल के सीधे खींचने से ऐक्रेलिक दबाव में टूट सकता है, इसलिए पुल सेक्शन (इनपुट) और मॉड्यूल (आउटपुट) अलग हो गए थे। प्रकाश गिरने को अधिकतम करने के लिए, छत पर लंबवत रूप से मॉड्यूल स्थापित किए गए थे, रैखिक मॉड्यूल हवा के लिए तय किए गए थे, सर्पिल सीधे छत पर तय किए गए थे। और हमने पिंग पोंग बॉल और स्विच को फिशिंग लाइन से जोड़ा ताकि इसे संचालित किया जा सके।

शेल्फ पर स्विच को सुरक्षित करने के लिए ऊपर दिए गए चित्र में दिखाए गए ऐक्रेलिक कटिंग की आवश्यकता होती है। एक 6 सेमी चौकोर आकार का स्विच लगभग 5 मिमी मोटा होता है, जिसमें स्विच केंद्रित होता है और स्विच को मजबूती से सुरक्षित करने के लिए दोनों तरफ छेद के माध्यम से एक केबल टाई डाली जाती है। केंद्र के नीचे एक गोलाकार छेद स्विच के खिंचाव को उजागर करता है, जिसके नीचे एक तीन तार केबल को बाहर निकाला जाता है और मॉड्यूल के केबल टर्मिनल से जोड़ा जाता है। और इसी तरह, चार कोनों में एक छेद के माध्यम से, शेल्फ और एक्रिलिक केबल संबंधों से सुरक्षित होते हैं। जैसा कि ऊपर वर्णित है, रैखिक मॉड्यूल सीधे पुल से जुड़ा है, लेकिन सर्पिल मॉड्यूल पिन और स्विच को अलग से जोड़ता है।

चरण 4: 50 लाइट मॉड्यूल का उपयोग करके बनाएं

हमने कुल 50 मॉड्यूलों को तैनात करके बेहतर रोशनी के लिए एक उपयोगकर्ता अनुभव तैयार किया है।

हमारे पास एक शेल्फ था जो 1, 800 मिमी चौड़ा और 1, 200 मिमी लंबा था, और हमने प्रत्येक स्विच और मॉड्यूल को जोड़ा ताकि आप बारिश और बारिश के वातावरण का अनुभव कर सकें, जिसकी हमने शुरुआत में योजना बनाई थी, और मल्टी-टास्किंग को सक्षम करने के लिए हमारे पास प्रत्येक मॉड्यूल अकेला था।.

डिजाइन ड्राइंग के आधार पर, स्थापना को छिपाने के लिए और यह सुनिश्चित करने के लिए कि एलईडी मॉड्यूल का जुड़ा क्षेत्र दिखाई नहीं दे रहा है, फोमेक्स में एक गोल छेद ड्रिल किया गया था। चूंकि ऐक्रेलिक बोर्ड से एलईडी मॉड्यूल कनेक्शन की दूरी जहां स्विच जुड़ा हुआ है, लगभग 1 सेमी है, इसलिए 1 सेमी मोटी फोमेक्स का उपयोग किया गया था।

समग्र वजन और संतुलन बनाए रखते हुए धातु वर्ग फ्रेम का उपयोग स्क्रू और केबल संबंधों के साथ स्थापना को पकड़ने के लिए किया गया था। यदि उजागर कनेक्शन की लंबाई निर्माता के प्रयास से अधिक है, तो मोटा बोर्ड अक्षम है और अन्य संरचनाओं की सिफारिश की जाती है।

आंखों के स्तर पर उपयोगकर्ता के अनुभव को सुविधाजनक बनाने के लिए, पूर्ण स्थापना को लगभग 2 मीटर ऊंचे समर्थन पर रखा गया है, लेकिन सावधानी यह है कि स्विच के साथ एम्बेडेड एलईडी मॉड्यूल स्थापित करना बहुत बोझिल है, इसलिए सभी कनेक्शन हटा दिए जाने चाहिए। हम सीढ़ी पर चढ़ गए और समर्थन पर तय की गई स्थापना के साथ मॉड्यूल को जोड़ा।

इस पूरी प्रक्रिया का सबसे महत्वपूर्ण हिस्सा यह सुनिश्चित करना है कि काम सुरक्षित और पूरी तरह से सुरक्षित हो ताकि यह सुनिश्चित हो सके कि एक सुरक्षित वातावरण में अनुभव संभव हो सके।

कुल 10 arduino और 50 LED मॉड्यूल का उपयोग किया गया था और अधिक कुशल और निर्बाध मल्टी-टास्किंग के लिए प्रति arduino में पांच LED मॉड्यूल जुड़े हुए थे। विवरण के लिए संलग्न ब्लूप्रिंट देखें। डिज़ाइन आरेख के अनुसार पूर्ण स्विच का उपयोग करके Neopixel मल्टी-टास्किंग कोडिंग पर अगले चरण में विस्तार से चर्चा की जाएगी।

चरण 5: Arduino कोडिंग और वायरिंग

तारों

• चरण 4 के लेआउट के अनुसार 50 मॉड्यूल जुड़े हुए थे।
• मल्टी-टास्किंग को सक्षम करने और एक स्पष्ट कनेक्शन प्रदान करने के लिए प्रत्येक मॉड्यूल को 50 मॉड्यूल के 10 सेट में विभाजित किया गया था।
• जैसा कि ऊपर सेट 1 छवि में दिखाया गया है, पांच मॉड्यूल एक एकल arduino से जुड़े थे, और बिजली की आपूर्ति को जोड़ने के लिए नियोपिक्सल के 5v पिन एक साथ बंधे थे।
• नियोपिक्सल और स्विच के जीएनडी को भी एक साथ बांधा गया था और, धारणा में आसानी के लिए, स्विच को पिन २, ३, ४, ५, ६ में प्लग किया गया था और नियोपिक्सल को पिन ९, १०, ११, १२, १३ में प्लग किया गया था।.
• स्विच और नियोपिक्सल क्रमशः 2-9, 3-10, 4-11, 5-12, 6-13 तरीकों से जुड़े थे।
• यह ध्यान दिया जाना चाहिए कि चूंकि लाइनों के कनेक्शन जटिल हैं और शॉर्ट सर्किट के कारण आग लगने का खतरा है, कमजोर भागों को तोड़ने के लिए सिकुड़ते ट्यूब को गर्म किया गया था।

पुल अप स्विच के साथ नियोपिक्सल मल्टी-टास्किंग कोडिंग

5 प्रकाश एनिमेशन (वर्षा प्रकार, शावर प्रकार, स्पार्क बिजली प्रकार, पॉप प्रकार, अनियमित प्रकार)

#शामिल

/*사용하고자하는 */

एनम पैटर्न {कोई नहीं, RAINBOW_CYCLE, THEATER_CHASE, COLOR_WIPE, SCANNER, FADE, TWINKLE, STAR, RAINBOWSPARKLE, METEOR, LIGHT, BLOSSOM}; /*네오 */ एनम दिशा { आगे, पीछे };

/*패턴의 */

वर्ग NeoPattern: सार्वजनिक Adafruit_NeoPixel {/* */ सार्वजनिक: पैटर्न ActivePattern; /*클레스 */दिशा दिशा;

/*변수 अंतराल을 */ अहस्ताक्षरित लंबा अंतराल; /*변수 lastUpdate를 */ unsigned long lastUpdate; /*변수 Color1, Color2를 */ uint32_t Color1, Color2; /*변수 टोटलस्टेप्स를 */ uint16_t टोटलस्टेप्स; /*변수 सूचकांक를 */ uint16_t सूचकांक;

/*패턴을 */ शून्य (*पूर्ण पूर्ण) (); /*네오패턴에서, 핀번호,, */ NeoPatterns(uint16_t पिक्सेल, uint8_t पिन, uint8_t प्रकार, शून्य (*कॉलबैक) ()): Adafruit_NeoPixel(पिक्सेल, पिन, प्रकार){ पूर्ण = कॉलबैक; }

/*패턴을 */

शून्य अद्यतन(){ /*패턴의. */ अगर ((मिली () - अंतिम अद्यतन) > अंतराल) {अंतिम अद्यतन = मिली (); /*ActivePattern의 */ स्विच (ActivePattern) {/*केस RAINBOW_CYCLE에서는 RainbowCycleUpdate를 */ केस RAINBOW_CYCLE: RainbowCycleUpdate(); /*केस RAINBOW_CYCLE에서 */ ब्रेक;

/*केस THEATER_CHASE에서는 Theatre ChaseUpdate를 */

मामला THEATER_CHASE: TheatreCaseUpdate (); /*केस THEATER_CHASE에서 */ ब्रेक;

/*केस COLOR_WIPE에서는 ColorWipeUpdate를 */

मामला COLOR_WIPE: ColorWipeUpdate (); /*केस COLOR_WIPE에서 */ ब्रेक; /*केस स्कैनर에서는 स्कैनरअपडेट를 */ केस स्कैनर: स्कैनरअपडेट (); /*केस स्कैनर에서 */ ब्रेक;

/*केस FADE에서는 FadeUpdate를 */

मामला फीका: FadeUpdate (); /*केस FADE에서 */ ब्रेक;

/*केस ट्विंकल에서는 ट्विंकलअपडेट를 */

केस ट्विंकल: ट्विंकलअपडेट (); /*केस ट्विंकल */ ब्रेक;

/*केस स्टार에서는 स्टारअपडेट를 */

केस स्टार: स्टारअपडेट (); /*केस स्टार에서 */ ब्रेक;

/*केस रेनबोस्पार्कल에서는 रेनबोस्पार्कलअपडेट를 */

केस रेनबोस्पार्कल: रेनबोस्पार्कलअपडेट (); /*केस रेनबोस्पार्कल에서 */ ब्रेक; /*केस METEOR에서는 MeteorUpdate를 */ Case METEOR: MeteorUpdate(); /*केस METEOR에서 */ ब्रेक;

/*केस लाइट에서는 लाइटअपडेट를 */

केस लाइट: लाइटअपडेट (); /*केस लाइट에서 */ ब्रेक;

/*केस ब्लॉसम에서는 ब्लॉसमअपडेट를 */

केस ब्लॉसम: ब्लॉसमअपडेट (); /*केस ब्लॉसम에서 */ ब्रेक; } } }

/*패턴의 */

/*सूचकांक를 */

शून्य वेतन वृद्धि () {/*만약 */ अगर (दिशा == आगे) {सूचकांक ++; /*만약 0으로 */ अगर (इंडेक्स>= टोटलस्टेप्स){ इंडेक्स = 0; /*패턴을 */ अगर (पूर्ण पूर्ण!= NULL){ पूर्ण पूर्ण (); } } }

/*만약 */ अन्य{ --इंडेक्स; /*만약 1을빼라*/ अगर (इंडेक्स <= 0){ इंडेक्स = टोटलस्टेप्स -1; /*패턴을 */ अगर (पूर्ण पूर्ण!= NULL){ पूर्ण पूर्ण (); } } } }

/*반대방향으로 */

शून्य रिवर्स () {/*애니메이션 रिवर्स를, */ अगर (दिशा == आगे){/*방향은 반대이며 1일빼라*/ दिशा = रिवर्स; इंडेक्स = टोटलस्टेप्स - 1; } /*그 0으로 */ अन्य{ दिशा = आगे; सूचकांक = 0; } }

/*애니메이션을 *

*इंद्रधनुष साइकिल의 */

शून्य इंद्रधनुष चक्र (uint8_t अंतराल, दिशा dir = आगे) {/*실행되는 इंद्रधनुष चक्र임*/ ActivePattern = RAINBOW_CYCLE; /*시간은 शून्य इंद्रधनुष चक्र ()안에 입력되는 अंतराल과 같음*/ अंतराल = अंतराल; /*총 २५५임*/ टोटलस्टेप्स = २५५; /*인덱스는 0으로 */ सूचकांक = 0; /*방향은 शून्य इंद्रधनुष चक्र ()안에 dir = आगे과 */ दिशा = dir; }

/*इंद्रधनुष साइकिल를 */

void RainbowCycleUpdate(){ /*변수 i가 i를 증가시켜라*/ for (int i = 0; i < numPixels(); i++){ /*변수 i가 동시에 RGB의 */ setPixelColor(i, Wheel(((i * 256 / numPixels ()) + इंडेक्स) और 255); } /*애니메이션을 */ शो (); वेतन वृद्धि (); }

/*थियेटरचेज़의 */

शून्य थियेटरचेज़ (uint32_t color1, uint32_t color2, uint8_t अंतराल, दिशा dir = FORWARD){/*실행되는 RTHEATER_CHASE*/ ActivePattern = THEATER_CHASE; /*시간은 शून्य थियेटरचेज़ ()안에 अंतराल과 */ अंतराल = अंतराल; /*총 numPixels갯수임*/ TotalSteps = numPixels (); /*컬러 1, 2를 */ Color1 = color1; रंग २ = रंग २; /*인덱스는 0으로 */ सूचकांक = 0; /*방향은 शून्य थियेटरचेज़ ()안에 dir = फॉरवर्ड과 */ दिशा = dir; }

/*थियेटरचेज़를 */

शून्य थियेटरचेसअपडेट(){ /*변수 i가 i를 */ के लिए (int i = 0; i < numPixels(); i++){ /*만약 i에 3으로 0과 같다면 i를 रंग로 */ अगर ((i + अनुक्रमणिका)% 3 == 0) {setPixelColor (i, Color1); } /*그렇지 i를 Color로 */else{ setPixelColor(i, Color2); } } /*애니메이션을 */ शो (); वेतन वृद्धि (); }

/*कलरवाइप의 */

शून्य ColorWipe(uint32_t रंग, uint8_t अंतराल, दिशा dir = FORWARD){/*실행되는 COLOR_WIPE*/ ActivePattern = COLOR_WIPE; /*시간은 शून्य ColorWipe()안에 अंतराल과 */ अंतराल = अंतराल; /*총 numPixels갯수임*/ TotalSteps = numPixels (); /*컬러 1을 */ Color1 = color; /*인덱스는 0으로 */ सूचकांक = 0; /*방향은 शून्य ColorWipe()안에 dir = FORWARD과 */ दिशा = dir; }

/*कलरवाइपअपडेट를 */

शून्य ColorWipeUpdate(){/*index를 1로 */ setPixelColor(Index, Color1); /*애니메이션을 */ शो (); वेतन वृद्धि (); }

/*स्कैनर의 */

शून्य स्कैनर (uint32_t color1, uint8_t अंतराल) {/*실행되는 स्कैनर*/ ActivePattern = स्कैनर; /*시간은 शून्य स्कैनर ()안에 अंतराल과 */ अंतराल = अंतराल; /*구동갯수는 1을빼고 2를 */ TotalSteps = (numPixels() - 1) * 2; /*컬러 1을 */ Color1 = color1; /*인덱스는 0으로 */ सूचकांक = 0; }

/*स्कैनरअपडेट를 */

शून्य स्कैनरअपडेट(){/*변수 i는 i를 */ for (int i = 0; i < numPixels(); i++){ /*만약 i가 같다면 i 를 color1로 */ if (i == Index){ setPixelColor(i, Color1); } /*그렇지 i를 */ और अगर (i == TotalSteps - Index){ setPixelColor(i, Color1); } /*그 i를 i의 값만큼 */else {setPixelColor(i, DimColor(getPixelColor(i))); } } /*애니메이션을 */ शो (); वेतन वृद्धि (); }

/*स्कैनर의 1, 2와,, */

शून्य फीका (uint32_t color1, uint32_t color2, uint16_t चरण, uint8_t अंतराल, दिशा dir = आगे) {/*실행되는 FADE*/ ActivePattern = FADE; /*시간은 शून्य फीका ()안에 अंतराल과 */ अंतराल = अंतराल; /*구동갯수는 */ टोटलस्टेप्स = स्टेप्स; /*컬러 1, 2를 */ Color1 = color1; रंग २ = रंग २; /*인덱스는 0으로 */ सूचकांक = 0; /*방향은 शून्य फीका ()안에 dir = आगे과 */ दिशा = dir; } /*FadeUpdate를 */ void FadeUpdate(){ /*변수 red값은 */ uint8_t red = ((Red(Color1) * (TotalSteps - Index)) + (Red(Color2) * Index)) / टोटलस्टेप्स; /*변수 हरा값은 */ uint8_t हरा = ((हरा(रंग1) * (कुल कदम - सूचकांक)) + (हरा(रंग2) * सूचकांक)) / कुल कदम; /*변수 नीला값은 */ uint8_t नीला = ((नीला(रंग1) * (कुल कदम - सूचकांक)) + (नीला(रंग2) * सूचकांक)) / कुल कदम; /*위의 लाल, हरा, नीला */ ColorSet(रंग (लाल, हरा, नीला)); /*애니메이션을 */ शो (); वेतन वृद्धि (); }

/*모든 */

शून्य ऑलऑफ़ () {/*총 ७४개이며*/इंट एनपीआईएक्सईएल = ७४; /*변수 i가 0으로 */ के लिए (int i = 0; i <NPIXEL; i++) {setPixelColor(i, 0, 0, 0); } }

/*ट्विंकल의 1와 */

शून्य ट्विंकल(uint32_t color1, uint8_t अंतराल){/*실행되는 TWINKLE*/ ActivePattern = TWINKLE; /*시간은 शून्य ट्विंकल ()안에 अंतराल과 */ अंतराल = अंतराल; /*컬러 1를 */ Color1 = color1; /*총 numPixels갯수임*/ TotalSteps = numPixels (); सूचकांक = 0; }

/*ट्विंकलअपडेट를 */

शून्य ट्विंकलअपडेट () {/*모든 0으로 */सेटऑल(0, 0, 0); /*변수 पिक्सेल은 यादृच्छिक 74*/ इंट पिक्सेल = यादृच्छिक(74); /*यादृच्छिक 74개에서 2로나눈 */ सेट पिक्सेल रंग (पिक्सेल/2, 50, 100, 255); सेट पिक्सेल रंग (पिक्सेल, 250, 255, 250); सेट पिक्सेल रंग (पिक्सेल / 2, 200, 250, 255); सेट पिक्सेल रंग (पिक्सेल, 255, 255, 255); सेट पिक्सेल रंग (पिक्सेल, 250, 230, 250); सेट पिक्सेल रंग (पिक्सेल / 2, 150, 200, 255); /*애니메이션을 */ शो (); /*랜덤하게 */ setPixelColor(Pixel, 0, 0, 0); /*애니메이션을 */ शो (); वेतन वृद्धि (); }

/*स्टार의 1 */

शून्य सितारा(uint32_t color1){ /*실행되는 STAR*/ ActivePattern = STAR; /*시간은 शून्य तारा ()안에 अंतराल과 */ अंतराल = अंतराल; /*총 numPixels갯수임*/ TotalSteps = numPixels (); /*컬러 1을 */ Color1 = color1; सूचकांक = 0; }

/*स्टारअपडेट를 */

शून्य StarUpdate(){/*인덱스와 */ setPixelColor(Index, Color1); प्रदर्शन(); /*변수 i가 0이고 i를 = */ के लिए (int i = 0; i < numPixels (); i--) {setPixelColor(i, Color(0, 0, 0)); } /*애니메이션을 */ वेतन वृद्धि (); }

/*रेनबोस्पार्कल의 */

शून्य रेनबोस्पार्कल(uint8_t अंतराल, दिशा dir = आगे){/*실행되는 रेनबोस्पार्कल*/ एक्टिवपैटर्न = रेनबोस्पार्कल; /*시간은 शून्य रेनबोस्पार्कल ()안에 입력되는 अंतराल과 같음*/ अंतराल = अंतराल; /*총 numPixels갯수임*/ TotalSteps = numPixels (); सूचकांक = 0; /*방향은 रेनबोस्पार्कल ()안에 दिशा과 */ दिशा = डीआईआर; }

/*रेनबोस्पार्कलअपडेट를 */

void RainbowsparkleUpdate(){/*변수 i가 0이고 i값을 증가하는데*/ for (int i = 0; i < numPixels(); i++){ /*변수 i가 0이고 i값을 */ अगर ((i + इंडेक्स)% 2 == 0){ uint32_t c = random(255); सेट पिक्सेल रंग (आई, सी); } और {setPixelColor (i, रैंडम (255)); } } /*애니메이션을 */ शो (); वेतन वृद्धि (); } /*उल्का의 */ शून्य उल्का(uint32_t color1){ /*실행되는 METEOR*/ ActivePattern = METEOR; /*시간 */ अंतराल = अंतराल; /*총 numPixels갯수에서 1일뺀, *2를 */ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 */ Color1 = color1; सूचकांक = 0; }

/*उल्का अद्यतन를 */

शून्य उल्का अद्यतन () {के लिए (int i = 0; i < numPixels (); i ++) {if (i == अनुक्रमणिका) {setPixelColor (i, १००, यादृच्छिक (२५५), २५५); } और {setPixelColor (i, DimColor (getPixelColor (i))); } } /*애니메이션을 */ शो (); वेतन वृद्धि (); }

/*प्रकाश의 */

शून्य प्रकाश(uint32_t color1){/*실행되는 प्रकाश*/ ActivePattern = LIGHT; /*시간 */ अंतराल = अंतराल; /*총 numPixels갯수에서 1일뺀, *2를 */ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 */ Color1 = color1; सूचकांक = 0; }

/*लाइटअपडेट를 */

शून्य लाइटअपडेट () {के लिए (int i = 0; i < numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, १५०, रैंडम (२००), ४०); } और {setPixelColor (i, DimColor (getPixelColor (i))); } } /*애니메이션을 */ शो (); वेतन वृद्धि (); }

/*खिलना의 */

शून्य खिलना(uint32_t color1){ /*실행되는 BLOSSOM*/ ActivePattern = BLOSSOM; /*시간 */ अंतराल = अंतराल; /*총 numPixels갯수에서 1일뺀, *2를 */ TotalSteps = (numPixels()-1) * 2; /*컬러 1을 */ Color1 = color1; सूचकांक = 0; }

/*ब्लॉसमअपडेट를 */

शून्य ब्लॉसमअपडेट () {के लिए (int i = 0; i < numPixels (); i ++) {if (i == TotalSteps - Index) {setPixelColor (i, 255, रैंडम (255), 100); } और {setPixelColor (i, DimColor (getPixelColor (i))); } } /*애니메이션을 */ शो (); वेतन वृद्धि (); }

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

/*네오픽셀의 */ शून्य सेटऑल (बाइट रेड, बाइट ग्रीन, बाइट ब्लू) { for(int i = 0; i < numPixels(); i++) { setPixelColor(i, red, हरा, नीला); } प्रदर्शन(); }

/*네오픽셀의, */

uint32_t DimColor (uint32_t रंग) {// R, G और B घटकों को दाईं ओर शिफ्ट करें uint32_t dimColor = रंग (लाल (रंग) >> 1, हरा (रंग) >> 1, नीला (रंग) >> 1); वापसी मंद रंग; }

/*모든 */

शून्य रंगसेट (uint32_t रंग) {के लिए (int i = 0; i < numPixels (); i ++) {setPixelColor (i, रंग); } प्रदर्शन(); }

/*레드값을 */

uint8_t लाल (uint32_t रंग) {वापसी (रंग >> 16) और 0xFF; } /*그린값을 */ uint8_t हरा (uint32_t रंग) {वापसी (रंग >> 8) और 0xFF; } /*블루값을 */ uint8_t नीला (uint32_t रंग) {वापसी रंग और 0xFF; }

/*इंद्रधनुष */

uint32_t Wheel(बाइट WheelPos){ WheelPos = 255 - WheelPos; अगर (व्हीलपॉस <85) {रिटर्न कलर (255 - व्हीलपॉस * 3, 0, व्हीलपॉस * 3); } और अगर (व्हीलपॉस <१७०) {व्हीलपॉज़ - = ८५; वापसी रंग (0, व्हीलपॉस * 3, 255 - व्हीलपॉस * 3); } और { व्हीलपोस - = १७०; वापसी रंग (व्हीलपॉस * 3, 255 - व्हीलपॉस * 3, 0); } } };

/*पट्टी을 / *사용하는 */

शून्य पट्टी 1 पूर्ण (); शून्य पट्टी 2 पूर्ण (); शून्य पट्टी 3 पूर्ण (); शून्य पट्टी 4 पूर्ण (); शून्य पट्टी 5 पूर्ण ();

/*네오픽셀의 */

#परिभाषित करें NUMPIXELS 74 /*사용하는 */ #परिभाषित करें B_NUM 5 /*आयात पट्टी1~5까지, 개 74개 स्ट्रिप1은 8 ~ स्ट्रिप5까지12*/ नियोपैटर्न स्ट्रिप1(74, 8, NEO_GRB + NEO_KHZ800, &strip1पूर्ण); NeoPatterns strip2(74, 9, NEO_GRB + NEO_KHZ800, &strip2Complete); नियोपैटर्न स्ट्रिप3(74, 10, NEO_GRB + NEO_KHZ800, &strip3Complete); नियोपैटर्न स्ट्रिप4(74, 11, NEO_GRB + NEO_KHZ800, &strip4Complete); नियोपैटर्न स्ट्रिप5(74, 12, NEO_GRB + NEO_KHZ800, &strip5Complete); /*배열을 */ const int बटनपिन[B_NUM] = {2, 3, 4, 5, 6}; /*배열을 */ इंट बटनस्टेट[B_NUM]; /*2번핀부터 6번핀까지 LOW임*/ int lastButtonState[B_NUM] = {लो, लो, लो, लो, लो}; /*2번핀부터 6번핀까지 */ int बटन काउंटर [B_NUM] = {0, 0, 0, 0, 0}; /*२번핀부터 ६번핀까지 ५임*/ इंट बटन काउंटरमैक्स = ५; /*모든 */ इंट रीडिंग[B_NUM]; अहस्ताक्षरित लॉन्ग लास्टडेबॉन्सटाइम[B_NUM] = {0, 0, 0, 0, 0}; /*모든 देरी50과 같음*/ अहस्ताक्षरित लंबी बहस देरी = ५०;

व्यर्थ व्यवस्था(){

/*복잡하게: GND - 5V (पिन नंबर से कनेक्ट करें) */ के लिए (int i = 0; i <B_NUM; i ++) { पिनमोड (बटनपिन , INPUT_PULLUP); } सीरियल.बेगिन (९६००); /*스트립 1~5를 */ strip1.begin(); स्ट्रिप2.बेगिन (); स्ट्रिप3.बेगिन (); स्ट्रिप4.बेगिन (); स्ट्रिप5.बेगिन ();

//strip1. TheaterChase(strip1. Color(255, 0, 255), strip1. Color(255, 50, 0), 20, FORWARD);

}

/*버튼 ५임*/

इंट काउंटर = 5; शून्य लूप () {/*버튼 i가 i를 증가시키고*/ के लिए (int i = 0; i debounceDelay) { अगर (पढ़ना ! = बटनस्टेट ) {बटनस्टेट = पढ़ना [मैं]; बटन काउंटर ++; /*버튼 मैक्स값 5를 0으로.*/ अगर (बटन काउंटर > बटन काउंटरमैक्स) बटन काउंटर = 0; } } लास्टबटनस्टेट = पढ़ना ; } /*모든.*/ strip1. Update(); स्ट्रिप 2. अपडेट (); स्ट्रिप3.अपडेट (); स्ट्रिप4.अपडेट (); स्ट्रिप5.अपडेट ();

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

/*버튼 0번째. 2번핀에 */ स्विच (बटन काउंटर [0]) {

/*첫번째 */

केस 0: स्ट्रिप1.एक्टिव पैटर्न = ब्लॉसम; /*해당 */ पट्टी1.अंतराल = 20; /*구동되는 */ strip1. TotalSteps = strip1.numPixels(); टूटना; /*두번째 */ केस १: स्ट्रिप१.एक्टिवपैटर्न = रेनबोस्पार्कल; स्ट्रिप १. अंतराल = ५०; स्ट्रिप १. टोटलस्टेप्स = स्ट्रिप१.नमपिक्सल (); टूटना; /*세번째 */ केस २: स्ट्रिप१.एक्टिवपैटर्न = स्कैनर; पट्टी १. अंतराल = १०; स्ट्रिप १. टोटलस्टेप्स = (स्ट्रिप१.numPixels () - १) * २; टूटना; /*네번째 */ केस ३: स्ट्रिप१.एक्टिवपैटर्न = ट्विंकल; पट्टी 1. अंतराल = 1; स्ट्रिप १. टोटलस्टेप्स = स्ट्रिप१.नमपिक्सल (); टूटना; /*다섯번째 */ केस ४: स्ट्रिप १.एक्टिवपैटर्न = उल्का; पट्टी १. अंतराल = १०; स्ट्रिप १. टोटलस्टेप्स = स्ट्रिप१.नमपिक्सल (); टूटना; } सीरियल.प्रिंट (बटन काउंटर [0]); सीरियल.प्रिंट ("", "); Serial.println (बटन काउंटर [1]);

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

स्विच (बटन काउंटर [1]) {केस 0: स्ट्रिप 2. एक्टिव पैटर्न = स्टार; स्ट्रिप २। अंतराल = ५०; स्ट्रिप २. टोटलस्टेप्स = स्ट्रिप २.नमपिक्सल (); टूटना; केस १: स्ट्रिप २.एक्टिवपैटर्न = रेनबोस्पार्कल; स्ट्रिप २। अंतराल = १००; स्ट्रिप 2. टोटलस्टेप्स = स्ट्रिप 2. numPixels (); टूटना; केस 2: स्ट्रिप2.एक्टिव पैटर्न = स्कैनर; स्ट्रिप २। अंतराल = २०; स्ट्रिप २. टोटलस्टेप्स = (स्ट्रिप२.नमपिक्सल्स () - १) * २; टूटना; केस ३: स्ट्रिप २.एक्टिवपैटर्न = ट्विंकल; स्ट्रिप २। अंतराल = ५; स्ट्रिप २. टोटलस्टेप्स = स्ट्रिप २.नमपिक्सल (); टूटना; केस ४: स्ट्रिप २.एक्टिवपैटर्न = उल्का; स्ट्रिप २। अंतराल = ४०; स्ट्रिप २. टोटलस्टेप्स = स्ट्रिप २.नमपिक्सल (); टूटना; } सीरियल.प्रिंट (बटन काउंटर [0]); सीरियल.प्रिंट ("", "); Serial.println (बटन काउंटर [1]);

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

स्विच (बटन काउंटर [2]) {केस 0: स्ट्रिप3.एक्टिव पैटर्न = स्टार; स्ट्रिप ३। अंतराल = ५०; स्ट्रिप3। टोटलस्टेप्स = स्ट्रिप3.numPixels (); टूटना; केस 1: स्ट्रिप3.एक्टिव पैटर्न = रेनबोस्पार्कल; स्ट्रिप ३। अंतराल = १००; स्ट्रिप3। टोटलस्टेप्स = स्ट्रिप3.numPixels (); टूटना; केस 2: स्ट्रिप3.एक्टिव पैटर्न = स्कैनर; पट्टी ३। अंतराल = २०; स्ट्रिप3. टोटलस्टेप्स = (स्ट्रिप3.numPixels() - 1) * 2; टूटना; केस 3: स्ट्रिप3.एक्टिव पैटर्न = ट्विंकल; पट्टी ३। अंतराल = ५; स्ट्रिप3। टोटलस्टेप्स = स्ट्रिप3.numPixels (); टूटना; केस 4: स्ट्रिप3.एक्टिव पैटर्न = उल्का; स्ट्रिप ३। अंतराल = २५; स्ट्रिप3। टोटलस्टेप्स = स्ट्रिप3.numPixels (); टूटना; } सीरियल.प्रिंट (बटन काउंटर [0]); सीरियल.प्रिंट ("", "); Serial.println (बटन काउंटर [1]);

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

स्विच (बटन काउंटर [3]) {केस 0: स्ट्रिप4.एक्टिव पैटर्न = स्टार; पट्टी ४। अंतराल = ५०; स्ट्रिप4। टोटलस्टेप्स = स्ट्रिप4.नम पिक्सल (); टूटना; केस 1: स्ट्रिप4.एक्टिव पैटर्न = रेनबोस्पार्कल; स्ट्रिप ४। अंतराल = १००; स्ट्रिप4। टोटलस्टेप्स = स्ट्रिप4.नम पिक्सल (); टूटना; केस 2: स्ट्रिप4.एक्टिव पैटर्न = स्कैनर; पट्टी ४। अंतराल = २०; strip4. TotalSteps = (strip4.numPixels() - 1) * 2; टूटना; केस 3: स्ट्रिप4.एक्टिव पैटर्न = ट्विंकल; पट्टी ४। अंतराल = ५; स्ट्रिप4। टोटलस्टेप्स = स्ट्रिप4.नम पिक्सल (); टूटना; केस 4: स्ट्रिप4.एक्टिव पैटर्न = METEOR; पट्टी ४। अंतराल = २५; स्ट्रिप4। टोटलस्टेप्स = स्ट्रिप4.नम पिक्सल (); टूटना; } सीरियल.प्रिंट (बटन काउंटर [0]); सीरियल.प्रिंट ("", "); Serial.println (बटन काउंटर [1]);

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

स्विच (बटन काउंटर [४]) {केस ०: स्ट्रिप ५। एक्टिवपैटर्न = स्टार; पट्टी ५। अंतराल = ५०; स्ट्रिप5.टोटलस्टेप्स = स्ट्रिप5.numPixels (); टूटना; केस १: स्ट्रिप ५.एक्टिवपैटर्न = रेनबोस्पार्कल; पट्टी ५। अंतराल = १००; स्ट्रिप5. टोटलस्टेप्स = स्ट्रिप5.numPixels (); टूटना; केस 2: स्ट्रिप5.एक्टिव पैटर्न = स्कैनर; पट्टी ५। अंतराल = २०; स्ट्रिप5. टोटलस्टेप्स = (स्ट्रिप5.numPixels() - 1) * 2; टूटना; केस 3: स्ट्रिप5.एक्टिव पैटर्न = ट्विंकल; पट्टी ५। अंतराल = ५; स्ट्रिप5.टोटलस्टेप्स = स्ट्रिप5.numPixels (); टूटना; केस 4: स्ट्रिप5.एक्टिव पैटर्न = उल्का; पट्टी ५। अंतराल = २५; स्ट्रिप5. टोटलस्टेप्स = स्ट्रिप5.numPixels (); टूटना; } सीरियल.प्रिंट (बटन काउंटर [0]); सीरियल.प्रिंट ("", "); Serial.println (बटन काउंटर [1]); }

// स्ट्रिप 1 पूर्ण कॉलबैक

शून्य पट्टी १ पूर्ण () { पट्टी १। रंग १ = पट्टी १। पहिया (यादृच्छिक (२५५)); स्ट्रिप 1. रंग 2 = स्ट्रिप 1. व्हील (यादृच्छिक (255)); स्ट्रिप1.इंडेक्स = 0; }

// स्ट्रिप 2 समापन कॉलबैक

शून्य पट्टी २ पूर्ण () { पट्टी २। रंग १ = पट्टी २। पहिया (यादृच्छिक (२५५)); स्ट्रिप 2. रंग 2 = स्ट्रिप 2. व्हील (यादृच्छिक (255)); स्ट्रिप २.इंडेक्स = ०; }

// स्ट्रिप 3 कंप्लीशन कॉलबैक

शून्य पट्टी ३ पूर्ण () { पट्टी ३। रंग १ = पट्टी ३। पहिया (यादृच्छिक (२५५)); स्ट्रिप ३। कलर २ = स्ट्रिप ३। व्हील (यादृच्छिक (२५५)); स्ट्रिप3.इंडेक्स = 0; }

// स्ट्रिप 4 कंप्लीशन कॉलबैक

शून्य पट्टी 4 पूर्ण () { पट्टी ४। रंग १ = पट्टी ४। पहिया (यादृच्छिक (२५५)); स्ट्रिप ४। कलर २ = स्ट्रिप ४। व्हील (यादृच्छिक (२५५)); स्ट्रिप4.इंडेक्स = 0; }

// स्ट्रिप 5 कंप्लीशन कॉलबैक

शून्य पट्टी ५ पूर्ण () { पट्टी ५। रंग १ = पट्टी ५। पहिया (यादृच्छिक (२५५)); स्ट्रिप ५. कलर २ = स्ट्रिप ५। व्हील (यादृच्छिक (२५५)); स्ट्रिप5.इंडेक्स = 0; }

चरण 6: परिणाम और फिल्म बनाना

हमारी परियोजना में आपकी रुचि के लिए धन्यवाद, हालांकि यह पर्याप्त नहीं है।