मिलिस के साथ Arduino समय के तरीके (): 4 कदम

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

इस लेख में हम मिलिस (); कार्य करते हैं और इसे विभिन्न समय उदाहरण बनाने के लिए उपयोग में लाते हैं।

मिलिस? लिप-सिंकर्स से कोई लेना-देना नहीं … उम्मीद है कि आपने मिलि को एक-हजारवें हिस्से के लिए संख्यात्मक उपसर्ग के रूप में मान्यता दी है; जो माप की एक इकाई को 0.001 (या ऋणात्मक 3 के घात से दस) से गुणा कर रहा है।

दिलचस्प बात यह है कि हमारे Arduino सिस्टम एक स्केच की शुरुआत से मिलीसेकंड (एक सेकंड के हजारों) की संख्या की गणना करेंगे जब तक कि गिनती परिवर्तनीय प्रकार में संग्रहीत होने में सक्षम अधिकतम संख्या तक नहीं पहुंच जाती (एक 32-बिट [चार बाइट] पूर्णांक - जो शून्य से (2^32)-1 (2^32)-1, या 4294967295 मिलीसेकंड से 49.71027-विषम दिनों में परिवर्तित होता है।

जब Arduino रीसेट हो जाता है तो काउंटर रीसेट हो जाता है, यह अधिकतम मूल्य तक पहुंच जाता है या एक नया स्केच अपलोड किया जाता है। किसी विशेष समय पर काउंटर का मूल्य प्राप्त करने के लिए, बस फ़ंक्शन को कॉल करें - उदाहरण के लिए:

प्रारंभ = मिली ();

जहां प्रारंभ एक अहस्ताक्षरित लंबा चर है। आपको मिलिस () को क्रिया में दिखाने के लिए यहां एक बहुत ही सरल उदाहरण दिया गया है:

/* मिली () प्रदर्शन */

अहस्ताक्षरित लंबी शुरुआत, समाप्त, बीता हुआ;

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

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

शून्य लूप ()

{ Serial.println ("शुरू करें …"); प्रारंभ = मिली (); देरी (1000); समाप्त = मिली (); Serial.println ("समाप्त"); बीता हुआ = समाप्त-शुरू; सीरियल.प्रिंट (बीता हुआ); Serial.println ("मिलीसेकंड बीता हुआ"); सीरियल.प्रिंट्लन (); देरी (500); }

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

चरण 1:

इसे सीधे शब्दों में कहें, तो मिलिस फ़ंक्शन आपके Arduino के केंद्र में ATmega माइक्रोकंट्रोलर के भीतर एक आंतरिक काउंटर का उपयोग करता है। यह काउंटर हर घड़ी चक्र को बढ़ाता है - जो कि (मानक Arduino और कॉम्पिटिबल्स में) 16 मेगाहर्ट्ज की घड़ी की गति से होता है। इस गति को Arduino बोर्ड पर क्रिस्टल द्वारा नियंत्रित किया जाता है (चांदी की चीज़ जिस पर T16.000 की मुहर लगी होती है)।

चरण 2:

क्रिस्टल की सटीकता बाहरी तापमान और क्रिस्टल की सहनशीलता के आधार पर भिन्न हो सकती है। यह बदले में आपके मिली परिणाम की सटीकता को प्रभावित करेगा। उपाख्यानात्मक अनुभव ने बताया है कि समय सटीकता में बहाव चौबीस घंटे की अवधि में लगभग तीन या चार सेकंड हो सकता है।

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

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

हार्डवेयर के दृष्टिकोण से, हमारे पास दो बटन होंगे - स्टार्ट और स्टॉप - जिसमें 10k ओम पुल-डाउन रेसिस्टर्स क्रमशः डिजिटल पिन 2 और 3 से जुड़े होंगे। जब उपयोगकर्ता शुरू करता है तो स्केच मिलिस के लिए मान नोट करेगा - फिर स्टॉप दबाए जाने के बाद, स्केच फिर से मिली के लिए मान को नोट करेगा, बीता हुआ समय की गणना और प्रदर्शित करेगा। उपयोगकर्ता तब प्रक्रिया को दोहराने के लिए स्टार्ट दबा सकता है, या अद्यतन डेटा के लिए रुक सकता है। यहाँ स्केच है:

/* मिलिस () का उपयोग करके सुपर-बेसिक स्टॉपवॉच; */

अहस्ताक्षरित लंबी शुरुआत, समाप्त, बीता हुआ;

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

{ सीरियल.बेगिन (९६००); पिनमोड (2, इनपुट); // स्टार्ट बटन पिनमोड (3, INPUT); // स्टॉप बटन Serial.println ("स्टार्ट / रीसेट के लिए 1 दबाएं, बीता हुआ समय के लिए 2"); }

शून्य प्रदर्शन परिणाम ()

{फ्लोट एच, एम, एस, एमएस; लंबे समय से अहस्ताक्षरित; बीता हुआ = समाप्त-शुरू; एच = इंट (बीता हुआ/३६०००००); अधिक = बीता हुआ% 3600000; एम = इंट (अधिक / ६००००); अधिक = ६००००% से अधिक; एस = इंट (अधिक / 1000); एमएस =% १००० से अधिक; Serial.print ("कच्चा बीता हुआ समय:"); Serial.println (बीता हुआ); सीरियल.प्रिंट ("बीता हुआ समय:"); सीरियल.प्रिंट (एच, 0); सीरियल.प्रिंट ("एच"); सीरियल.प्रिंट (एम, 0); सीरियल.प्रिंट ("एम"); सीरियल.प्रिंट (एस, 0); सीरियल.प्रिंट ("एस"); सीरियल.प्रिंट (एमएस, 0); सीरियल.प्रिंट्लन ("एमएस"); सीरियल.प्रिंट्लन (); }

शून्य लूप ()

{ अगर (डिजिटल रीड (2) == हाई) {शुरू = मिली (); देरी (200); // बहस के लिए Serial.println ("शुरू हुआ …"); } अगर (डिजिटल रीड (3) == हाई) {समाप्त = मिली (); देरी (200); // डेब्यू डिस्प्ले के लिए रिसेट (); } }

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

चरण 3: स्पीडोमीटर…

यदि आपके पास एक निश्चित दूरी की शुरुआत और अंत में एक सेंसर था, तो गति की गणना की जा सकती है: गति = दूरी समय।

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

सबसे पहले, आइए आवश्यक गणित की समीक्षा करें। आपको पहिया की परिधि जानने की आवश्यकता होगी। हार्डवेयर - आपको एक सेंसर की आवश्यकता होगी। उदाहरण के लिए - एक ईख स्विच और चुंबक। रीड स्विच को सामान्य रूप से खुला बटन मानें, और हमेशा की तरह 10k ओम पुल-डाउन रेसिस्टर से कनेक्ट करें।

अन्य हॉल-इफ़ेक्ट सेंसर का उपयोग कर सकते हैं - प्रत्येक अपने लिए)। परिधि की गणना करने के लिए गणित की कक्षा से याद रखें - सूत्र का उपयोग करें: परिधि = 2πr जहाँ r वृत्त की त्रिज्या है।

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

आपका सेंसर - एक बार फिट हो जाने पर - सामान्य रूप से खुले बटन की तरह ही कार्य करना चाहिए जिसे हर घुमाव पर धकेला जाता है। हमारा स्केच सेंसर से प्रत्येक पल्स के बीच के समय को मापेगा।

ऐसा करने के लिए, हमारे उदाहरण में डिजिटल पिन 2 से जुड़ा सेंसर आउटपुट होगा - क्योंकि यह गति की गणना करने के लिए एक रुकावट को ट्रिगर करेगा। अन्यथा स्केच सामान्य I2C-इंटरफ़ेस LCD मॉड्यूल पर गति प्रदर्शित करेगा। I2C इंटरफ़ेस का सुझाव दिया गया है क्योंकि इसके लिए Arduino बोर्ड से LCD तक केवल 4 तारों की आवश्यकता होती है - जितने कम तार बेहतर होते हैं।

यहाँ आपके अवलोकन के लिए स्केच है:

/*मिलिस का उपयोग कर मूल स्पीडोमीटर (); */

#include "Wire.h" // I2C बस LCD. के लिए

#include "LiquidCrystal_I2C.h" // I2C बस LCD मॉड्यूल के लिए - https://bit.ly/m7K5wt LiquidCrystal_I2C LCD(0x27, 16, 2); // 16 वर्णों और 2 लाइन डिस्प्ले के लिए एलसीडी पते को 0x27 पर सेट करें

फ्लोट शुरू, समाप्त;

फ्लोट बीता हुआ, समय; फ्लोट सर्किमेट्रिक = १.२; // सेंसर की स्थिति के सापेक्ष पहिया परिधि (मीटर में) फ्लोट सर्किल इंपीरियल; // 1 किलोमीटर = 0.621371192 मील फ्लोट स्पीडक, स्पीडएम का उपयोग करना; // मेट्रिक और इंपीरियल में परिकलित गति मान रखता है

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

{अटैचइंटरप्ट (0, स्पीडकैल्क, राइजिंग); // इंटरप्ट को तब कहा जाता है जब सेंसर डिजिटल 2 हाई (हर व्हील रोटेशन) स्टार्ट = मिलिस () भेजता है; // सेटअप एलसीडी LCD.init (); // LCD LCD.backlight () को इनिशियलाइज़ करें; // LCD बैकलाइट LCD.clear () चालू करें; LCD.println ("हेलमेट पहनें!"); देरी (3000); एलसीडी.क्लियर (); सीरियल.बेगिन (115200); circImperial=circMetric*.62137; // MPH गणना के लिए मीट्रिक को इंपीरियल में बदलें }

शून्य गति कैल्क ()

{बीता हुआ = मिली () - शुरू; प्रारंभ = मिली (); स्पीडक = (3600 * सर्किमेट्रिक) / बीता हुआ; // किमी / घंटा स्पीडएम = (3600 * सर्किल इंपीरियल) / बीता हुआ; // मील प्रति घंटा }

शून्य लूप ()

{lcd.setCursor(0, 0); एलसीडी.प्रिंट (इंट (स्पीडके)); एलसीडी.प्रिंट ("किमी / घंटा"); एलसीडी.प्रिंट (इंट (स्पीडएम)); एलसीडी.प्रिंट ("एमपीएच"); LCD.setCursor(0, 1); एलसीडी.प्रिंट (इंट (बीता हुआ)); एलसीडी.प्रिंट ("एमएस / रेव"); देरी (1000); // झिलमिलाहट को कम करने के लिए व्यक्तिगत वरीयता के लिए समायोजित करें}

इतना कुछ नहीं चल रहा है - हर बार जब पहिया एक क्रांति को पूरा करता है तो सेंसर से संकेत निम्न से उच्च तक जाएगा - एक रुकावट को ट्रिगर करता है जो फ़ंक्शन स्पीडकैल्क () को कॉल करता है।

यह मिलिस () की रीडिंग लेता है और फिर वर्तमान रीडिंग और पिछले रीडिंग के बीच के अंतर की गणना करता है - यह मान दूरी को कवर करने का समय बन जाता है (जो सेंसर के सापेक्ष पहिया की परिधि है - में संग्रहीत

फ्लोट सर्किमेट्रिक = १.२;

और मीटर में मापा जाता है)। यह अंत में किमी/घंटा और मील प्रति घंटे में गति की गणना करता है। इंटरप्ट के बीच स्केच एलसीडी पर अद्यतन गति डेटा के साथ-साथ जिज्ञासा के लिए प्रत्येक क्रांति के लिए कच्चे समय के मूल्य को प्रदर्शित करता है। वास्तविक जीवन में मुझे नहीं लगता कि कोई साइकिल पर एलसीडी लगाएगा, शायद एक एलईडी डिस्प्ले अधिक प्रासंगिक होगा।

इस बीच, आप निम्न लघु वीडियो क्लिप में देख सकते हैं कि यह उदाहरण कैसे काम करता है। बाइक व्हील और रीड स्विच/चुंबक संयोजन के बजाय, मैंने सेंसर से दालों को अनुकरण करने के लिए एक फ़ंक्शन जनरेटर से स्क्वायर-वेव आउटपुट को इंटरप्ट पिन से जोड़ा है, ताकि आप यह जान सकें कि यह कैसे काम करता है।

चरण 4:

यह कुछ समय के लिए मिलिस () के उपयोग के बारे में बताता है। माइक्रो (); भी है। फ़ंक्शन जो माइक्रोसेकंड की गणना करता है।

तो आपके पास यह है - एक और व्यावहारिक कार्य जो Arduino की दुनिया के माध्यम से अधिक समस्याओं को हल करने की अनुमति दे सकता है। हमेशा की तरह, अब यह आप पर और आपकी कल्पना पर निर्भर है कि आप कुछ नियंत्रित करें या अन्य शीनिगन्स तक पहुंचें।

यह पोस्ट आपके लिए pmdway.com द्वारा लाया गया है - निर्माताओं और इलेक्ट्रॉनिक्स के प्रति उत्साही लोगों के लिए, दुनिया भर में मुफ्त डिलीवरी के साथ।