लकड़ी की एलईडी घड़ी - एनालॉग शैली: 11 कदम (चित्रों के साथ)

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

यह एक एनालॉग शैली की लकड़ी की एलईडी घड़ी है। मुझे नहीं पता कि मैंने इनमें से एक को पहले क्यों नहीं देखा..भले ही डिजिटल प्रकार बहुत आम हैं। किसी भी तरह, हम यहाँ जाते हैं!

चरण 1:

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

चरण 2: डिजाइन

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

चरण 3: सीएनसीिंग

मैंने मास्टरकैम पर टूलपाथ डिज़ाइन किया, और घड़ी को 3/4 इंच प्लाईवुड से बाहर निकालने के लिए एक टेक्नो राउटर का उपयोग किया। मैं इसके लिए एक 15"x15" टुकड़े का उपयोग करता हूं, जिसमें न्यूनतम अपव्यय होता है। चाल लकड़ी के माध्यम से तोड़ने के बिना जितना संभव हो उतना लकड़ी को बाहर निकालना है। हल्की लकड़ी के लिए 0.05"-0.1" छोड़ना एक अच्छा विकल्प है। यदि आप अनिश्चित हैं, तो अधिक लकड़ी छोड़ना बेहतर है, क्योंकि आप हमेशा दूसरे चेहरे को रेत सकते हैं। मैंने कुछ हिस्सों से थोड़ी बहुत लकड़ी हटा दी, लेकिन शुक्र है कि इस वजह से परिणाम बहुत ज्यादा प्रभावित नहीं हुए।

बिना सीएनसी के उपयोगकर्ताओं के लिए नोट:

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

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

इलेक्ट्रॉनिक्स काफी सरल हैं। 24 नियोपिक्सल हैं, बारह घंटे दिखाने के लिए और बारह मिनट दिखाने के लिए, पांच मिनट की सटीकता के साथ। एक Arduino प्रो मिनी नियोपिक्सल को नियंत्रित करता है और इसे DS3231 रीयल टाइम क्लॉक (RTC) मॉड्यूल के माध्यम से सटीक समय मिलता है। RTC मॉड्यूल में बैकअप के रूप में एक कॉइन सेल है, इसलिए बिजली बंद होने पर भी यह समय नहीं गंवाता है।

सामग्री:

Arduino प्रो मिनी (या उस मामले के लिए कोई अन्य Arduino)

DS3231 ब्रेकआउट बोर्ड

अलग-अलग ब्रेकआउट बोर्डों में नियोपिक्सल

चरण 5: इलेक्ट्रॉनिक्स असेंबली

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

चरण 6: ड्राई रन

प्रयोग करने के बाद, छेदों में एलईडी लगाने और उन सभी को चालू करने के बाद, मैं परिणामों से संतुष्ट था। इसलिए मैंने सामने के चेहरे को थोड़ा सा रेत दिया और एक पीयू कोट लगाया। मैंने बाद में कोट को सैंड करना समाप्त कर दिया, लेकिन अगर आपको यह सौंदर्यपूर्ण रूप से अप्रसन्न नहीं लगता है तो इसे छोड़ना एक अच्छा विचार है।

चरण 7: एपॉक्सी

छेद के भीतर नेतृत्व की स्थिति के साथ कुछ परीक्षण के बाद, मुझे लगा कि सबसे अच्छी चर्चा तब प्राप्त होती है जब एल ई डी छेद के अंत से लगभग 0.2 दूर होते हैं। जब आप स्वयं इसे आजमाते हैं, तो एल ई डी की चमक बहुत अलग होगी प्रत्येक छेद। इसके बारे में चिंता न करें; हम इसे कोड में ठीक कर देंगे। यह मेरे द्वारा उपयोग किए जाने वाले ड्रिल बिट के प्रकार के कारण है। अगर मैं इसे फिर से करता, तो मैं छेद के लिए बॉल एंड ड्रिल बिट का उपयोग करता लेकिन, किसी भी मामले में, दूरी पाने के लिए मैंने कुछ एपॉक्सी मिलाया और प्रत्येक छेद में थोड़ा सा डाल दिया।

चरण 8: यह सब एक साथ रखना

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

एक घंटे के लिए एपॉक्सी ठीक होने के बाद, मैंने कुछ और एपॉक्सी डाल दिए। इस बार, मैंने एल ई डी को छेदों में रखा, जिससे तारों और सोल्डर जोड़ों को एपॉक्सी के साथ कवर करना सुनिश्चित हो गया। यह अच्छा प्रकाश प्रसार करता है और तारों को सुरक्षित करता है।

चरण 9: कोड

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

प्लाईवुडक्लॉक.इनो

// प्लाईवुड घड़ी

// लेखक: टिंकरमिंद

// एट्रिब्यूशन 4.0 इंटरनेशनल (सीसी बाय 4.0)। आप इसके लिए स्वतंत्र हैं:

// साझा करें - सामग्री को किसी भी माध्यम या प्रारूप में कॉपी और पुनर्वितरित करें

// अनुकूलन - किसी भी उद्देश्य के लिए सामग्री पर रीमिक्स, रूपांतरण, और निर्माण, यहां तक कि व्यावसायिक रूप से भी।

// हुर्रे!

#शामिल

#शामिल करें"RTClib.h"

आरटीसी_डीएस3231 आरटीसी;

#शामिल करें"Adafruit_NeoPixel.h"

#ifdef _AVR_

#शामिल

#अगर अंत

#परिभाषितपिन6

Adafruit_NeoPixel स्ट्रिप = Adafruit_NeoPixel (60, पिन, NEO_GRB + NEO_KHZ800);

इंट ऑवरपिक्सेल = 0;

इंट मिनट पिक्सेल = 0;

unsignedlong lastRtcचेक;

स्ट्रिंग इनपुटस्ट्रिंग = ""; // आने वाले डेटा को रखने के लिए एक स्ट्रिंग

बूलियन स्ट्रिंग पूर्ण = झूठा; // क्या स्ट्रिंग पूर्ण है

इंट लेवल [24] = {31, 51, 37, 64, 50, 224, 64, 102, 95, 255, 49, 44, 65, 230, 80, 77, 102, 87, 149, 192, 67, 109, 68, 77};

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

#ifndef ESP8266

जबकि (! सीरियल); // लियोनार्डो/सूक्ष्म/शून्य. के लिए

#अगर अंत

// यह ट्रिंकेट 5V 16MHz के लिए है, यदि आप ट्रिंकेट का उपयोग नहीं कर रहे हैं तो आप इन तीन लाइनों को हटा सकते हैं

#if परिभाषित (_AVR_ATtiny85_)

अगर (F_CPU == 16000000) clock_prescale_set(clock_div_1);

#अगर अंत

// ट्रिंकेट विशेष कोड का अंत

सीरियल.बेगिन (९६००);

पट्टी। शुरू ();

कपड़े उतारने का प्रदर्शन(); // सभी पिक्सल को 'ऑफ' करने के लिए इनिशियलाइज़ करें

अगर (! rtc.begin ()) {

Serial.println ("आरटीसी नहीं मिला");

जबकि (1);

}

पिनमोड (2, INPUT_PULLUP);

// rtc.adjust (दिनांक समय (F(_DATE_), F(_TIME_)));

अगर (आरटीसी.लॉस्टपावर ()) {

Serial.println ("आरटीसी खोई हुई शक्ति, समय निर्धारित करने देता है!");

// निम्नलिखित पंक्ति आरटीसी को उस तारीख और समय पर सेट करती है जब यह स्केच संकलित किया गया था

rtc.adjust(DateTime(F(_DATE_), F(_TIME_)));

// यह लाइन आरटीसी को एक स्पष्ट तिथि और समय के साथ सेट करती है, उदाहरण के लिए सेट करने के लिए

// २१ जनवरी २०१४ को सुबह ३ बजे आप कॉल करेंगे:

// rtc.adjust (दिनांक समय (2017, 11, 06, 2, 49, 0));

}

// rtc.adjust (दिनांक समय (2017, 11, 06, 2, 49, 0));

// लाइटअप ईवन ();

// जबकि (1);

lastRtcचेक = 0;

}

शून्य लूप () {

अगर (मिली () - lastRtcCheck> 2000) {

डेटटाइम अब = rtc.now ();

सीरियल.प्रिंट (अब। घंटा (), डीईसी);

सीरियल.प्रिंट (':');

सीरियल.प्रिंट (अब। मिनट (), डीईसी);

सीरियल.प्रिंट (':');

सीरियल.प्रिंट (अब। दूसरा (), डीईसी);

सीरियल.प्रिंट्लन ();

शो टाइम();

lastRtcCheck = मिली ();

}

अगर (! digitalRead(2)) {

लाइटअप ईवन ();

}

अगर (स्ट्रिंग पूर्ण) {

Serial.println (इनपुटस्ट्रिंग);

अगर (इनपुटस्ट्रिंग [0] == 'एल') {

Serial.println ("स्तर");

लाइटअप ईवन ();

}

अगर (इनपुटस्ट्रिंग [0] == 'सी') {

Serial.println ("समय दिखा रहा है");

शो टाइम();

कपड़े उतारने का प्रदर्शन();

}

अगर (इनपुटस्ट्रिंग [0] == '1') {

Serial.println ("सभी एल ई डी पर स्विच करना");

लाइटअप (पट्टी। रंग (255, 255, 255));

कपड़े उतारने का प्रदर्शन();

}

अगर (इनपुटस्ट्रिंग [0] == '0') {

Serial.println ("क्लियरिंग स्ट्रिप");

स्पष्ट();

कपड़े उतारने का प्रदर्शन();

}

// #3, 255 एलईडी नंबर 3 को 255, 255, 255 के स्तर पर सेट करेगा

अगर (इनपुटस्ट्रिंग [0] == '#') {

स्ट्रिंग अस्थायी;

अस्थायी = इनपुटस्ट्रिंग। सबस्ट्रिंग (1);

int pixNum = temp.toInt ();

अस्थायी = inputString.substring (inputString.indexOf (',') + 1);

int तीव्रता = temp.toInt ();

सीरियल.प्रिंट ("सेटिंग");

सीरियल.प्रिंट (पिक्सनम);

सीरियल.प्रिंट ("से स्तर तक");

Serial.println (तीव्रता);

स्ट्रिप.सेट पिक्सेलकलर (पिक्सनम, स्ट्रिप। कलर (तीव्रता, तीव्रता, तीव्रता));

कपड़े उतारने का प्रदर्शन();

}

// #3, 255, 0, 125 एलईडी नंबर 3 को 255, 0, 125 के स्तर पर सेट करेगा

अगर (इनपुटस्ट्रिंग [0] == '$') {

स्ट्रिंग अस्थायी;

अस्थायी = इनपुटस्ट्रिंग। सबस्ट्रिंग (1);

int pixNum = temp.toInt ();

int rIndex = inputString.indexOf (',') + 1;

अस्थायी = inputString.substring (rIndex);

int rIntensity = temp.toInt ();

intgIndex = inputString.indexOf (',', rIndex + 1) + 1;

अस्थायी = इनपुटस्ट्रिंग। सबस्ट्रिंग (जीइंडेक्स);

intgIntensity = temp.toInt ();

int bIndex = inputString.indexOf (',', gIndex + 1) + 1;

अस्थायी = इनपुटस्ट्रिंग। सबस्ट्रिंग (बीइंडेक्स);

int bIntensity = temp.toInt ();

सीरियल.प्रिंट ("सेटिंग");

सीरियल.प्रिंट (पिक्सनम);

सीरियल.प्रिंट ("आर से");

सीरियल.प्रिंट (आरइंटेंसिटी);

सीरियल.प्रिंट ("जी से");

सीरियल.प्रिंट (जीइंटेंसिटी);

सीरियल.प्रिंट ("बी टू");

Serial.println(bIntensity);

strip.setPixelColor (pixNum, strip. Color (rIntensity, gIntensity, biIntensity));

कपड़े उतारने का प्रदर्शन();

}

अगर (इनपुटस्ट्रिंग [0] == 'एस') {

स्ट्रिंग अस्थायी;

इंट घंटा, मिनट;

अस्थायी = इनपुटस्ट्रिंग। सबस्ट्रिंग (1);

घंटा = अस्थायी। toInt ();

int rIndex = inputString.indexOf (',') + 1;

अस्थायी = inputString.substring (rIndex);

मिनट = अस्थायी। toInt ();

Serial.print ("समय दिखा रहा है:");

सीरियल.प्रिंट (घंटा);

सीरियल.प्रिंट (":");

सीरियल.प्रिंट (मिनट);

शोटाइम (घंटा, मिनट);

देरी (1000);

}

इनपुटस्ट्रिंग = "";

स्ट्रिंग पूर्ण = झूठा;

}

// देरी (1000);

}

voidserialEvent () {

जबकि (सीरियल.उपलब्ध ()) {

चार इनचर = (चार) सीरियल.रीड ();

इनपुटस्ट्रिंग + = इनचर;

अगर (इनचर == '\ n') {

स्ट्रिंग पूर्ण = सत्य;

}

देरी(1);

}

}

शून्य स्पष्ट () {

के लिए (uint16_t i = 0; i < strip.numPixels (); i++) {

स्ट्रिप.सेट पिक्सेलकलर (i, स्ट्रिप। कलर (0, 0, 0));

}

}

शून्य शोटाइम () {

डेटटाइम अब = rtc.now ();

घंटा पिक्सेल = अब। घंटा ()% 12;

मिनट पिक्सेल = (अब। मिनट ()/5)% १२ + १२;

स्पष्ट();

// strip.setPixelColor(hourPixel, strip. Color(40 + 40 * level[hourPixel], 30 + 30 * level[hourPixel], 20 + 20 * level [hourPixel]));

// strip.setPixelColor (मिनट पिक्सेल, स्ट्रिप। रंग (40 + 40 * स्तर [मिनट पिक्सेल], 30 + 30 * स्तर [मिनट पिक्सेल], 20 + 20 * स्तर [मिनट पिक्सेल]));

strip.setPixelColor(hourPixel, strip. Color(level[hourPixel], level[hourPixel], level[hourPixel]));

स्ट्रिप.सेट पिक्सेलकलर (मिनट पिक्सेल, स्ट्रिप। रंग (स्तर [मिनट पिक्सेल], स्तर [मिनट पिक्सेल], स्तर [मिनट पिक्सेल]));

// लाइटअप (स्ट्रिप। कलर (255, 255, 255));

कपड़े उतारने का प्रदर्शन();

}

voidshowTime (इंट घंटा, इंट मिनट) {

घंटा पिक्सेल = घंटा% 12;

मिनट पिक्सेल = (मिनट/5)% 12 + 12;

स्पष्ट();

// strip.setPixelColor(hourPixel, strip. Color(40 + 40 * level[hourPixel], 30 + 30 * level[hourPixel], 20 + 20 * level [hourPixel]));

// strip.setPixelColor (मिनट पिक्सेल, स्ट्रिप। रंग (40 + 40 * स्तर [मिनट पिक्सेल], 30 + 30 * स्तर [मिनट पिक्सेल], 20 + 20 * स्तर [मिनट पिक्सेल]));

strip.setPixelColor(hourPixel, strip. Color(level[hourPixel], level[hourPixel], level[hourPixel]));

स्ट्रिप.सेट पिक्सेलकलर (मिनट पिक्सेल, स्ट्रिप। रंग (स्तर [मिनट पिक्सेल], स्तर [मिनट पिक्सेल], स्तर [मिनट पिक्सेल]));

// लाइटअप (स्ट्रिप। कलर (255, 255, 255));

कपड़े उतारने का प्रदर्शन();

}

voidlightUp (uint32_t रंग) {

के लिए (uint16_t i = 0; i < strip.numPixels (); i++) {

strip.setPixelColor (i, रंग);

}

कपड़े उतारने का प्रदर्शन();

}

शून्यलाइटअपईवन () {

के लिए (uint16_t i = 0; i < strip.numPixels (); i++) {

strip.setPixelColor (i, स्ट्रिप। रंग (स्तर , स्तर , स्तर ));

}

कपड़े उतारने का प्रदर्शन();

}

देखें rawplywoodClock.ino ❤ के साथ GitHub द्वारा होस्ट किया गया

चरण 10: कंप्यूटर विजन - अंशांकन

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

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

आप ऊपर की तस्वीरों में कैलिब्रेशन से पहले और बाद में एलईडी की चमक देख सकते हैं।

कैलिब्रेट डिस्प्ले.pde

आयात प्रसंस्करण.वीडियो।*;

आयात प्रसंस्करण। धारावाहिक। *;

सीरियल मायपोर्ट;

वीडियो बनाओ;

अंतिम अंक संख्या = २४;

इंट एलईडीनम = 0;

// PxPGetPixelDark() का उपयोग करने के लिए आपके पास ये वैश्विक चर होने चाहिए

इंट आरडार्क, जीडार्क, बीडार्क, एडार्क;

इंट आरएलईडी, जीएलईडी, बीएलईडी, एलईडी;

int rOrg, gOrg, bOrg, aOrg;

int rTemp, gTemp, bTemp, aTemp;

पिमेज आवरइमेज;

इंट रननंबर =0;

इंट स्वीकार्य त्रुटि = 3;

इंट किया गया;

int numPixelsInLed;

लंबा नेतृत्व की तीव्रता;

इंट एलईडी पावर;

लंबी लक्ष्य तीव्रता = ९९९९९९९९;

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

किया = नया [numLed];

numPixelsInLed = newint [numLed];

एलईडीइंटेंसिटी = न्यूलॉन्ग [numLed];

एलईडी पावर = न्यूिंट [numLed];

के लिए (int i=0; i<numLed; i++) {

एलईडी पावर = 255;

}

प्रिंटअरे (सीरियल। सूची ());

स्ट्रिंग पोर्टनाम = सीरियल.सूची () [३१];

myPort = newSerial (यह, पोर्टनाम, 9600);

आकार (640, 480);

वीडियो = नया कैप्चर (यह, चौड़ाई, ऊंचाई);

वीडियो.स्टार्ट ();

नोस्ट्रोक ();

निर्बाध();

देरी (1000); // सीरियल पोर्ट के खुलने की प्रतीक्षा करें

}

शून्य आहरण () {

अगर (वीडियो उपलब्ध ()) {

अगर (किया गया [ledNum] == 0) {

स्पष्ट प्रदर्शन ();

देरी (1000);

वीडियो.पढ़ें ();

छवि (वीडियो, 0, 0, चौड़ाई, ऊंचाई); // स्क्रीन पर वेबकैम वीडियो बनाएं

saveFrame ("डेटा/no_leds.jpg");

अगर (रननंबर! = 0) {

अगर ((ledIntensity[ledNum] - targetIntensity)*100/targetIntensity > स्वीकार्य त्रुटि) {

एलईडी पावर [ledNum] - = पाउ (0.75, रननंबर) * 100 + 1;

}

अगर ((लक्ष्य तीव्रता - नेतृत्व तीव्रता [ledNum]) * 100 / लक्ष्य तीव्रता> स्वीकार्य त्रुटि) {

एलईडी पावर [ledNum] + = पाउ (0.75, रननंबर) * 100 + 1;

}

अगर (abs(targetIntensity-ledIntensity[ledNum])*100/targetIntensity <= स्वीकार्य त्रुटि) {

किया [ledNum] = 1;

प्रिंट ("एलईडी");

प्रिंट (एलईडीनम);

प्रिंट ("किया गया");

}

अगर (एलईडी पावर [ledNum]> २५५) {

एलईडी पावर [एलईडीनम] = 255;

}

अगर (एलईडी पावर [ledNum] <0) {

एलईडी पावर [ledNum] = 0;

}

}

setLedPower (ledNum, LEDPower [ledNum]);

देरी (1000);

वीडियो.पढ़ें ();

छवि (वीडियो, 0, 0, चौड़ाई, ऊंचाई); // स्क्रीन पर वेबकैम वीडियो बनाएं

देरी(10);

जबकि (myPort.उपलब्ध ()> 0) {

int inByte = myPort.read ();

// प्रिंट (चार (इनबाइट));

}

स्ट्रिंग इमेजनाम = "डेटा /";

छविनाम+=str(ledNum);

इमेजनाम +="_led.jpg";

सेवफ्रेम (छवि नाम);

स्ट्रिंग मूल इमेजनाम = "डेटा/संगठन";

मूल छविनाम+=str(ledNum);

मूल छविनाम +=".jpg";

अगर (रननंबर == 0) {

सेवफ्रेम (ओरिजिनल इमेजनाम);

}

PImage noLedImg =loadImage("data/no_leds.jpg");

पीआईएममेज एलईडीआईएमजी = लोडइमेज (इमेजनाम);

पिमेज ओरिजिनलआईएमजी = लोडइमेज (ओरिजिनलइमेजनाम);

noLedImg.loadPixels ();

LEDImg.loadPixels ();

ओरिजिनलImg.loadPixels ();

पृष्ठभूमि (0);

लोड पिक्सेल ();

नेतृत्व तीव्रता [ledNum] =0;

numPixelsInLed [ledNum] =0;

के लिए (int x =0; x<चौड़ाई; x++) {

के लिए (int y =0; y<ऊंचाई; y++) {

PxPGetPixelDark(x, y, noLedImg.pixels, चौड़ाई);

PxPGetPixelLed(x, y, ledImg.pixels, चौड़ाई);

PxPGetPixelOrg(x, y, originalImg.pixels, चौड़ाई);

अगर ((आरओआरजी+जीओआरजी/2+बीओआरजी/3)-(आरडार्क+जीडार्क/2+बीडार्क/3)>75) {

एलईडी इंटेंसिटी [ledNum] = लेडइंटेंसिटी [ledNum] + (rLed+gLed/2+bLed/3) -(rDark+gDark/2+bDark/3);

rTemp=255;

जीटेम्प = २५५;

बीटेम्प = २५५;

numPixelsInLed [ledNum]++;

} अन्यथा {

rTemp = 0;

जीटेम्प = 0;

बीटेम्प = 0;

}

PxPSetPixel (x, y, rTemp, gTemp, bTemp, 255, पिक्सेल, चौड़ाई);

}

}

एलईडी तीव्रता [ledNum] / = numPixelsInLed [ledNum];

अगर (लक्ष्य तीव्रता> नेतृत्व तीव्रता [ledNum] && रननंबर == 0) {

लक्ष्य तीव्रता = नेतृत्व तीव्रता [ledNum];

}

अद्यतन पिक्सेल ();

}

प्रिंट (एलईडीनम);

प्रिंट (',');

प्रिंट (एलईडी पावर [ledNum]);

प्रिंट (',');

println (नेतृत्व की तीव्रता [ledNum]);

एलईडीनम ++;

अगर (ledNum == numLed) {

इंट डेन्ज़ो = 0;

के लिए (int i=0; i<numLed; i++) {

डेन्ज़ो + = किया ;

}

अगर (डोनज़ो == numLed) {

println ("हो गया");

के लिए (int i=0; i<numLed; i++) {

प्रिंट (मैं);

प्रिंट ("\ टी");

प्रिंट्लन (एलईडी पावर );

}

प्रिंट ("इंट लेवल [");

प्रिंट (एलईडीनम);

प्रिंट ("] = {");

के लिए (int i=0; i<numLed-1; i++) {

प्रिंट (एलईडी पावर );

प्रिंट (',');

}

प्रिंट (एलईडी पावर [numLed -1]);

प्रिंट्लन ("};");

लाइटअप ईवन ();

जबकि (सच);

}

प्रिंट ("लक्ष्य तीव्रता:");

अगर (रननंबर == 0) {

लक्ष्य तीव्रता - = 1;

}

प्रिंट्लन (लक्ष्य तीव्रता);

नेतृत्व संख्या = 0;

रननंबर++;

}

}

}

voidPxPGetPixelOrg(intx, inty, int pixelArray, intpixelsWidth) {

int thisPixel=pixelArray[x+y*pixelsWidth]; // रंगों को पिक्सेल से एक इंट के रूप में प्राप्त करना

aOrg = (यह पिक्सेल >> 24) &0xFF; // हमें प्रत्येक घटक को अकेले प्राप्त करने के लिए शिफ्ट और मास्क करने की आवश्यकता है

rOrg = (यह पिक्सेल >>16) &0xFF; // यह लाल (), हरा (), नीला () को कॉल करने से तेज है

gOrg = (यह पिक्सेल >>8) &0xFF;

बीओआरजी = यह पिक्सेल &0xFF;

}

voidPxPGetPixelDark(intx, inty, int pixelArray, intpixelsWidth) {

int thisPixel=pixelArray[x+y*pixelsWidth]; // रंगों को पिक्सेल से एक इंट के रूप में प्राप्त करना

aDark = (यह पिक्सेल >> 24) &0xFF; // हमें प्रत्येक घटक को अकेले प्राप्त करने के लिए शिफ्ट और मास्क करने की आवश्यकता है

rDark = (यह पिक्सेल >>16) &0xFF; // यह लाल (), हरा (), नीला () को कॉल करने से तेज है

gDark = (यह पिक्सेल >>8) &0xFF;

बीडार्क = यह पिक्सेल &0xFF;

}

voidPxPGetPixelLed(intx, inty, int pixelArray, intpixelsWidth) {

int thisPixel=pixelArray[x+y*pixelsWidth]; // रंगों को पिक्सेल से एक इंट के रूप में प्राप्त करना

एलेड = (यह पिक्सेल >> 24) &0xFF; // हमें प्रत्येक घटक को अकेले प्राप्त करने के लिए शिफ्ट और मास्क करने की आवश्यकता है

आरएलडी = (यह पिक्सेल >>16) &0xFF; // यह लाल (), हरा (), नीला () को कॉल करने से तेज है

जीएलईडी = (यह पिक्सेल >>8) &0xFF;

बीएलईडी = यह पिक्सेल &0xFF;

}

voidPxPSetPixel(intx, inty, intr, intg, intb, inta, int pixelArray, intpixelsWidth) {

ए = (ए << 24);

आर = आर <<16; // हम सभी 4 घटकों को एक int. में पैक कर रहे हैं

जी = जी <<8; // इसलिए हमें उन्हें उनके स्थान पर स्थानांतरित करने की आवश्यकता है

रंग argb = a | आर | जी | बी; // बाइनरी "या" ऑपरेशन उन सभी को एक int. में जोड़ता है

पिक्सेलअरे [एक्स + वाई * पिक्सेलविड्थ] = argb; // फाइनल में हम इंट को ते रंगों के साथ पिक्सल में सेट करते हैं

}

GitHub द्वारा ❤ के साथ होस्ट किए गए raw कैलिब्रेटडिस्प्ले.pde देखें

चरण 11: बिदाई टिप्पणी

बचने के लिए नुकसान:

* लकड़ी के साथ, आपको वह मिलता है जिसके लिए आप भुगतान करते हैं। तो, अच्छी गुणवत्ता वाली लकड़ी प्राप्त करें। बिर्च प्लाईवुड एक अच्छा विकल्प है; कोई भी हल्की ठोस लकड़ी भी अच्छा करेगी। मैं लकड़ी पर सस्ता हो गया और अपने फैसले पर खेद व्यक्त किया।

* अधिक से कम ड्रिल करना बेहतर है। मेरे टुकड़े के लिए कुछ छेद बहुत गहरे हो गए। और एपॉक्सी सामने के चेहरे पर दिखाई देता है। एक बार जब आप इसे नोटिस करते हैं तो यह बहुत ध्यान देने योग्य होता है।

* स्ट्रेट एंड के बजाय बॉल एंड ड्रिल बिट का उपयोग करें। मैंने बॉल एंड बिट के साथ प्रयोग नहीं किया है, लेकिन मुझे पूरा यकीन है कि परिणाम काफी बेहतर होंगे।

मैं इन्हें Etsy या टिंडी पर बेचने के विचार से छेड़खानी कर रहा हूं। मैं वास्तव में इसकी सराहना करता हूं यदि आप नीचे टिप्पणी कर सकते हैं यदि आपको लगता है कि यह समझ में आता है:)