🌴 🐡 ✝️ DevBoy: सिग्नल जनरेटर बना रहा है 🕴🏾 📲 🧑🏻‍🤝‍🧑🏻

नमस्कार दोस्तों!

पिछले लेखों में, मैंने अपनी परियोजना और इसके सॉफ्टवेयर भाग के बारे में बात की । इस लेख में मैं आपको बताऊंगा कि कैसे 4 चैनलों के लिए एक सरल सिग्नल जनरेटर बनाया जाए - दो एनालॉग चैनल और दो पीडब्लूएम चैनल।

एनालॉग चैनल

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

" क्लासिक " तरंगों में शामिल हैं: साइनसॉइडल, मेन्डियर, त्रिकोणीय और आरी।

बफर में इन तरंगों को उत्पन्न करने का कार्य निम्नानुसार है

// ***************************************************************************** // *** GenerateWave ******************************************************** // ***************************************************************************** Result Application::GenerateWave(uint16_t* dac_data, uint32_t dac_data_cnt, uint8_t duty, WaveformType waveform) { Result result; uint32_t max_val = (DAC_MAX_VAL * duty) / 100U; uint32_t shift = (DAC_MAX_VAL - max_val) / 2U; switch(waveform) { case WAVEFORM_SINE: for(uint32_t i = 0U; i < dac_data_cnt; i++) { dac_data[i] = (uint16_t)((sin((2.0F * i * PI) / (dac_data_cnt + 1)) + 1.0F) * max_val) >> 1U; dac_data[i] += shift; } break; case WAVEFORM_TRIANGLE: for(uint32_t i = 0U; i < dac_data_cnt; i++) { if(i <= dac_data_cnt / 2U) { dac_data[i] = (max_val * i) / (dac_data_cnt / 2U); } else { dac_data[i] = (max_val * (dac_data_cnt - i)) / (dac_data_cnt / 2U); } dac_data[i] += shift; } break; case WAVEFORM_SAWTOOTH: for(uint32_t i = 0U; i < dac_data_cnt; i++) { dac_data[i] = (max_val * i) / (dac_data_cnt - 1U); dac_data[i] += shift; } break; case WAVEFORM_SQUARE: for(uint32_t i = 0U; i < dac_data_cnt; i++) { dac_data[i] = (i < dac_data_cnt / 2U) ? max_val : 0x000; dac_data[i] += shift; } break; default: result = Result::ERR_BAD_PARAMETER; break; } return result; }

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

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

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

1 KHz ( 90% आयाम ) पर जनरेशन:

10 KHz ( 90% आयाम ) पर जनरेशन:

100 KHz ( 90% आयाम ) पर जनरेशन:

चरण पहले से ही दिखाई दे रहे हैं - क्योंकि नए डेटा को 4 मेगाहर्ट्ज की आवृत्ति पर डीएसी में लोड किया गया है।

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

200 KHz ( 90% आयाम ) पर जनरेशन:

यहां आप पहले से ही देख सकते हैं कि सभी तरंगें त्रिकोण में कैसे बदल गईं।

डिजिटल चैनल

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

उपयोगकर्ता इंटरफ़ेस

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

एन्कोडर पर नियंत्रण करने का निर्णय लिया गया: बायां एक आवृत्ति और वर्तमान चयनित चैनल ( बटन दबाए जाने पर परिवर्तन ) के लिए जिम्मेदार है, सही एक आयाम / कर्तव्य चक्र और तरंग ( बटन दबाए जाने पर परिवर्तन ) के लिए जिम्मेदार है।

इसके अलावा, टच स्क्रीन के लिए समर्थन लागू किया जाता है - जब आप एक निष्क्रिय चैनल पर क्लिक करते हैं, तो यह सक्रिय हो जाता है, जब आप एक सक्रिय चैनल पर क्लिक करते हैं, तो तरंग बदल जाता है।

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

सभी UI ऑब्जेक्ट्स वाली संरचना

  // ************************************************************************* // *** Structure for describes all visual elements for the channel ***** // ************************************************************************* struct ChannelDescriptionType { // UI data UiButton box; Image img; String freq_str; String duty_str; char freq_str_data[64] = {0}; char duty_str_data[64] = {0}; // Generator data ... }; // Visual channel descriptions ChannelDescriptionType ch_dsc[CHANNEL_CNT];

उपयोगकर्ता इंटरफ़ेस आरंभीकरण कोड

  // Create and show UI int32_t half_scr_w = display_drv.GetScreenW() / 2; int32_t half_scr_h = display_drv.GetScreenH() / 2; for(uint32_t i = 0U; i < CHANNEL_CNT; i++) { // Generator data ... // UI data int32_t start_pos_x = half_scr_w * (i%2); int32_t start_pos_y = half_scr_h * (i/2); ch_dsc[i].box.SetParams(nullptr, start_pos_x, start_pos_y, half_scr_w, half_scr_h, true); ch_dsc[i].box.SetCallback(&Callback, this, nullptr, i); ch_dsc[i].freq_str.SetParams(ch_dsc[i].freq_str_data, start_pos_x + 4, start_pos_y + 64, COLOR_LIGHTGREY, String::FONT_8x12); ch_dsc[i].duty_str.SetParams(ch_dsc[i].duty_str_data, start_pos_x + 4, start_pos_y + 64 + 12, COLOR_LIGHTGREY, String::FONT_8x12); ch_dsc[i].img.SetImage(waveforms[ch_dsc[i].waveform]); ch_dsc[i].img.Move(start_pos_x + 4, start_pos_y + 4); ch_dsc[i].box.Show(1); ch_dsc[i].img.Show(2); ch_dsc[i].freq_str.Show(3); ch_dsc[i].duty_str.Show(3); }

स्क्रीन अपडेट कोड

  for(uint32_t i = 0U; i < CHANNEL_CNT; i++) { ch_dsc[i].img.SetImage(waveforms[ch_dsc[i].waveform]); snprintf(ch_dsc[i].freq_str_data, NumberOf(ch_dsc[i].freq_str_data), "Freq: %7lu Hz", ch_dsc[i].frequency); if(IsAnalogChannel(i)) snprintf(ch_dsc[i].duty_str_data, NumberOf(ch_dsc[i].duty_str_data), "Ampl: %7d %%", ch_dsc[i].duty); else snprintf(ch_dsc[i].duty_str_data, NumberOf(ch_dsc[i].duty_str_data), "Duty: %7d %%", ch_dsc[i].duty); // Set gray color to all channels ch_dsc[i].freq_str.SetColor(COLOR_LIGHTGREY); ch_dsc[i].duty_str.SetColor(COLOR_LIGHTGREY); } // Set white color to selected channel ch_dsc[channel].freq_str.SetColor(COLOR_WHITE); ch_dsc[channel].duty_str.SetColor(COLOR_WHITE); // Update display display_drv.UpdateDisplay();

बटन क्लिक का एक दिलचस्प कार्यान्वयन कार्यान्वित किया जाता है (यह एक आयत है जिस पर शेष तत्व खींचे जाते हैं )। यदि आपने कोड को देखा है, तो आपको इस तरह का ध्यान देना चाहिए: ch_dsc [i] .box.SetCallback (& Callback, this, nullptr, i); एक पाश में कहा जाता है। यह कॉलबैक फ़ंक्शन का काम है जिसे बटन दबाए जाने पर कॉल किया जाएगा। निम्नलिखित को फ़ंक्शन में स्थानांतरित किया जाता है: क्लास के स्थिर फ़ंक्शन के स्थैतिक फ़ंक्शन का पता, यह पॉइंटर, और दो उपयोगकर्ता पैरामीटर जो कॉलबैक फ़ंक्शन को पास किए जाएंगे - एक पॉइंटर ( इस मामले में उपयोग नहीं किया गया - nullptr पास है और एक नंबर ( चैनल नंबर प्रेषित है )।

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

 // ***************************************************************************** // *** Callback for the buttons ********************************************* // ***************************************************************************** void Application::Callback(void* ptr, void* param_ptr, uint32_t param) { Application& app = *((Application*)ptr); ChannelType channel = app.channel; if(channel == param) { // Second click - change wave type ... } else { app.channel = (ChannelType)param; } app.update = true; }

इस फ़ंक्शन की पहली पंक्ति में, " जादू " होता है, जिसके बाद आप निजी लोगों सहित कक्षा के किसी भी सदस्य तक पहुंच सकते हैं।

वैसे, इस फ़ंक्शन को किसी अन्य कार्य ( स्क्रीन को रेंडर करना ) में कहा जाता है, इसलिए इस फ़ंक्शन के अंदर आपको सिंक्रनाइज़ेशन का ध्यान रखना होगा। इस सरल " शाम की जोड़ी " परियोजना में, मैंने ऐसा नहीं किया, क्योंकि इस विशेष मामले में यह आवश्यक नहीं है।

जनरेटर स्रोत कोड GitHub पर अपलोड किया गया: https://github.com/nickshl/WaveformGenerator
अब DevCore को एक अलग रिपॉजिटरी में आवंटित किया गया है और एक सबमॉड्यूल के रूप में शामिल किया गया है।

खैर, मुझे सिग्नल जनरेटर की आवश्यकता क्यों है, यह अगले ( या निम्नलिखित में से एक ) लेख में होगा।

DevBoy: सिग्नल जनरेटर बना रहा है

एनालॉग चैनल

डिजिटल चैनल

उपयोगकर्ता इंटरफ़ेस

More articles: