एलईडी सर्पिल ट्री: 4 कदम (चित्रों के साथ)

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

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

चरण 1: नियंत्रक

मैंने गैर-पता योग्य आरजीबी एलईडी का उपयोग करने का निर्णय लिया। इसका मतलब है कि मेरे पास प्रोग्राम किए गए प्रभाव हो सकते हैं लेकिन सभी एल ई डी एक साथ रंग बदलते हैं। इसका मतलब यह भी है कि एक नियंत्रक की आवश्यकता होगी। मैं एक arduino uno का उपयोग कर सकता था और RGB शील्ड का उपयोग करके प्रारंभिक परीक्षण करने के लिए किया था, लेकिन एक नंगे Atmega328 चिप के साथ एक कस्टम सिंगल बोर्ड का उपयोग करके समाप्त हुआ। बस लक्ष्य प्रोग्रामर को स्विच करना था और चिप को सीधे प्रोग्राम करना था।

मेरे पास इनमें से बहुत सारे बोर्ड अन्य लैंप प्रोजेक्ट्स से बचे थे। एक सस्ते इनलाइन प्रीप्रोग्राम किए गए नियंत्रक का उपयोग करने के लिए स्वतंत्र महसूस करें जैसे मैंने अपनी छतरी पर किया था।

मैं पेड़ के आधार के रूप में धीमी क्रॉसफ़ेड डेमो का उपयोग कर समाप्त हुआ।

/** क्रॉस-फ़ेडिंग के लिए कोड 3 एलईडी, लाल, हरा और नीला (RGB) * फ़ेड बनाने के लिए, आपको दो काम करने होंगे: * 1. उन रंगों का वर्णन करें जिन्हें आप प्रदर्शित करना चाहते हैं * 2. अपने इच्छित क्रम की सूची बनाएं उन्हें फीका करने के लिए * * एक रंग का वर्णन: * एक रंग सिर्फ तीन प्रतिशत की एक सरणी है, 0-100, * लाल, हरे और नीले एल ई डी को नियंत्रित करना * * लाल पूर्ण लाल एलईडी है, नीला और हरा बंद * int लाल = {१००, ०, ०} * मंद सफेद सभी तीन एलईडी है ३०% * int dimWhite = {३०, ३०, ३०} * आदि। * * कुछ सामान्य रंग नीचे दिए गए हैं, या अपना खुद का बनाएं* *सूचीबद्ध करना आदेश: * कार्यक्रम के मुख्य भाग में, आपको उस क्रम को सूचीबद्ध करने की आवश्यकता है * जिसमें आप रंग दिखाना चाहते हैं, उदाहरण के लिए * क्रॉसफ़ेड (लाल); * क्रॉसफ़ेड (हरा); * क्रॉसफ़ेड (नीला); * *वे रंग उसी क्रम में दिखाई देंगे, * एक रंग से लुप्त होकर अगले में * * इसके अलावा, 5 वैकल्पिक सेटिंग्स हैं जिन्हें आप समायोजित कर सकते हैं: * 1. प्रारंभिक रंग काला पर सेट है (इसलिए पहला रंग फीका पड़ जाता है) in), लेकिन * आप प्रारंभिक रंग को किसी अन्य रंग के रूप में सेट कर सकते हैं * 2. आंतरिक लूप 1020 इंटरेक्शन के लिए चलता है; 'प्रतीक्षा' चर * एकल क्रॉसफ़ेड की अनुमानित अवधि निर्धारित करता है। सिद्धांत रूप में, * 10 एमएस के 'प्रतीक्षा' को ~ 10 सेकंड का क्रॉसफ़ेड बनाना चाहिए। * अभ्यास में, अन्य कार्य जो कोड मेरे बोर्ड पर धीमी गति से * नीचे ~ 11 सेकंड तक कर रहा है। वाईएमएमवी। * 3. यदि 'रिपीट' को 0 पर सेट किया जाता है, तो प्रोग्राम अनिश्चित काल के लिए लूप हो जाएगा। * यदि यह किसी संख्या पर सेट है, तो यह उस संख्या को लूप करेगा, * फिर अनुक्रम में अंतिम रंग पर रुक जाएगा। ('वापसी' को 1 पर सेट करें, और यदि आप चाहते हैं कि यह अंत में फीका हो जाए तो अंतिम रंग काला कर दें।) * 4. एक वैकल्पिक 'होल्ड' वैरिएबल है, जो 'होल्ड' मिलीसेकंड के लिए * प्रोग्राम को रोक देता है जब एक रंग पूरा हो गया है, * लेकिन अगला रंग शुरू होने से पहले। * 5. यदि आप डिबगिंग आउटपुट को सीरियल मॉनिटर पर भेजना चाहते हैं तो DEBUG फ्लैग को 1 पर सेट करें। * *कार्यक्रम के आंतरिक भाग जटिल नहीं हैं, लेकिन वे * थोड़े उधम मचाते हैं - मुख्य लूप के नीचे आंतरिक कार्यप्रणाली को * समझाया गया है। * *अप्रैल 2007, क्ले शिर्की*

/ आउटपुट

int grnPin = 9; // ग्रीन एलईडी, डिजिटल पिन से जुड़ा 10 इंट रेडपिन = 10; // लाल एलईडी, डिजिटल पिन 9 इंट ब्लूपिन = 11 से जुड़ा; // ब्लू एलईडी, डिजिटल पिन से जुड़ा 11

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

इंट ब्लैक [3] = {0, 0, 0}; इंट व्हाइट [3] = {१००, १००, १००}; इंट रेड [३] = {१००, ०, ०}; इंट ग्रीन [३] = {०, १००, ०}; इंट ब्लू [3] = {0, 0, 100}; इंट येलो [३] = {४०, ९५, ०}; इंट डिमव्हाइट [3] = { ३०, ३०, ३० }; // आदि।

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

इंट रेडवैल = काला [0]; int grnVal = काला [1]; इंट ब्लूवैल = काला [२];

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

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

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

int prevR = redVal; int prevG = grnVal; इंट प्रीवबी = ब्लूवैल;

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

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

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

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

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

शून्य लूप () {क्रॉसफ़ेड (लाल); क्रॉसफ़ेड (हरा); क्रॉसफ़ेड (नीला); क्रॉसफ़ेड (पीला);

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

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

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

* *कार्यक्रम इस तरह काम करता है: * एक क्रॉसफ़ेड की कल्पना करें जो लाल एलईडी को 0-10 से, * हरे को 0-5 से, और नीले रंग को 10 से 7 तक * दस चरणों में ले जाता है। * हम 10 चरणों की गणना करना चाहते हैं और समान रूप से चरणबद्ध वृद्धि में रंग मानों को बढ़ाना या घटाना चाहते हैं। * कल्पना कीजिए कि a + एक मान को 1 से बढ़ाने का संकेत देता है, और a - * इसे कम करने के बराबर है। हमारा 10 कदम फीका इस तरह दिखेगा: * * 1 2 3 4 5 6 7 8 9 10 * R + + + + + + + + + * G + + + + + * B - - * * लाल से उगता है दस चरणों में 0 से 10, 5 चरणों में *0-5 से हरा और तीन चरणों में नीला 10 से 7 तक गिरता है। * *वास्तविक कार्यक्रम में, रंग प्रतिशत को * 0-255 मानों में बदल दिया जाता है, और 1020 चरण (255*4) होते हैं। * * यह पता लगाने के लिए कि एलईडी मानों में से एक के ऊपर या * डाउन-टिक के बीच कितना बड़ा कदम होना चाहिए, हम कैलकुलेटस्टेप (), * कहते हैं जो प्रारंभ और अंत मूल्यों के बीच पूर्ण अंतर की गणना करता है, * और फिर मूल्य में समायोजन के बीच चरण * के आकार को निर्धारित करने के लिए उस अंतर को 1020 से विभाजित करता है। */

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

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

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

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

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

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

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

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

// 0-255 इंट आर = (रंग [0] * 255) / 100 में कनवर्ट करें; इंट जी = (रंग [1] * २५५) / १००; इंट बी = (रंग [२] * २५५) / १००;

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

इंट स्टेपजी = कैलकुलेटस्टेप (पिछला, जी); इंट स्टेपबी = कैलकुलेटस्टेप (पिछला बी, बी);

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

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

AnalogWrite (grnPin, grnVal); एनालॉगवर्इट (ब्लूपिन, ब्लूवैल);

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

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

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

चरण 2: पेड़ को लपेटना

मैंने वाटरप्रूफ स्ट्रिप्स का इस्तेमाल किया क्योंकि ये बाहर होंगे। वे अपने आप चिपक गए लेकिन मैंने जल्दी से तार संबंधों के साथ यह सुनिश्चित करने के लिए पीछा किया कि वे बने रहें। सरल और आसान हैक। पट्टी की फीडथ्रू शक्ति क्षमता ने बिजली की आपूर्ति को नीचे तक पहुँचाना और ऊपर से तारे तक बिजली पहुँचाना आसान बना दिया।

चरण 3: ऊपर के सितारे को न भूलें

स्टार के लिए मैंने कुछ ध्यान आकर्षित करने के लिए 10W चिप्स की एक जोड़ी का इस्तेमाल किया। मैंने उन्हें एक तांबे की शीट में एक हीटसिंक के रूप में मिलाया। मैं और पट्टी का उपयोग कर सकता था क्योंकि थोड़ा बचा हुआ था।

चरण 4: इसे आज़माना

पहले प्रयास में गति बहुत तेज थी…।

एक बार जब मैंने इसे शांत किया तो यह बहुत अच्छा लग रहा था।