Arduino LED मूड क्यूब में सुधार (सरल) (वीडियो शामिल): 4 कदम

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

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

चरण 1: सामग्री

इस मूड क्यूब को बनाने के लिए आपको कुछ सामग्रियों की आवश्यकता होगी:

• ब्रेड बोर्ड
• Arduino - (मेरे यहाँ लियोनार्डो है)
• Arduino बिजली की आपूर्ति / USB केबल
• ब्रेड बोर्ड
• जम्पर तार (उनमें से बहुत सारे, मैंने 29 तारों का इस्तेमाल किया)
• लाल एलईडी एक्स 2
• ब्लू एलईडी एक्स 2
• ग्रीन एलईडी x 2
• पीला एलईडी x 2
• सफेद एलईडी एक्स 1
• 9 प्रतिरोधक
• ब्रेडबोर्ड फिट करने के लिए काफी बड़ा बॉक्स (मैंने एक जूता बॉक्स का इस्तेमाल किया)
• उपयोगिता के चाकू
• कागज़

चरण 2: कोड

यहां दिए गए कोड के लिए कुछ स्पष्टीकरण:

कोड का श्रेय मेरे प्रोजेक्ट के मूल स्रोत को जाता है क्योंकि प्रोजेक्ट के संपादक ने ये कोड बनाए हैं। मैंने उनमें से कुछ को और अधिक जटिल बनाकर उनमें सुधार किया। कुछ कोड में, आप अंत में //改 देख सकते हैं। इसका मतलब है कि यह कोड मेरे द्वारा संपादित किया गया है, इसलिए यह मेरे मूल स्रोत से अलग है।

मेरे पास Arduino Creator पर कोड का एक संस्करण भी है।

/* क्रॉस-फ़ेडिंग के लिए कोड 3 एलईडी, लाल, हरा और नीला (RGB) फ़ेड बनाने के लिए, आपको दो काम करने होंगे: 1. उन रंगों का वर्णन करें जिन्हें आप प्रदर्शित करना चाहते हैं 2. उस क्रम को सूचीबद्ध करें जिसमें आप उन्हें फीका करना चाहते हैं

एक रंग का वर्णन करना:

लाल, हरे और नीले एल ई डी को नियंत्रित करते हुए एक रंग केवल तीन प्रतिशत, 0-100 की एक सरणी है

लाल लाल एलईडी पूर्ण, नीला और हरा बंद है

इंट रेड = {१००, ०, ०} डिम व्हाइट सभी तीन एलईडी है ३०% इंट डिमव्हाइट = {३०, ३०, ३०} आदि।

कुछ सामान्य रंग नीचे दिए गए हैं, या अपना बनाएं

आदेश सूचीबद्ध करना:

कार्यक्रम के मुख्य भाग में, आपको उस क्रम को सूचीबद्ध करना होगा जिसमें आप रंग दिखाना चाहते हैं, उदा। क्रॉसफ़ेड (लाल); क्रॉसफ़ेड (हरा); क्रॉसफ़ेड (नीला);

वे रंग उसी क्रम में दिखाई देंगे, जो फीके पड़ रहे हैं

एक रंग और अगले में

इसके अतिरिक्त, 5 वैकल्पिक सेटिंग्स हैं जिन्हें आप समायोजित कर सकते हैं:

1. प्रारंभिक रंग काला पर सेट है (इसलिए पहला रंग फीका पड़ जाता है), लेकिन आप प्रारंभिक रंग को किसी अन्य रंग के रूप में सेट कर सकते हैं 2. आंतरिक लूप 1020 इंटरेक्शन के लिए चलता है; 'प्रतीक्षा' चर एकल क्रॉसफ़ेड की अनुमानित अवधि निर्धारित करता है। सिद्धांत रूप में, 10 एमएस के 'प्रतीक्षा' को ~ 10 सेकंड का क्रॉसफ़ेड बनाना चाहिए। व्यवहार में, अन्य कार्य जो कोड मेरे बोर्ड पर धीमी गति से ~ 11 सेकंड तक कर रहा है। वाईएमएमवी। 3. यदि 'रिपीट' को 0 पर सेट किया जाता है, तो प्रोग्राम अनिश्चित काल के लिए लूप हो जाएगा। यदि यह किसी संख्या पर सेट है, तो यह उस संख्या को लूप करेगा, फिर अनुक्रम में अंतिम रंग पर रुक जाएगा। ('वापसी' को 1 पर सेट करें और यदि आप चाहते हैं कि यह अंत में फीका हो जाए तो अंतिम रंग काला कर दें।) 4. एक वैकल्पिक 'होल्ड' वैरिएबल है, जो एक रंग होने पर 'होल्ड' मिलीसेकंड के लिए प्रोग्राम को रोक देता है। पूरा, लेकिन अगला रंग शुरू होने से पहले। 5. यदि आप डिबगिंग आउटपुट को सीरियल मॉनिटर पर भेजना चाहते हैं तो DEBUG फ्लैग को 1 पर सेट करें।

कार्यक्रम के आंतरिक भाग जटिल नहीं हैं, लेकिन वे

थोड़े उधम मचाते हैं - मुख्य लूप के नीचे आंतरिक कार्यप्रणाली को समझाया गया है।

अप्रैल 2007, क्ले शिर्क्यो

*

/ आउटपुट

int ylwPin = 5; // पीला एलईडी, डिजिटल पिन से जुड़ा 5 //改 int redPin = 6; // लाल एलईडी, डिजिटल पिन से जुड़ा है 6 //改 int grnPin = 7; // ग्रीन एलईडी, डिजिटल पिन से जुड़ा है 7 //改 int bluPin = 8; // ब्लू एलईडी, डिजिटल पिन से जुड़ा 8 //改 int whipin = 9; // सफेद एलईडी, डिजिटल पिन से जुड़ा है 9 //改 int ylwPin2 = 10; // पीला एलईडी, डिजिटल पिन से जुड़ा 10 //改 int redPin2 = 11; // लाल एलईडी, डिजिटल पिन से जुड़ा 11 //改 int grnPin2 = 12; // ग्रीन एलईडी, डिजिटल पिन से जुड़ा 12 //改 int bluPin2 = 13; // ब्लू एलईडी, डिजिटल पिन से जुड़ा 13 //改

// रंग सरणियाँ

इंट ब्लैक [९] = {०, ०, ०, ०, ०, ०, ०, ०, ०};//改 इंट व्हाइट [९] = {१००, १००, १००, १००, १००, १००, १००, १००, १००};//改 इंट रेड [९] = {०, ०, १००, ०, ०, ०, १००, ०, ०};//改 इंट ग्रीन [९] = {०, १००, ०, 0, 0, 0, 0, 100, 0};//改 इंट ब्लू[9] = {0, 0, 0, 100, 0, 0, 0, 0, 100};//改 इंट येलो[9] = {१००, ०, ०, ०, ०, १००, ०, ०, ०}; // इंट पर्पल [9] = {0, ५०, ०, ५०, ०, ०, ५०, ०, ५०}; // 改 इंट ऑरेंज [९] = {५०, ५०, ०, ०, ०, ५०, ५०, ०, ०}; // इंट पिंक [9] = {0, 50, 0, 0, 50, 0, 0, 50, 0,}; // // आदि।

// प्रारंभिक रंग सेट करें

इंट रेडवैल = काला [0]; int grnVal = काला [1]; इंट ब्लूवैल = काला [२]; int ylwVal = काला [3]; // 改 इंट व्हिवल = काला [४]; //

इंट प्रतीक्षा = 15; // 10ms आंतरिक क्रॉसफ़ेड देरी; धीमी फीके के लिए वृद्धि //改

इंट होल्ड = 1; // वैकल्पिक होल्ड जब एक रंग पूरा हो जाता है, अगले क्रॉसफ़ेड से पहले //改 int DEBUG = 1; // डीबग काउंटर; यदि 1 पर सेट किया जाता है, तो सीरियल इंट लूपकाउंट = 60 के माध्यम से मान वापस लिखेंगे; // DEBUG को कितनी बार रिपोर्ट करनी चाहिए? इंट रिपीट = 0; // रुकने से पहले हमें कितनी बार लूप करना चाहिए? (0 बिना रुके) //改 int j = 0; // दोहराने के लिए लूप काउंटर

// रंग चर शुरू करें

int prevR = redVal; int prevG = grnVal; इंट प्रीवबी = ब्लूवैल; int prevY = ylwVal; int prevW = whiVal; //

// एलईडी आउटपुट सेट करें

शून्य सेटअप () {पिनमोड (रेडपिन, आउटपुट); // पिन को आउटपुट पिनमोड (grnPin, OUTPUT) के रूप में सेट करता है; पिनमोड (ब्लूपिन, आउटपुट); पिनमोड (ylwPin, OUTPUT); // पिनमोड (व्हीपिन, आउटपुट); // पिनमोड (grnPin2, OUTPUT); // पिनमोड (ब्लूपिन 2, आउटपुट); // पिनमोड (ylwPin2, OUTPUT); // पिनमोड (रेडपिन 2, आउटपुट); //

अगर (DEBUG) {// अगर हम डिबगिंग के लिए मान देखना चाहते हैं…

सीरियल.बेगिन (९६००); // … सीरियल आउटपुट सेट करें } }

// मुख्य कार्यक्रम: क्रॉसफ़ेड के क्रम को सूचीबद्ध करें

शून्य लूप () {क्रॉसफ़ेड (लाल); क्रॉसफ़ेड (हरा); क्रॉसफ़ेड (नीला); क्रॉसफ़ेड (पीला); क्रॉसफ़ेड (सफेद); क्रॉसफ़ेड (गुलाबी); क्रॉसफ़ेड (बैंगनी); क्रॉसफ़ेड (नारंगी);

अगर (दोहराना) {// क्या हम एक सीमित संख्या में लूप करते हैं?

जे + = 1; अगर (जे> = दोहराना) {// क्या हम अभी तक वहां हैं? बाहर निकलें (जे); // यदि हां, तो रुकें। } } }

/* इस लाइन के नीचे गणित है -- आपको मूलभूत बातों के लिए इसे बदलने की आवश्यकता नहीं है

कार्यक्रम इस तरह काम करता है:

एक क्रॉसफ़ेड की कल्पना करें जो लाल एलईडी को 0-10 से, हरे को 0-5 से, और नीले को 10 से 7 तक दस चरणों में ले जाता है। हम 10 चरणों की गणना करना चाहते हैं और समान रूप से चरणबद्ध वृद्धि में रंग मानों को बढ़ाना या घटाना चाहते हैं। कल्पना कीजिए कि a + एक मान को 1 से बढ़ाने का संकेत देता है, और a - इसे कम करने के बराबर है। हमारा 10 कदम फीका इस तरह दिखेगा:

1 2 3 4 5 6 7 8 9 10

आर + + + + + + + + + + जी + + + + + बी - - -

लाल दस चरणों में 0 से 10 तक उगता है, हरा से

5 चरणों में 0-5, और तीन चरणों में नीला 10 से 7 तक गिरता है।

वास्तविक कार्यक्रम में, रंग प्रतिशत को परिवर्तित किया जाता है

0-255 मान, और 1020 चरण (255*4) हैं।

यह पता लगाने के लिए कि एक अप के बीच कितना बड़ा कदम होना चाहिए- या

एलईडी मानों में से एक का डाउन-टिक, हम कैलकुलेटस्टेप () कहते हैं, जो प्रारंभ और अंत मूल्यों के बीच पूर्ण अंतर की गणना करता है, और फिर मूल्य में समायोजन के बीच चरण के आकार को निर्धारित करने के लिए उस अंतर को 1020 से विभाजित करता है। */

int गणना चरण (int prevValue, int endValue) {

इंट स्टेप = एंडवैल्यू - प्रीवेल्यू; // कुल अंतर क्या है? अगर (चरण) {// यदि यह शून्य नहीं है, तो चरण = 1020 / चरण; // 1020 से विभाजित करें} वापसी चरण; }

/* अगला फंक्शन कैलकुलेटवैल है। जब लूप मान, i, किसी एक रंग के लिए उपयुक्त चरण आकार तक पहुँचता है, यह उस रंग के मान को 1 से बढ़ाता या घटाता है। (R, G, और B प्रत्येक की अलग-अलग गणना की जाती है।) */

इंट कैलकुलेटवैल (इंट स्टेप, इंट वैल, इंट आई) {

अगर ((चरण) && i% चरण == 0) {// यदि चरण गैर-शून्य है और इसका मान बदलने का समय है, अगर (चरण> 0) {// यदि चरण सकारात्मक है तो मान बढ़ाएं … वैल + = 1; } और अगर (चरण २५५) {वैल = २५५; } और अगर (वैल <0) {वैल = 0; } वापसी वैल; }

/* crossFade () प्रतिशत रंगों को a. में परिवर्तित करता है

0-255 रेंज, फिर 1020 बार लूप करता है, यह देखने के लिए जाँच करता है कि क्या मान को हर बार अपडेट करने की आवश्यकता है, फिर रंग मानों को सही पिन पर लिखें। */

शून्य क्रॉसफ़ेड (इंट कलर ) {//改

// 0-255 इंट आर = (रंग [0] * 255) / 100 में कनवर्ट करें; इंट जी = (रंग [1] * २५५) / १००; इंट बी = (रंग [२] * २५५) / १००; इंट वाई = (रंग [३] * २५५) / १००; // 改 इंट डब्ल्यू = (रंग [४] * २५५) / १००; //

इंट स्टेपआर = कैलकुलेटस्टेप (पिछला, आर);

इंट स्टेपजी = कैलकुलेटस्टेप (पिछला, जी); इंट स्टेपबी = कैलकुलेटस्टेप (पिछला बी, बी); इंट स्टेपवाई = कैलकुलेटस्टेप (पिछला, वाई); // 改 इंट स्टेपव = कैलकुलेटस्टेप (पिछला डब्ल्यू, डब्ल्यू); //

के लिए (int i = 0; i <= 1020; i++) { redVal = कैलकुलेटवैल (stepR, redVal, i); जीआरएनवैल = कैलकुलेटवैल (स्टेपजी, जीआरएनवैल, आई); ब्लूवैल = कैलकुलेटवैल (स्टेपबी, ब्लूवैल, आई); ylwVal = गणना वैल (स्टेपवाई, वाईएलडब्ल्यूवैल, आई); // व्हीवल = कैलकुलेटवैल (स्टेपडब्ल्यू, व्हीवैल, आई); //

एनालॉगवर्इट (रेडपिन, रेडवैल); // एलईडी पिन के लिए वर्तमान मान लिखें

AnalogWrite (grnPin, grnVal); एनालॉगवर्इट (ब्लूपिन, ब्लूवैल); AnalogWrite (ylwPin, ylwVal); // एनालॉग्राइट (व्हीपिन, व्हीवल); // एनालॉग्राइट (grnPin2, grnVal); // एनालॉगवर्इट (ब्लूपिन 2, ब्लूवैल); // एनालॉग्राइट (ylwPin2, ylwVal); // एनालॉगवर्इट (रेडपिन 2, रेडवैल); //

देरी (प्रतीक्षा); // लूप को फिर से शुरू करने से पहले 'प्रतीक्षा' मिलीसेकंड के लिए रुकें

अगर (DEBUG) {// अगर हम सीरियल आउटपुट चाहते हैं, तो इसे प्रिंट करें

अगर (i == 0 या i% लूपकाउंट == 0) {// शुरुआत, और हर लूपकाउंट टाइम्स सीरियल.प्रिंट ("लूप/आरजीबीवाईडब्ल्यू: #"); सीरियल.प्रिंट (i); सीरियल.प्रिंट ("|"); सीरियल.प्रिंट (रेडवैल); सीरियल.प्रिंट ("/"); सीरियल.प्रिंट (grnVal); सीरियल.प्रिंट ("/"); सीरियल.प्रिंट्लन (ब्लूवैल); सीरियल.प्रिंट ("/"); Serial.println (ylwVal); // 改 सीरियल.प्रिंट ("/"); // 改 Serial.println (whiVal); // 改 सीरियल.प्रिंट ("/"); //改 } डीबग += 1; } } // अगले लूप के लिए वर्तमान मान अपडेट करें prevR = redVal; prevG = grnVal; पिछलाबी = ब्लूवैल; पिछला = ylwVal; // 改 prevW = whiVal; // 改 देरी (पकड़); // लूप को फिर से शुरू करने से पहले वैकल्पिक 'प्रतीक्षा' मिलीसेकंड के लिए रुकें}

चरण 3: सेट अप

1. ब्रेडबोर्ड प्राप्त करें।

2. तारों को जोड़ने का डेमो ताकि एक एलईडी लाइट चमक सके:

   1. ब्रेडबोर्ड पर एलईडी लगाएं। लंबे सिरे को बाईं ओर और छोटे सिरे को दाईं ओर रखें।
   2. एक जम्पर तार के एक छोर को उस स्थान पर रखें जो एलईडी के लंबे सिरे के साथ एक ही पंक्ति में हो। दूसरे सिरे को डिजिटल PWM सेक्शन पर रखें। कोड ने पीले एलईडी को 10 और 5 से, लाल वाले को 6 और 11 से, नीले वाले को 8 और 13 को, हरे को 7 और 12 को, और अंत में सफेद एलईडी को 9 से जोड़ा।
   3. एलईडी के छोटे सिरे के साथ एक ही पंक्ति पर एक रोकनेवाला के एक छोर को रखें। दूसरे सिरे को कहीं पास में रखें।
   4. एक और जम्पर तार के एक छोर को उसी पंक्ति के साथ रखें जो रोकनेवाला के अंत के साथ है जो एलईडी के छोटे छोर के साथ एक ही पंक्ति पर नहीं है। तार के दूसरे सिरे को ऋणात्मक आवेश पंक्ति पर रखें।
   5. एक और जम्पर तार का एक सिरा ऋणात्मक आवेश पंक्ति पर रखें और उसका दूसरा सिरा GND पर रखें।
3. चरण 2 को 8 बार दोहराएं क्योंकि आप चाहते हैं कि 9 एलईडी चमकें

4. ब्रेडबोर्ड को बॉक्स के अंदर रखें। यहाँ कुछ अनुस्मारक:

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