DIY फोटोग्राफिक लाइटमीटर: 5 कदम

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

यह निर्देशयोग्य एक साधारण छोटे और सस्ते घटना लाइटमीटर के निर्माण पर कुछ विचार साझा करता है।

जैसा कि इंस्ट्रक्शंस मुझे अपने वीडियो डालने नहीं देंगे, इस लिंक को आजमाएं:

www.youtube.com/embed/avQD10fd52s

मेरे लिए लक्ष्य मेरे ब्रोनिका ईटीआरएसआई मध्यम प्रारूप फिल्म कैमरे के साथ एक लाइट-मीटर था।

चीजें जो मैं चाहता था कि यह विशेषता हो:

• एकल एएसए (100) क्योंकि मैं लगभग केवल एएसए 100 फिल्म का उपयोग करता हूं
• जितना संभव हो उतना छोटा
• केवल मुझे ऐसे संयोजन दें जो मेरी ब्रोनिका पुन: उत्पन्न कर सकें, जिसका अर्थ है f2.8-f22 और 1sec से 1/500 वां सेकंड
• सादे समय और एपर्चर मानों को छोड़कर कोई बकवास विशेषता नहीं है

मेरे द्वारा उपयोग की जाने वाली चीजें:

• Adafruit(Vishay) VEML 7700 डिजिटल लक्स-मीटर (लगभग 5$)
• Adafruit Trinket M0 माइक्रो कंट्रोलर (लगभग 9$)
• 128x32 OLED डिस्प्ले (लगभग 10$)
• इसे अस्थायी रूप से चालू करने के लिए एक पुशबटन (कुछ सेंट)
• स्ट्रिप-बोर्ड का एक छोटा सा टुकड़ा, क्योंकि मैं केबल का उपयोग नहीं करने की कोशिश करता हूं, लेकिन आप निश्चित रूप से केबल का भी उपयोग कर सकते हैं

चरण 1: मूल गणना | लक्स टू ईवी

मेरे द्वारा खरीदा गया सेंसर दो विशेषताओं का उपयोग करता है जो मुझे इस पर निर्णय लेने देते हैं:

• "आयाम-कम" प्रकाश मानों के बजाय 16 बिट लक्स मान आउटपुट करता है
• I2C. के माध्यम से मानों को आउटपुट करता है

एक फोटोग्राफिक लाइट मीटर एक्सपोजर वैल्यू (ईवी) का उपयोग करता है जो सेंसर मैंने खरीदा है वह लक्स वैल्यू का उपयोग करता है, जो एक पूर्ण भिन्न स्केल है। तो पहला कदम ईवीएस को लक्स वैल्यू से प्राप्त करना है जो सेंसर प्रदान करता है।

विकिपीडिया पर एक त्वरित झलक और आप घटना मीटरिंग के लिए एक सूत्र ढूंढ सकते हैं और ईवी को लक्स में परिवर्तित कर सकते हैं:

ई =2.5 * 2^ईवी

जहां E को लक्स में मापा जाता है।

जैसा कि हमें पहले से ही सेंसर से लक्स वैल्यू मिल गई है और ईवी वैल्यू चाहते हैं, हमें फॉर्मूला को फिर से बनाना होगा, जो हमें मिलता है:

ईवी = लॉग2 (ई/2.5)

तो यह पहली गणना है जिसे लाइटमीटर से फोटोग्राफिक मान प्राप्त करने के लिए किया जाना है।

संलग्न लुकअप तालिका में आप सभी मान देख सकते हैं जो इस लाइटमीटर में उपयोग किए जाएंगे, साथ में लक्स और ईवी मानों के अनुसार।

चरण 2: प्रदर्शन पर मान प्रस्तुत करना | एडफ्रूट जीएफएक्स लाइब्रेरी

मैंने पहले मूल्यों को पूरे चरणों में प्रस्तुत करने की कोशिश की, क्योंकि यही वह है जो मैं अपना ब्रोनिका सेट कर सकता हूं, लेकिन यह मुझे एक समस्या की ओर ले जाता है:

आइए मान लें कि लक्स सेंसर बिल्कुल 20480 का मान आउटपुट करता है, इसका मतलब यह बिल्कुल ईवी 13 होगा, इसलिए मैं उदाहरण के लिए अपने कैमरे को एफ 4 और 1/500 सेकेंड पर सेट कर सकता हूं और जाना अच्छा होगा।

इसके बाद, मान लेते हैं कि लक्स सेंसर EV13 के तहत 20479 लक्स, 1 लक्स का उत्पादन करेगा, जो कि 12 के EV मान का उत्पादन करेगा, लेकिन यह EV13 से सिर्फ एक लक्स दूर है।

इसलिए मैं एक सेकंड के f2.8 और 1/500 वें पर अपना कैमरा सेट करूंगा जो मेरे बिना 1 स्टॉप को ओवरएक्सपोज कर देगा, यहां तक कि यह भी जानते हुए कि मैं EV13 के कितना करीब था।

निष्कर्ष: हमें कम से कम यह देखने के लिए मूल्यों के किसी प्रकार के एनालॉग डिस्प्ले की आवश्यकता है कि मीटर अगले या पिछले ईवी चरण से कितना करीब या दूर है।

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

एक एपर्चर मानों के लिए, एक समय के लिए।

जीएफएक्स लाइब्रेरी ग्राफिक्स प्रस्तुत करने के लिए 8 बिट मानों का उपयोग करती है, इसलिए मैंने एक एक्सएलएस शीट बनाई (ऊपर की छवि देखें)।

• प्रत्येक मान में प्रति मान पिक्सेल की समान मात्रा होती है
• समय और एपर्चर में प्रति पंक्ति मानों की मात्रा समान होती है
• मैंने प्रत्येक बाइट की शुरुआत में आवश्यक "बी" और अंत में "," जोड़ा
• मैंने फिर इसे एक सादे पाठ और वॉइला में निर्यात किया: मुझे तीसरा ग्राफिक संलग्न मिला

समय मान 1/8 सेकंड से शुरू होते हैं और एपर्चर मान f2.8 से शुरू होते हैं।

पिछले चरण की लुकअप तालिका का उपयोग करके हम जानते हैं कि यह 160 लक्स या ईवी 6 का प्रतिनिधित्व करता है।

तब सबसे गहरा मान एक सेकंड का f22 और 1/500 वां होगा।

फिर से लुकअप टेबल के माध्यम से हम देख सकते हैं कि इसका मतलब है 655360 लक्स या ईवी18

अब तक सब ठीक है।

इसलिए EV6 पर अपर्चर ग्राफ़िक सबसे बाईं ओर, समय सबसे दाईं ओर और EV18 पर इसके विपरीत होना चाहिए

चरण 3: लक्स मूल्यों को पढ़ना और क्षतिपूर्ति करना | वीईएमएल७७००

Vishay VEML7700 Adafruit के अपने बोर्ड के लिए उपयोग किए जाने वाले डेटाशीट के माध्यम से स्क्रॉल करते समय, मुझे एक परेशान करने वाला नोटिस मिला:

सेंसर केवल 0 और 1000Lux (!) के बीच रैखिक काम करता है

नारंगी (रैखिक) रेखा और नीली (वास्तविक सेंसर आउटपुट) रेखा के साथ स्क्रीनशॉट देखें

सनलाइट (EV15) लगभग ८०,००० लक्स है, जिसका अर्थ है कि सेंसर के गैर-रैखिक हिस्से के मुआवजे के बिना यह एक प्रकाश मीटर के रूप में पूरी तरह से बेकार होगा।

Vishay यह जानता है, इसलिए उन्होंने अपने ग्राहकों को एक अन्य पीडीएफ़ प्रदान किया, जिसे डिज़ाइनिंग द वीईएमएल७७०० इनटू ए एप्लीकेशन कहा जाता है।

इस पीडीएफ में आप सेंसर की गैर-रैखिकता की भरपाई के लिए एक सूत्र पा सकते हैं:

LUX_CORR = 6.0135e-13*pow(LUX, 4)-9.3924e-9*pow(LUX, 3)+8.1488e-5*pow(LUX, 2)+1.0023*LUX

जहां LUX_CORR सही लक्स-वैल्यू है और LUX वह मान है जो सेंसर आउटपुट करता है।

वे वेरिएबल्स हैं जिनका मैंने उपयोग किया है, उनकी शीट में अलग-अलग इस्तेमाल किए गए हैं।

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

इसलिए पहले कुछ दिनों में मैं सोच रहा था कि मेरा लाइटमीटर सीधे धूप में भी अधिकतम 20000 लक्स का उत्पादन क्यों करता है।

यदि आप लाल और नीली रेखा के साथ ग्राफ़ पर एक नज़र डालते हैं तो आप देख सकते हैं कि क्यों: क्योंकि यह मुआवजे के फार्मूले के बिना अधिक नहीं जा सकता।

लेकिन सेंसर के दस्तावेज़ीकरण में एक और संकेत छिपा है:

यह मुआवजा फॉर्मूला केवल तभी काम करता है जब आप सेंसर को 25ms और 1/8 का लाभ अनुपात सेट करते हैं।

ऐडफ्रूट्स लाइब्रेरी के साथ इसे जोड़कर बहुत आसानी से किया गया है:

veml.setGain(VEML7700_GAIN_1_8);veml.setIntegrationTime(VEML7700_IT_25MS);

आपके शून्य सेटअप में ()

तो इसे 1/8 और 25ms पर सेट करने और क्षतिपूर्ति फॉर्मूला जोड़ने के बाद आप 120000 लक्स तक माप सकते हैं, जो 80-100k लक्स पर सूरज की रोशनी को कवर करने के लिए पर्याप्त है।

चरण 4: अरुडिनो / सी-कोड

जैसा कि यह आपके उपयोग किए गए डिस्प्ले और पसंदीदा नियंत्रक पर निर्भर करता है, मैं बहुत अधिक विस्तार में नहीं जाऊंगा, बस कुछ विचार और संकेत जोड़ने के लिए, विशेष रूप से Adafruit पुस्तकालयों और 128x32 px OLED का उपयोग करते समय:

शून्य सेटअप में:

मैंने वीईएमएल लाइब्रेरी-पार्ट को यहां सेट किया है:

veml.setGain(VEML7700_GAIN_1_8);

veml.setIntegrationTime (VEML7700_IT_25MS);

veml.setLowThreshold(१००००);

veml.set HighThreshold (20000);

veml.interruptEnable (सच);

शून्य लूप में:

मुआवजा जोड़ना सुनिश्चित करें:

int LUX_CORR = 6.0135e-13*pow(LUX, 4)-9.3924e-9*pow(LUX, 3)+8.1488e-5*pow(LUX, 2)+1.0023*LUX;

Lux से EV प्राप्त करने के लिए इस लाइन का उपयोग करें:

फ्लोट ईवी = लॉग 2 ((LUX_CORR / 2.5));

बिटमैप्स को स्थानांतरित करना

यह सुनिश्चित करने के लिए कि बिटमैप्स केवल तभी चलते हैं जब मान 160Lux और 655360Lux के बीच हों, जैसा कि पिछले चरण में बताया गया है, इसे if क्लॉज में इस तरह लपेटें:

अगर (LUX_CORR > 159 && LUX_CORR <655361)

आगे हमें निर्देशांक के लिए EV मानों को मैप करने की आवश्यकता है, क्योंकि EV की सीमा दोहरे अंक हैं और हम उन्हें पूरे डिस्प्ले में 128px से अधिक के डिस्प्ले से बाहर ले जाना चाहते हैं, हमें बड़े मूल्यों की आवश्यकता है।

जैसा कि हमारे पास पहले से ही एक फ्लोट नंबर है, हम इसे 100 से गुणा करते हैं और निर्देशांक को मैप करने के लिए उस पूर्णांक का उपयोग करते हैं

इंट EV_DSPL = EV*100;

तथा:

समय = नक्शा (EV_DSPL, 600, 1900, -260, 39); APERTURE = नक्शा (EV_DSPL, 600, 1900, 39, -260);

जैसा कि आप मेरे मामले में देख सकते हैं कि बिटमैप की न्यूनतम स्थिति -260px होगी और अधिकतम 39px होगी

यहां यह भी देखा जा सकता है कि मैंने निर्देशांकों को स्विच किया ताकि दो बिटमैप विपरीत दिशा में आगे बढ़ सकें

आगे हमें निर्देशांक के अनुसार बिटमैप्स को स्थानांतरित करने की आवश्यकता है:

display.drawBitmap((TIME), (0), TIMES_bmp, 352, 16, 1);display.drawBitmap((APERTURE), (15), APERTURES_bmp, 352, 16, 1);

और बस इतना ही करने की जरूरत है

एक बोनस के रूप में मैं सीधे EV और Lux मान प्रदर्शित करता हूं जब सेंसर 160Lux के तहत मान आउटपुट करता है, सिर्फ इसलिए कि मैं इसका परीक्षण करते समय सामान देखना चाहता था।

चरण 5: इसे एक साथ रखना

दोनों के रूप में, प्रदर्शन और सेंसर संचार के लिए I2C का उपयोग कर रहे हैं, वास्तविक हार्डवेयर का निर्माण उतना ही सरल है जितना संभवतः हो सकता है।

बस डेटा, क्लॉक ग्राउंड और 3V लाइनों को Arduino से कनेक्ट करें और आप जाने के लिए तैयार हैं।

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

मेरे ग्राफिक पर, सफेद डॉट्स को डिस्प्ले और सेंसर से जोड़ा जाना चाहिए और पीले डॉट्स को ट्रिंकेट से जोड़ा जाना चाहिए।

एकमात्र अपवाद I2C लाइन का डेटा-पिन होगा जो डिस्प्ले से जुड़ता है, वह पिन ट्रिंकेट डेटा पिन से भी जुड़ता है।

मैंने ऑन/ऑफ स्विच का उपयोग नहीं करना चुना, बल्कि जब तक मैं बटन दबाता हूं, तब तक इसे अस्थायी रूप से पावर देने के लिए एक पुशबटन और दो 3V बटन सेल का उपयोग करें। यह एक सेकंड के 1/10 से कम समय में शक्ति देता है ताकि मेरे लिए एक बटन को छोड़ने और इसे छोटा करने के लिए पर्याप्त हो।