Arduino Datalogger: 8 कदम (चित्रों के साथ)

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

इस ट्यूटोरियल में, हम Arduino का उपयोग करके एक साधारण डेटा लकड़हारा बनाने जा रहे हैं। बात यह है कि सूचना को कैप्चर करने और टर्मिनल पर प्रिंट करने के लिए Arduino का उपयोग करने की मूल बातें सीखना है। हम कई कार्यों को पूरा करने के लिए इस मूल सेटअप का उपयोग कर सकते हैं।

आरंभ करना:

आपको टिंकरकाड (www.tinkercad.com) खाते की आवश्यकता होगी। हेड ओवर करें और अपने ईमेल या सोशल मीडिया अकाउंट से साइन अप करें।

लॉग इन करना आपको टिंकरकाड डैशबोर्ड पर ले जाता है। बाईं ओर "सर्किट" पर क्लिक करें और "नया सर्किट बनाएं" चुनें। आएँ शुरू करें!

आप पूरी फ़ाइल TInkercad सर्किट पर पा सकते हैं - इसे जांचने के लिए धन्यवाद!

चरण 1: कुछ घटक जोड़ें

आपको कुछ बुनियादी घटकों की आवश्यकता होगी। इसमे शामिल है:

• अरुडिनो बोर्ड
• ब्रेड बोर्ड

उन्हें खोजकर जोड़ें और उन्हें मध्य क्षेत्र में क्लिक-खींचें।

ब्रेडबोर्ड को Arduino के ऊपर रखें। इससे बाद में कनेक्शन देखना आसान हो जाता है।

चरण 2: ब्रेडबोर्ड के बारे में एक नोट

रैपिड प्रोटोटाइप के लिए ब्रेडबोर्ड एक सुपर सहायक उपकरण है। हम इसका उपयोग घटकों को जोड़ने के लिए करते हैं। ध्यान देने योग्य कुछ बातें।

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

चरण 3: दो सेंसर जोड़ें

हम जिन दो सेंसर का उपयोग कर रहे हैं वे एक फोटोसेंसिटिव सेंसर और तापमान सेंसर हैं।

ये सेंसर प्रकाश और तापमान का मूल्यांकन करते हैं। हम Arduino का उपयोग मान को पढ़ने और Arduino पर सीरियल मॉनिटर में प्रदर्शित करने के लिए करते हैं।

दो सेंसर खोजें और जोड़ें। सुनिश्चित करें कि वे ब्रेडबोर्ड पर कॉलम में स्थित हैं। उनके बीच इतनी जगह रखें कि उन्हें आसानी से देखा जा सके।

चरण 4: सहज संवेदक

1. फोटोसेंसिटिव सेंसर के लिए, Arduino पर 5V पिन से एक तार को ब्रेडबोर्ड में दाहिने पैर के समान कॉलम में जोड़ें। तार का रंग बदलकर लाल कर दें।
2. बाएं पैर को उसी कॉलम में पिन के माध्यम से Arduino पर A0 (A-शून्य) पिन से कनेक्ट करें। यह एनालॉग पिन है, जिसका उपयोग हम सेंसर से मान को पढ़ने के लिए करेंगे। इस तार को पीला या लाल या काले रंग के अलावा कुछ और रंग दें।

3. बोर्ड पर एक रोकनेवाला (खोज और क्लिक-ड्रैग) रखें। यह सर्किट को पूरा करता है और सेंसर और पिन की सुरक्षा करता है।

   • इसे चारों ओर घुमाएं ताकि यह स्तंभों के पार चला जाए।
   • ब्रेडबोर्ड पर एक पैर को दाहिने पैर के कॉलम से कनेक्ट करें

   • रोकनेवाला के दूसरे सिरे से एक तार को जमीन पर रखें

     तार का रंग बदलकर काला कर दें।

4. सभी कनेक्शनों को दोबारा जांचें। अगर कुछ सही जगह पर नहीं है, तो यह ठीक से काम नहीं करेगा।

चरण 5: कोड शुरू करें

आइए इस घटक के लिए कोड देखें।

सबसे पहले, इस चरण में तीसरी छवि को देखें। इसमें दो कार्यों के साथ कुछ कोड शामिल हैं:

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

शून्य लूप ()

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

सेटअप फ़ंक्शन एक बार चलता है जब Arduino बूट होता है (जब आप इसे प्लग इन करते हैं या बैटरी संलग्न करते हैं)।

लूप फ़ंक्शन मिलीसेकंड से एक स्थिर लूप में चलता है जो सेटअप फ़ंक्शन पूरा करता है।

जब आप Arduino के रन करते हैं तो लूप फंक्शन में आप जो कुछ भी डालते हैं वह चलेगा। बाहर की हर चीज जो बुलाए जाने पर ही चलेगी। जैसे अगर हमने लूप के बाहर किसी अन्य फंक्शन को परिभाषित और कॉल किया है।

टास्क

Tinkercad में बटन के साथ कोड पैनल खोलें। ब्लॉक ड्रॉपडाउन को टेक्स्ट में बदलें। पॉप अप होने वाले चेतावनी बॉक्स से सहमत हों। अब, इस चरण में तीसरी छवि में टेक्स्ट को छोड़कर आप जो कुछ भी देखते हैं उसे हटा दें।

चर

आरंभ करने के लिए, हमें कुछ चर निर्दिष्ट करने की आवश्यकता है ताकि हम अपने कोड को वास्तव में कुशल बना सकें।

चर बाल्टी की तरह होते हैं जो केवल एक वस्तु को पकड़ सकते हैं (सी ++ जिसे हम ऑब्जेक्ट-ओरिएंटेड कहते हैं)। हां, हमारे पास सरणियाँ हैं, लेकिन ये विशेष चर हैं और हम उनके बारे में बाद में बात करेंगे। जब हम एक वेरिएबल असाइन करते हैं, तो हमें यह बताना होता है कि यह किस प्रकार का है, फिर इसे एक वैल्यू दें। यह इस तरह दिख रहा है:

int someVar = A0;

इसलिए, हमने एक वेरिएबल असाइन किया और इसे टाइप इंट दिया। एक इंट एक पूर्णांक या एक पूर्ण संख्या है।

"लेकिन आपने पूर्ण संख्या का उपयोग नहीं किया!", मैंने सुना है कि आप कहते हैं। यह सच है।

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

तो, हमारे कोड के लिए हम संलग्न सेंसर के लिए एक चर लिखेंगे। जबकि मैं इसे एक साधारण नाम देने की सलाह देता हूं, यह आप पर निर्भर है।

आपका कोड इस तरह दिखना चाहिए:

इंट लाइट सेंसर = ए0;

शून्य सेटअप () { } शून्य लूप () { }

अब, Arduino को बताते हैं कि उस पिन पर लगे सेंसर को कैसे हैंडल करना है। हम पिन मोड सेट करने के लिए सेटअप के अंदर एक फ़ंक्शन चलाएंगे और Arduino को बताएंगे कि इसे कहां देखना है।

इंट लाइट सेंसर = ए0;

शून्य सेटअप () {पिनमोड (लाइट सेंसर, इनपुट); } शून्य लूप () { }

पिनमोड फ़ंक्शन Arduino को बताता है कि पिन (A0) का उपयोग INPUT पिन के रूप में किया जाएगा। CamelCaseUsed पर ध्यान दें (देखें प्रत्येक पहला अक्षर एक कैपिटल है, क्योंकि इसमें कूबड़ होते हैं, इसलिए… ऊंट…!) चर और फ़ंक्शन नामों के लिए। यह एक सम्मेलन है और इसकी आदत डालने के लिए अच्छा है।

अंत में, आइए कुछ डेटा प्राप्त करने के लिए analogRead फ़ंक्शन का उपयोग करें।

इंट लाइट सेंसर = ए0;

शून्य सेटअप () {पिनमोड (लाइट सेंसर, इनपुट); } शून्य लूप () {इंट रीडिंग = एनालॉग रीड (लाइट सेंसर); }

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

इंट लाइट सेंसर = ए0;

शून्य सेटअप () {// पिन मोड पिनमोड सेट करें (लाइट सेंसर, इनपुट); // सीरियल लाइब्रेरी जोड़ें Serial.begin(9600); } शून्य लूप () {// सेंसर इंट रीडिंग पढ़ें = एनालॉग रीड (लाइट सेंसर); // मान को मॉनिटर पर प्रिंट करें Serial.print("Light:"); Serial.println (पढ़ना); // अगले लूप में 3 सेकंड की देरी (3000) की देरी करें; }

कुछ नई बातें! सबसे पहले, आप इन्हें देखेंगे:

// यह एक टिप्पणी है

हम अन्य लोगों को यह बताने के लिए टिप्पणियों का उपयोग करते हैं कि हमारा कोड क्या कर रहा है। आपको इनका इस्तेमाल अक्सर करना चाहिए। कंपाइलर इन्हें नहीं पढ़ेगा और उन्हें कोड में बदल देगा।

अब, हमने लाइन के साथ सीरियल लाइब्रेरी भी जोड़ दी है

सीरियल.बेगिन (9600)

यह एक फ़ंक्शन का एक उदाहरण है जो एक तर्क लेता है। आपने लाइब्रेरी को सीरियल कहा, फिर एक फ़ंक्शन चलाया (हम जानते हैं कि यह गोल ब्रेसिज़ के कारण एक फ़ंक्शन है) और एक पूर्णांक में एक तर्क के रूप में पारित किया, सीरियल फ़ंक्शन को 9600baud पर संचालित करने के लिए सेट किया। चिंता न करें क्यों - बस यह जान लें कि यह काम करता है, अभी के लिए।

अगला काम हमने सीरियल मॉनीटर पर प्रिंट किया। हमने दो कार्यों का उपयोग किया:

// यह बिना लाइन ब्रेक के सीरियल में प्रिंट करता है (अंत में एक एंटर)

सीरियल.प्रिंट ("लाइट:"); // यह एक लाइन ब्रेक में डालता है इसलिए हर बार जब हम पढ़ते और लिखते हैं, तो यह एक नई लाइन पर चला जाता है Serial.println(reading);

यह देखना महत्वपूर्ण है कि प्रत्येक का एक अलग उद्देश्य होता है। सुनिश्चित करें कि आपके तार दोहरे-उद्धरण चिह्नों का उपयोग करते हैं और आप बृहदान्त्र के बाद स्थान छोड़ते हैं। यह उपयोगकर्ता के लिए पठनीयता में मदद करता है।

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

महान! हम चलते हैं!

चरण 6: सिमुलेशन

हमेशा सिमुलेशन चलाकर चीजों के काम की जाँच करें। इस सर्किट के लिए, आपको सिम्युलेटर को यह जांचने के लिए भी खोलना होगा कि यह काम करता है और अपने मूल्यों की जांच करता है।

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

• लाल डिबगिंग विंडो में इंगित लाइनों पर ध्यान दें जो आपके सामने प्रस्तुत की जाएंगी।
• यदि आपका कोड सही है और सिमुलेशन अभी भी काम नहीं कर रहा है, तो अपनी वायरिंग जांचें।
• पृष्ठ को पुनः लोड करें - आपके पास एक असंबंधित सिस्टम/सर्वर त्रुटि हो सकती है।
• कंप्यूटर पर अपनी मुट्ठी हिलाएं, और फिर से जांचें। सभी प्रोग्रामर ऐसा करते हैं। सभी। NS। समय।

चरण 7: अस्थायी सेंसर को तार दें

मुझे लगता है कि अब आप सही रास्ते पर हैं। आगे बढ़ें और तापमान संवेदक को तार दें जैसा कि चित्र से पता चलता है। ध्यान दें कि 5V और GND तारों को उसी स्थान पर रखा गया है जहां प्रकाश के लिए है। यह ठीक है। यह एक समानांतर सर्किट की तरह है और सिम्युलेटर में समस्या नहीं पैदा करेगा। एक वास्तविक सर्किट में, आपको बेहतर बिजली प्रबंधन और कनेक्शन प्रदान करने के लिए ब्रेकआउट बोर्ड या शील्ड का उपयोग करना चाहिए।

अब, कोड को अपडेट करते हैं।

अस्थायी सेंसर कोड

यह थोड़ा अधिक कठिन है, लेकिन केवल इसलिए कि हमें पठन को परिवर्तित करने के लिए कुछ गणित करना है। यह बहुत खराब नहीं है।

इंट लाइट सेंसर = ए0;

int tempSensor = A1; शून्य सेटअप () {// पिन मोड पिनमोड (लाइट सेंसर, इनपुट) सेट करें; // सीरियल लाइब्रेरी जोड़ें Serial.begin(9600); } शून्य लूप () {// अस्थायी सेंसर // एक पंक्ति पर दो चर बनाना - ओह दक्षता! // फ्लोट संस्करण एक दशमलव फ्लोट वोल्टेज, डिग्री सी स्टोर करने के लिए; // पिन का मान पढ़ें और इसे 0 - 5 से रीडिंग में बदलें // अनिवार्य रूप से वोल्टेज = (5/1023 = 0.004882814); वोल्टेज = (एनालॉगरीड (टेम्पसेंसर) * ०.००४८८२८१४); // डिग्री सी डिग्री में कनवर्ट करें सी = (वोल्टेज - ०.५) * १००; // सीरियल मॉनिटर पर प्रिंट करें Serial.print("Temp:"); सीरियल.प्रिंट (डिग्रीसी); Serial.println ("ओसी"); // सेंसर इंट रीडिंग पढ़ें = एनालॉग रीड (लाइट सेंसर); // मान को मॉनिटर पर प्रिंट करें Serial.print("Light:"); Serial.println (पढ़ना); // अगले लूप में 3 सेकंड की देरी (3000) की देरी करें; }

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

सबसे पहले, मैंने लाइन जोड़ी

int tempSensor = A1;

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

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

फ्लोट वोल्टेज, डिग्री सी;

यह वास्तव में मददगार है क्योंकि यह मेरे द्वारा लिखी जाने वाली पंक्तियों की संख्या में कटौती करता है और कोड को गति देता है। हालाँकि, त्रुटियों को खोजना कठिन हो सकता है।

अब, हम रीडिंग करेंगे और इसे स्टोर करेंगे, फिर इसे हमारे आउटपुट वैल्यू में बदल देंगे।

वोल्टेज = (एनालॉगरीड (टेम्पसेंसर) * ०.००४८८२८१४);

डिग्रीसी = (वोल्टेज - ०.५) * १००;

वे दो पंक्तियाँ कठिन लगती हैं, लेकिन पहले में हम रीडिंग ले रहे हैं और इसे 0.004 से गुणा कर रहे हैं … क्योंकि यह 1023 (एनालॉग रीडिंग इस मान को लौटाता है) को 5 में से रीडिंग में बदल देता है।

वहां दूसरी पंक्ति दशमलव बिंदु को स्थानांतरित करने के लिए उस रीडिंग को 100 से गुणा करती है। यह हमें तापमान देता है। साफ!

चरण 8: परीक्षण और जाँच

योजना बनाने वाली सभी चीजें, आपके पास एक कार्यशील सर्किट होना चाहिए। सिमुलेशन चलाकर और सीरियल मॉनिटर का उपयोग करके परीक्षण करें। यदि आप में त्रुटियां हैं, तो जांचें, फिर से जांचें और अपनी मुट्ठी हिलाएं।

इसे आपने बनाया? साझा करें और हमें अपनी कहानी बताएं!

यह आपके लिए एम्बेडेड अंतिम सर्किट है ताकि आप अंतिम निर्माण को खेल/परीक्षण कर सकें। ट्यूटोरियल पूरा करने के लिए धन्यवाद!