१०२४ नमूने एफएफटी स्पेक्ट्रम विश्लेषक एक एटमेगा का उपयोग कर रहे हैं१२८४: ९ कदम

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

यह अपेक्षाकृत आसान ट्यूटोरियल (इस विषय की जटिलता पर विचार करते हुए) आपको दिखाएगा कि आप Arduino टाइप बोर्ड (1284 नैरो) और सीरियल प्लॉटर का उपयोग करके एक बहुत ही सरल 1024 नमूने स्पेक्ट्रम विश्लेषक कैसे बना सकते हैं। किसी भी प्रकार का Arduino संगत बोर्ड करेगा, लेकिन इसमें जितनी अधिक RAM होगी, आपको सबसे अच्छा आवृत्ति रिज़ॉल्यूशन मिलेगा। 1024 नमूनों के साथ FFT की गणना करने के लिए इसे 8 KB से अधिक RAM की आवश्यकता होगी।

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

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

हम यहां सॉफ्टवेयर भाग पर ध्यान केंद्रित करेंगे। यदि आप किसी विशिष्ट एप्लिकेशन के लिए एक स्थायी सर्किट बनाना चाहते हैं, तो आपको सिग्नल को बढ़ाना और फ़िल्टर करना होगा। यह प्री-कंडीशनिंग पूरी तरह से उस सिग्नल पर निर्भर है जिसका आप अध्ययन करना चाहते हैं, यह इसके आयाम, प्रतिबाधा, अधिकतम आवृत्ति आदि पर निर्भर करता है… आप

चरण 1: पुस्तकालय स्थापित करना

हम Enrique Condes द्वारा लिखित ArduinoFFT लाइब्रेरी का उपयोग करेंगे। चूंकि हम जितना संभव हो सके रैम को खाली करना चाहते हैं, हम इस रिपॉजिटरी की विकसित शाखा का उपयोग करेंगे जो नमूना और गणना किए गए डेटा को संग्रहीत करने के लिए फ्लोट डेटा प्रकार (डबल के बजाय) का उपयोग करने की अनुमति दे रही है। इसलिए हमें इसे मैन्युअल रूप से इंस्टॉल करना होगा। चिंता न करें, बस आर्काइव को डाउनलोड करें और इसे अपने Arduino लाइब्रेरी फोल्डर में अनकम्प्रेस्ड करें (उदाहरण के लिए विंडोज 10 डिफॉल्ट कॉन्फ़िगरेशन पर: C:\Users\_your_user_name_\Documents\Arduino\libraries)

आप "FFT_01.ino" जैसे प्रदान किए गए उदाहरणों में से किसी एक को संकलित करके जांच सकते हैं कि पुस्तकालय सही ढंग से स्थापित है।

चरण 2: फूरियर ट्रांसफॉर्म और एफएफटी अवधारणाएं

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

आवृत्ति स्पेक्ट्रम फास्ट फूरियर ट्रांसफॉर्म एल्गोरिदम के माध्यम से प्राप्त किया जाता है। एफएफटी एक डिजिटल कार्यान्वयन है जो फूरियर ट्रांसफॉर्म की गणितीय अवधारणा का अनुमान लगाता है। इस अवधारणा के तहत एक बार जब आप एक समय अक्ष के बाद एक संकेत का विकास प्राप्त कर लेते हैं, तो आप एक आवृत्ति डोमेन में इसके प्रतिनिधित्व को जान सकते हैं, जो जटिल (वास्तविक + काल्पनिक) मूल्यों से बना होता है। अवधारणा पारस्परिक है, इसलिए जब आप आवृत्ति डोमेन प्रतिनिधित्व को जानते हैं तो आप इसे वापस समय डोमेन में बदल सकते हैं और ट्रांसफॉर्म से पहले सिग्नल वापस प्राप्त कर सकते हैं।

लेकिन हम समय क्षेत्र में गणना किए गए जटिल मूल्यों के इस सेट के साथ क्या करने जा रहे हैं? खैर, इसका अधिकांश हिस्सा इंजीनियरों पर छोड़ दिया जाएगा। हमारे लिए हम एक और एल्गोरिथ्म कहेंगे जो इन जटिल मूल्यों को वर्णक्रमीय घनत्व डेटा में बदल देगा: यह प्रत्येक आवृत्ति बैंड से जुड़ा एक परिमाण (= तीव्रता) मान है। आवृत्ति बैंड की संख्या नमूनों की संख्या के समान होगी।

आप निश्चित रूप से इक्वलाइज़र अवधारणा से परिचित हैं, जैसे कि 1980 के दशक में ग्राफिक EQ के साथ। ठीक है, हम उसी तरह के परिणाम प्राप्त करेंगे लेकिन 16 के बजाय 1024 बैंड और बहुत अधिक तीव्रता वाले रिज़ॉल्यूशन के साथ। जब इक्वलाइज़र संगीत का वैश्विक दृष्टिकोण देता है, तो सूक्ष्म वर्णक्रमीय विश्लेषण 1024 बैंडों में से प्रत्येक की तीव्रता की सटीक गणना करने की अनुमति देता है।

एक आदर्श अवधारणा, लेकिन:

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

व्यवहार में

1) नमूना आवृत्ति (विख्यात एफएस)

हम एक सिग्नल का नमूना लेंगे, यानी हर 1/fs सेकंड में इसके आयाम को मापेंगे। fs नमूना आवृत्ति है। उदाहरण के लिए यदि हम 8 किलोहर्ट्ज़ पर नमूना लेते हैं, तो एडीसी (डिजिटल कनवर्टर के अनुरूप) जो चिप पर है, हर 1/8000 सेकंड में एक माप प्रदान करेगा।

2) नमूनों की संख्या (कोड में नोट किए गए एन या नमूने)

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

• नमूना डेटा को संग्रहीत करने के लिए "vReal" नामक एक सरणी और फिर रूपांतरित डेटा का वास्तविक भाग
• परिवर्तित डेटा के काल्पनिक भाग को संग्रहीत करने के लिए "vImag" नाम की एक सरणी

RAM की आवश्यक मात्रा 2 (सरणी) * 32 (बिट्स) * N (नमूने) के बराबर होती है।

तो हमारे Atmega1284 में जिसमें 16 KB RAM अच्छी है, हम अधिकतम N = 16000*8 / 64 = 2000 मान संग्रहीत करेंगे। चूंकि मानों की संख्या 2 की घात होनी चाहिए, इसलिए हम अधिकतम 1024 मान संग्रहीत करेंगे।

3) आवृत्ति संकल्प

एफएफटी नमूनों की संख्या के रूप में कई आवृत्ति बैंड के लिए मूल्यों की गणना करेगा। ये बैंड 0 HZ से सैंपलिंग फ़्रीक्वेंसी (fs) तक फैले होंगे। इसलिए, आवृत्ति संकल्प है:

फ़्रीसोल्यूशन = एफएस / एन

रिज़ॉल्यूशन कम होने पर बेहतर होता है। तो बेहतर संकल्प (निचला) के लिए हम चाहते हैं:

• अधिक नमूने, और/या
• एक कम fs

परंतु…

4) न्यूनतम एफएस

चूंकि हम बहुत सारी आवृत्तियों को देखना चाहते हैं, उनमें से कुछ "मौलिक आवृत्ति" की तुलना में बहुत अधिक हैं, इसलिए हम fs को बहुत कम सेट नहीं कर सकते। वास्तव में Nyquist-Shannon नमूना प्रमेय है जो हमें एक नमूना आवृत्ति को उस अधिकतम आवृत्ति से दोगुने से ऊपर रखने के लिए मजबूर करता है जिसे हम परीक्षण करना चाहते हैं।

उदाहरण के लिए, यदि हम 0 हर्ट्ज से लेकर 15 किलोहर्ट्ज़ तक के सभी स्पेक्ट्रम का विश्लेषण करना चाहते हैं, जो लगभग अधिकतम आवृत्ति है जिसे अधिकांश मनुष्य स्पष्ट रूप से सुन सकते हैं, तो हमें नमूना आवृत्ति को 30 किलोहर्ट्ज़ पर सेट करना होगा। वास्तव में इलेक्ट्रॉनिकी अक्सर इसे 2.5 (या 2.52) * अधिकतम आवृत्ति पर सेट करते हैं। इस उदाहरण में यह 2.5 * 15 किलोहर्ट्ज़ = 37.5 किलोहर्ट्ज़ होगा। पेशेवर ऑडियो में सामान्य नमूना आवृत्ति ४४.१ किलोहर्ट्ज़ (ऑडियो सीडी रिकॉर्डिंग), ४८ किलोहर्ट्ज़ और अधिक हैं।

निष्कर्ष:

अंक १ से ४ तक ले जाते हैं: हम अधिक से अधिक नमूनों का उपयोग करना चाहते हैं। हमारे मामले में 16 केबी रैम डिवाइस के साथ हम 1024 नमूनों पर विचार करेंगे। हम यथासंभव न्यूनतम नमूना आवृत्ति पर नमूना लेना चाहते हैं, जब तक कि यह हमारे सिग्नल में अपेक्षित उच्चतम आवृत्ति का विश्लेषण करने के लिए पर्याप्त है (2.5 * यह आवृत्ति, कम से कम)।

चरण 3: सिग्नल का अनुकरण

हमारे पहले प्रयास के लिए, हम पुस्तकालय में दिए गए TFT_01.ino उदाहरण को थोड़ा संशोधित करेंगे, जिससे बने सिग्नल का विश्लेषण किया जा सके।

• मौलिक आवृत्ति, 440 हर्ट्ज पर सेट (संगीत ए)
• मौलिक की आधी शक्ति पर तीसरा हार्मोनिक ("-3 डीबी")
• मौलिक की शक्ति के 1/4 वें हार्मोनिक ("-6 डीबी)

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

चरण 4: सिम्युलेटेड सिग्नल का विश्लेषण - कोडिंग

०) पुस्तकालय शामिल करें

#शामिल "arduinoFFT.h"

1 कई। परिभाषाएं

घोषणा अनुभागों में, हमारे पास है

कॉन्स्ट बाइट adcPin = 0; // ए0

कास्ट uint16_t नमूने = १०२४; // यह मान हमेशा 2 const uint16_t सैंपलिंग फ़्रीक्वेंसी = 8000 की शक्ति होना चाहिए; // टाइमर_सेटअप में टाइमर के अधिकतम मान को प्रभावित करेगा () SYSCLOCK/8/नमूना आवृत्ति एक पूर्णांक होना चाहिए

चूंकि सिग्नल में 5 वां हार्मोनिक्स है (इस हार्मोनिक की आवृत्ति = 5 * 440 = 2200 हर्ट्ज) हमें नमूना आवृत्ति 2.5 * 2200 = 5500 हर्ट्ज से ऊपर सेट करने की आवश्यकता है। यहां मैंने 8000 हर्ट्ज चुना।

हम उन सरणियों की भी घोषणा करते हैं जहाँ हम कच्चे और गणना किए गए डेटा को संग्रहीत करेंगे

फ्लोट vReal [नमूने];

फ्लोट वीमैग [नमूने];

2) इंस्टेंटेशन

हम एक ArduinoFFT ऑब्जेक्ट बनाते हैं। ArduinoFFT का देव संस्करण एक टेम्पलेट का उपयोग करता है ताकि हम फ्लोट या डबल डेटा प्रकार का उपयोग कर सकें। हमारे कार्यक्रम की समग्र सटीकता के संबंध में फ्लोट (32 बिट) पर्याप्त है।

ArduinoFFT FFT = ArduinoFFT (vReal, vImag, नमूने, नमूना आवृत्ति);

3) एडीसी मानों के साथ पॉप्युलेट होने के बजाय, vReal सरणी को पॉप्युलेट करके सिग्नल को सिम्युलेट करना।

लूप की शुरुआत में हम vReal सरणी को इसके साथ भरते हैं:

फ्लोट साइकिल = (((नमूने) * सिग्नल फ़्रीक्वेंसी) / सैंपलिंग फ़्रिक्वेंसी); // सिग्नल चक्रों की संख्या जो नमूना पढ़ेगा

के लिए (uint16_t i = 0; i <नमूने; i++) {vReal = फ्लोट ((आयाम * (पाप ((i * (TWO_PI * चक्र)) / नमूने))));/* सकारात्मक के साथ डेटा बनाएं और नकारात्मक मान*/ vReal += फ्लोट ((आयाम * (पाप ((3 * i * (TWO_PI * चक्र)) / नमूने))) / 2.0);/* सकारात्मक और नकारात्मक मूल्यों के साथ डेटा बनाएँ*/ vReal += फ्लोट ((आयाम * (पाप((५ * i * (TWO_PI * चक्र)) / नमूने)) / ४.०);/* सकारात्मक और नकारात्मक मूल्यों के साथ डेटा बनाएँ*/vImag = ०.०; // गलत गणना और अतिप्रवाह से बचने के लिए लूपिंग के मामले में काल्पनिक भाग को शून्य किया जाना चाहिए}

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

4) एफएफटी कंप्यूटिंग

फिर हम एफएफटी और वर्णक्रमीय घनत्व की गणना करते हैं

FFT.windowing(FFTWindow::Hamming, FFTDirection::Forward);

एफएफटी.कंप्यूट (एफएफटीडायरेक्शन::फॉरवर्ड); /* FFT की गणना करें */ FFT.complexToMagnitude (); /* परिमाण की गणना करें */

FFT.windowing(…) ऑपरेशन कच्चे डेटा को संशोधित करता है क्योंकि हम FFT को सीमित संख्या में नमूनों पर चलाते हैं। पहले और आखिरी नमूने एक असंतुलन पेश करते हैं (उनके एक तरफ "कुछ भी नहीं" है)। यह त्रुटि का स्रोत है। "विंडो" ऑपरेशन इस त्रुटि को कम करता है।

FFT.compute(…) दिशा "फॉरवर्ड" के साथ समय डोमेन से फ़्रीक्वेंसी डोमेन में परिवर्तन की गणना करता है।

फिर हम प्रत्येक आवृत्ति बैंड के लिए परिमाण (यानी तीव्रता) मानों की गणना करते हैं। vReal सरणी अब परिमाण मानों से भर गई है।

5) सीरियल प्लॉटर ड्राइंग

आइए फ़ंक्शन को कॉल करके सीरियल प्लॉटर पर मान प्रिंट करें PrintVector(…)

PrintVector (vReal, (नमूने >> 1), SCL_FREQUENCY);

यह एक सामान्य कार्य है जो समय अक्ष या आवृत्ति अक्ष के साथ डेटा मुद्रित करने की अनुमति देता है।

हम उस बैंड की फ़्रीक्वेंसी भी प्रिंट करते हैं जिसका परिमाण मान सबसे अधिक होता है

फ्लोट एक्स = एफएफटी। मेजरपीक ();

सीरियल.प्रिंट ("f0 ="); सीरियल.प्रिंट (एक्स, 6); सीरियल.प्रिंट्लन ("हर्ट्ज");

चरण 5: सिम्युलेटेड सिग्नल का विश्लेषण - परिणाम

हम मूलभूत आवृत्ति (f0) के अनुरूप ३ स्पाइक्स देखते हैं, ३ और ५वें हार्मोनिक्स, f0 परिमाण के आधे और १/४वें हिस्से के साथ, जैसा कि अपेक्षित था। हम विंडो के शीर्ष पर f0 = 440.430114 Hz पढ़ सकते हैं। ऊपर बताए गए सभी कारणों से यह मान बिल्कुल 440 हर्ट्ज नहीं है, लेकिन यह वास्तविक मूल्य के बहुत करीब है। इतने तुच्छ दशमलव दिखाना वास्तव में आवश्यक नहीं था।

चरण 6: वास्तविक सिग्नल का विश्लेषण - एडीसी को तार देना

चूंकि हम जानते हैं कि सिद्धांत रूप में कैसे आगे बढ़ना है, हम एक वास्तविक संकेत का विश्लेषण करना चाहेंगे।

वायरिंग बहुत सरल है। 1 KOhm से 10 KOhm के मान के साथ एक श्रृंखला रोकनेवाला के माध्यम से मैदान और सिग्नल लाइन को अपने बोर्ड के A0 पिन से कनेक्ट करें।

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

इस डेमो के लिए मैंने ४४० हर्ट्ज़ आवृत्ति के एक साइनसॉइडल सिग्नल और लगभग ५ वोल्ट के आयाम को खिलाने के लिए एक फ़ंक्शन जनरेटर का उपयोग किया (यह सबसे अच्छा है यदि आयाम ३ और ५ वोल्ट के बीच है तो एडीसी का उपयोग पूर्ण पैमाने के पास किया जाता है), १.२ KOhm रोकनेवाला के माध्यम से.

चरण 7: वास्तविक सिग्नल का विश्लेषण - कोडिंग

०) पुस्तकालय शामिल करें

#शामिल "arduinoFFT.h"

1) घोषणाएं और तात्कालिकता

घोषणा अनुभाग में हम पिछले उदाहरण की तरह एडीसी इनपुट (ए0), नमूनों की संख्या और नमूना आवृत्ति को परिभाषित करते हैं।

कॉन्स्ट बाइट adcPin = 0; // ए0

कास्ट uint16_t नमूने = १०२४; // यह मान हमेशा 2 const uint16_t सैंपलिंग फ़्रीक्वेंसी = 8000 की शक्ति होना चाहिए; // टाइमर_सेटअप में टाइमर के अधिकतम मान को प्रभावित करेगा () SYSCLOCK/8/नमूना आवृत्ति एक पूर्णांक होना चाहिए

हम ArduinoFFT ऑब्जेक्ट बनाते हैं

ArduinoFFT FFT = ArduinoFFT (vReal, vImag, नमूने, नमूना आवृत्ति);

2) टाइमर और एडीसी सेटअप

हम टाइमर 1 सेट करते हैं ताकि यह नमूना आवृत्ति (8 किलोहर्ट्ज़) पर चक्रित हो और आउटपुट तुलना पर एक बाधा उत्पन्न करे।

शून्य टाइमर_सेटअप () {

// टाइमर 1 TCCR1A = 0 रीसेट करें; टीसीसीआर1बी = 0; टीसीएनटी1 = 0; TCCR1B = बिट (CS11) | बिट (WGM12); // सीटीसी, 8 TIMSK1 = बिट (OCIE1B) का प्रीस्कूलर; OCR1A = ((16000000/8) / नमूना आवृत्ति) -1; }

और एडीसी को इस तरह से सेट करें

• इनपुट के रूप में A0 का उपयोग करता है
• प्रत्येक टाइमर पर स्वचालित रूप से ट्रिगर 1 आउटपुट मैच बी की तुलना करता है
• रूपांतरण पूरा होने पर व्यवधान उत्पन्न करता है

एडीसी घड़ी को सिस्टम घड़ी (16 मेगाहर्ट्ज) को 16 से बढ़ाकर 1 मेगाहर्ट्ज पर सेट किया गया है। चूंकि प्रत्येक रूपांतरण में पूर्ण पैमाने पर लगभग 13 घड़ियां लगती हैं, इसलिए रूपांतरण 1/13 = 0.076 मेगाहर्ट्ज = 76 किलोहर्ट्ज़ की आवृत्ति पर प्राप्त किया जा सकता है। नमूना आवृत्ति 76 किलोहर्ट्ज़ से काफी कम होनी चाहिए ताकि एडीसी के पास डेटा का नमूना लेने का समय हो। (हमने fs = 8 KHz चुना है)।

शून्य adc_setup () {

ADCSRA = बिट (ADEN) | बिट (एडीईई) | बिट (एडीआईएफ); // ADC चालू करें, ADCSRA के पूरा होने पर रुकावट चाहते हैं | = बिट (ADPS2); // 16 ADMUX का प्रीस्कूलर = बिट (REFS0) | (एडीसीपिन और 7); // ADC इनपुट सेट करना ADCSRB = bit (ADTS0) | बिट (ADTS2); // टाइमर/काउंटर1 मैच बी ट्रिगर स्रोत एडीसीएसआरए की तुलना करें |= बिट (एडेट); // स्वचालित ट्रिगर चालू करें }

हम इंटरप्ट हैंडलर घोषित करते हैं जिसे प्रत्येक एडीसी रूपांतरण के बाद vReal सरणी में कनवर्ट किए गए डेटा को स्टोर करने और इंटरप्ट को साफ़ करने के लिए बुलाया जाएगा।

// एडीसी पूरा आईएसआर

ISR (ADC_vect) {vReal[resultNumber++] = ADC; अगर (परिणाम संख्या == नमूने) {एडीसीएसआरए = 0; // एडीसी बंद करें } } EMPTY_INTERRUPT (TIMER1_COMPB_vect);

आप Arduino (analogRead) पर ADC रूपांतरण पर एक विस्तृत विवरण प्राप्त कर सकते हैं।

3) सेटअप

सेटअप फ़ंक्शन में हम काल्पनिक डेटा तालिका को साफ़ करते हैं और टाइमर और एडीसी सेटअप फ़ंक्शन को कॉल करते हैं

जीरोआई (); // एक फ़ंक्शन जो सभी काल्पनिक डेटा को 0 पर सेट करता है - पिछले अनुभाग में समझाया गया है

टाइमर_सेटअप (); adc_setup ();

3) लूप

FFT.dcRemoval (); // इस सिग्नल के डीसी घटक को हटा दें क्योंकि एडीसी को जमीन से संदर्भित किया गया है

FFT.windowing(FFTWindow::Hamming, FFTDirection::Forward); // वजन डेटा FFT.compute (FFTDirection:: Forward); // FFT FFT.complexToMagnitude की गणना करें (); // परिमाण की गणना करें // स्पेक्ट्रम और मौलिक आवृत्ति को प्रिंट करें f0 PrintVector (vReal, (नमूने >> 1), SCL_FREQUENCY); फ्लोट एक्स = एफएफटी। मेजरपीक (); सीरियल.प्रिंट ("f0 ="); सीरियल.प्रिंट (एक्स, 6); सीरियल.प्रिंट्लन ("हर्ट्ज");

हम डीसी घटक को हटा देते हैं क्योंकि एडीसी को जमीन से संदर्भित किया जाता है और संकेत लगभग 2.5 वोल्ट के आसपास केंद्रित होता है।

फिर हम पिछले उदाहरण में बताए अनुसार डेटा की गणना करते हैं।

चरण 8: वास्तविक सिग्नल का विश्लेषण - परिणाम

वास्तव में हम इस साधारण संकेत में केवल एक आवृत्ति देखते हैं। परिकलित मौलिक आवृत्ति ४४०.११८१९४ हर्ट्ज़ है। यहाँ फिर से मान वास्तविक आवृत्ति का बहुत निकट सन्निकटन है।

चरण 9: एक क्लिप्ड साइनसॉइडल सिग्नल के बारे में क्या?

अब 5 वोल्ट से ऊपर सिग्नल के आयाम को बढ़ाकर एडीसी को थोड़ा ओवरड्राइव करने देता है, इसलिए इसे क्लिप किया जाता है। एडीसी इनपुट को नष्ट न करने के लिए बहुत अधिक धक्का न दें!

हम कुछ हार्मोनिक्स को प्रकट होते देख सकते हैं। सिग्नल को क्लिप करने से उच्च आवृत्ति वाले घटक बनते हैं।

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