आपके माइक्रोकंट्रोलर प्रोजेक्ट्स के लिए रनिंग एवरेज: 6 कदम

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

इस निर्देशयोग्य में मैं समझाऊंगा कि एक रनिंग एवरेज क्या है और आपको इसकी परवाह क्यों करनी चाहिए, साथ ही आपको यह भी दिखाना चाहिए कि इसे अधिकतम कम्प्यूटेशनल दक्षता के लिए कैसे लागू किया जाना चाहिए (जटिलता के बारे में चिंता न करें, इसे समझना बहुत आसान है और मैं करूंगा अपने arduino प्रोजेक्ट्स के लिए लाइब्रेरी का उपयोग करने में आसान प्रदान करें:)

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

चरण 1: केस का उपयोग करें: एडीसी माप को चौरसाई करना

Arduino में बहुत कम शोर के साथ एक अच्छा 10 बिट ADC है। पोटेंशियोमीटर, फोटोरेसिस्टर या अन्य उच्च शोर घटकों जैसे सेंसर पर मूल्य मापते समय, यह विश्वास करना कठिन है कि माप सही है।

एक समाधान यह है कि हर बार जब आप अपने सेंसर को पढ़ना चाहते हैं और उन्हें औसत करना चाहते हैं तो कई माप लें। कुछ मामलों में यह एक व्यवहार्य समाधान है लेकिन हमेशा नहीं। यदि आप प्रति सेकंड 1000 बार एडीसी पढ़ना चाहते हैं, तो आपको 10 माप लेने पर 10 000 की आवश्यकता होगी। गणना समय की एक बड़ी बर्बादी।

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

ऊपर की तस्वीर में मैंने पिछले 32 मापों के औसत का उपयोग किया। आप देखेंगे कि यह विधि 100% फेलप्रूफ नहीं है, लेकिन यह सटीकता में काफी सुधार करती है (यह हर बार औसतन 32 नमूनों से भी बदतर नहीं है)। यदि आप हर बार औसतन 32 मापों की गणना करना चाहते हैं, तो अकेले माप के लिए Arduino UNO पर 0.25 ms से अधिक समय लगेगा!

चरण 2: केस का उपयोग करें: माइक्रोफ़ोन सिग्नल के डीसी घटक को मापना

Arduino 0 और Vcc (सामान्यतः 5 V) के बीच वोल्टेज को माप सकता है। ऑडियो सिग्नल पूरी तरह से एसी है और यदि आप इसे माइक्रोकंट्रोलर पर मापना चाहते हैं, तो आपको इसे लगभग 1/2 Vcc का पूर्वाग्रह करना होगा। एक Arduino UNO प्रोजेक्ट में जिसका अर्थ लगभग 2.5 V (DC) + ऑडियो सिग्नल (AC) होगा। 10 बिट एडीसी और 5 वी बिजली की आपूर्ति का उपयोग करते समय, 2.5 वी पूर्वाग्रह 512 के बराबर माप होना चाहिए। तो सिग्नल का एसी मान प्राप्त करने के लिए, एडीसी माप से 512 घटाया जाना चाहिए और यह है, है ना?

एक आदर्श दुनिया में, यह सच होगा। दुर्भाग्य से वास्तविक जीवन अधिक जटिल है और हमारा संकेत पूर्वाग्रह बहाव की ओर जाता है। विद्युत नेटवर्क से 50 हर्ट्ज शोर (यदि आप अमेरिका में रहते हैं तो 60 हर्ट्ज) बहुत आम है। आमतौर पर यह सब बहुत अधिक समस्याग्रस्त नहीं होता है लेकिन यह जानना अच्छा है कि यह मौजूद है। अधिक समस्याग्रस्त घटकों के हीटिंग से रैखिक बहाव है। आप शुरुआत में डीसी ऑफसेट सुधार को ध्यान से सेट करते हैं और यह धीरे-धीरे दूर हो जाता है क्योंकि आपका एप्लिकेशन चल रहा है।

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

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

हम जानते हैं कि किसी भी एसी सिग्नल का औसत मूल्य 0 है। इस ज्ञान का उपयोग करके हम एसी + डीसी सिग्नल का औसत मूल्य घटा सकते हैं, यह डीसी पूर्वाग्रह है। इसे हटाने के लिए, हम पिछले कुछ मानों का रनिंग एवरेज ले सकते हैं और इसे वर्तमान एडीसी रीडिंग से घटा सकते हैं। ध्यान दें कि आपको लंबे समय तक चलने वाले औसत का उपयोग करने की आवश्यकता है। ऑडियो के लिए, एक सेकंड का दसवां हिस्सा (नमूनों की संख्या आपके नमूना दर पर निर्भर करती है) पर्याप्त होनी चाहिए, लेकिन यह जान लें कि लंबा औसत बेहतर काम करता है। पहली तस्वीर में आप 1 kHz नमूना दर पर 64 तत्वों के साथ चलने वाले औसत के साथ वास्तविक डीसी पूर्वाग्रह गणना का उदाहरण देख सकते हैं (मेरे द्वारा अनुशंसित से कम लेकिन यह अभी भी काम करता है)।

चरण 3: गणना

आप डॉक्टर के प्रतीक्षालय में लोगों के औसत वजन के रूप में चलने वाले औसत की कल्पना कर सकते हैं। डॉक्टर एक मरीज की जांच पूरी करता है और साथ ही एक नया वेटिंग रूम में आता है।

प्रतीक्षा कक्ष में सभी प्रतीक्षारत रोगियों के औसत वजन का पता लगाने के लिए, नर्स तब प्रत्येक रोगी से उनके वजन के बारे में पूछ सकती थी, उन संख्याओं को जोड़ सकती थी और रोगियों की संख्या से विभाजित कर सकती थी। जब भी डॉक्टर नए मरीज को स्वीकार करता, नर्स पूरी प्रक्रिया को दोहराती।

आप सोच रहे होंगे: "यह सब बहुत कुशल नहीं लगता… ऐसा करने का एक बेहतर तरीका होना चाहिए।" और, आप सही होंगे।

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

लेकिन अगर आपको अंतिम पैराग्राफ भ्रमित करने वाला नहीं लगा, तो आपके पास ऐसे प्रश्न हो सकते हैं जैसे कि शुरुआत में संचायक में क्या होना चाहिए, मैं जो पढ़ता हूं उसे वास्तविक सी कोड में कैसे डालूं? इसे अगले चरण में संबोधित किया जाएगा, जहां आपको मेरा स्रोत कोड भी मिलेगा।

चरण 4: कोड

चल रहे औसत की गणना करने के लिए, आपको सबसे पहले अंतिम N मानों को संग्रहीत करने का एक तरीका चाहिए। आपके पास एन तत्वों के साथ एक सरणी हो सकती है और हर बार जब आप कोई तत्व जोड़ते हैं तो पूरी सामग्री को एक स्थान पर ले जा सकते हैं (कृपया ऐसा न करें), या आप एक पुराने तत्व को ओवरराइट कर सकते हैं और पॉइंटर को अगले तत्व को फेंकने के लिए समायोजित कर सकते हैं (कृपया ऐसा करें):)

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

विलंब रेखा में एक तत्व जोड़ना नवीनतम तत्व के सूचकांक को 1 से घटाना जितना आसान है, यह सुनिश्चित करना कि यह विलंब रेखा सरणी के पक्ष को इंगित नहीं करता है। सूचकांक में कमी के बाद जब यह 0 होता है, तो यह 255 के आसपास लूप करेगा (क्योंकि यह 8 बिट अहस्ताक्षरित पूर्णांक है)। मोडुलो (%) ऑपरेटर विलंब रेखा सरणी के आकार के साथ यह सुनिश्चित करेगा कि सूचकांक एक वैध तत्व को इंगित करेगा।

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

आसान, है ना?

यह सब कैसे काम करता है, इसे बेहतर ढंग से समझने के लिए कृपया बेझिझक संलग्न कोड का उपयोग करके प्रयोग करें। जैसा कि यह वर्तमान में खड़ा है, arduino एनालॉग पिन A0 पर एनालॉग वैल्यू पढ़ता है और 115200 बॉड रेट पर सीरियल पोर्ट पर "[ADC वैल्यू], [रनिंग एवरेज]" प्रिंट करता है। यदि आप सही बॉड दर पर arduino के सीरियल प्लॉटर को खोलते हैं, तो आपको दो पंक्तियाँ दिखाई देंगी: ADC मान (नीला) और स्मूथ आउट मान (लाल)।

चरण 5: अतिरिक्त

आपके प्रोजेक्ट में रनिंग एवरेज का उपयोग करने के लिए कुछ चीजें हैं जिन्हें आपको जानने की आवश्यकता नहीं है, जिन्हें जानकर आपको दुख नहीं होगा।

देरी: मैं इस कदम के चित्रण के बारे में बात करके शुरू करूंगा। आप देखेंगे कि अधिक तत्वों का औसत चलाना अधिक विलंब का परिचय देता है। यदि मूल्य में परिवर्तन के लिए आपकी प्रतिक्रिया का समय महत्वपूर्ण है, तो आप कम चलने वाले औसत का उपयोग करना चाहेंगे या नमूना दर बढ़ा सकते हैं (अधिक बार मापें)।

आगे बढ़ते रहना।

आरंभीकरण: जब मैंने संचायक और विलंब तत्वों को आरंभ करने के बारे में बात की, तो मैंने कहा कि आपको उन सभी को 0 से प्रारंभ करना चाहिए। वैकल्पिक रूप से आप अपनी पसंद की किसी भी चीज़ के लिए विलंब रेखा को प्रारंभ कर सकते हैं, लेकिन संचायक को विलंब रेखा में नवीनतम N तत्वों के योग के रूप में प्रारंभ करना चाहिए (जहाँ N आपके चलने वाले औसत में तत्वों की संख्या है)। यदि संचायक किसी अन्य मूल्य के रूप में शुरू होता है, तो गणना की गई औसत गलत होगी - या तो बहुत कम या बहुत अधिक, हमेशा एक ही राशि से (समान प्रारंभिक स्थितियों को मानते हुए)। मेरा सुझाव है कि आप कुछ "पेन और पेपर सिमुलेशन" का उपयोग करके यह जानने का प्रयास करें कि ऐसा क्यों है।

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

चाल: लंबी देरी वाली लाइनें बहुत अधिक मेमोरी लेती हैं। यह जल्दी ही एक समस्या बन सकती है। यदि आप बहुत मेमोरी प्रतिबंधित हैं और सटीकता के बारे में ज्यादा परवाह नहीं करते हैं, तो आप देरी को पूरी तरह से छोड़कर और इसके बजाय ऐसा करके चल रहे औसत का अनुमान लगा सकते हैं: संचायक से 1/N * संचायक घटाएं और नया मान जोड़ें (8 लंबे चलने वाले औसत के उदाहरण पर: संचायक = संचायक * 7/8 + newValue)। यह विधि गलत परिणाम देती है लेकिन जब आप कम मेमोरी में चल रहे हों तो यह रनिंग एवरेज की गणना करने का एक अच्छा तरीका है।

भाषाविज्ञान: "चल रहा औसत/माध्य" आमतौर पर वास्तविक समय औसत का जिक्र करते समय उपयोग किया जाता है जबकि "चलती औसत/माध्य" आमतौर पर इसका मतलब है कि एल्गोरिदम स्थिर डेटा सेट जैसे एक्सेल स्प्रेडशीट पर चल रहा है।

चरण 6: निष्कर्ष

मुझे उम्मीद है कि यह निर्देश समझने में काफी आसान था और यह आपकी भविष्य की परियोजनाओं में आपकी मदद करेगा। अगर कुछ अस्पष्ट है तो कृपया नीचे टिप्पणी में प्रश्न पोस्ट करने के लिए स्वतंत्र महसूस करें।