👇🏼 🍥 🉑 STM32 प्रोग्रामयोग्य माइक्रोकंट्रोलर

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

सामग्री:

माइक्रोइलेक्ट्रॉनिक के साथ पहला संपर्क।
गैर-प्रोग्राम योग्य तर्क तत्वों पर कारों का निर्माण।
STM32 के साथ शुरुआत करना। विकास का वातावरण। माइक्रोकंट्रोलर को मशीन से जोड़ना।
सामने के पहियों के रोटेशन के कोण को निर्धारित करें - एडीसी के माध्यम से प्रतिक्रिया।
ध्वनियों को चलाने के लिए DAC का उपयोग करना।

1. माइक्रोइलेक्ट्रॉनिक के साथ पहला संपर्क

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

टास्क 1: डीटीएमएफ सिग्नल रिकग्निशन

DTMF डिक्रिप्शन को लागू करने के तीन विकल्प इंटरनेट से प्रिंट किए जा रहे हैं (मेरा विचार नया नहीं है), उनके साथ - एक प्रसिद्ध स्टोर में। इसे खरीदा जाता है:

MT 8870DE डिकोडर - इनपुट एनालॉग सिग्नल से अंतिम मान्यता प्राप्त DTMF कमांड का बाइनरी कोड (4 बिट्स) प्राप्त करता है और इस सेकंड में DTMF कमांड की उपस्थिति / अनुपस्थिति (इसे "पांचवां आउटपुट" कहते हैं)।
डिकोडर के संचालन के लिए आवश्यक क्वार्ट्ज गुंजयमान यंत्र, कैपेसिटर और प्रतिरोधक।
7-खंड सूचक - फोन पर दबाए गए नंबर को प्रदर्शित करने के लिए।
7 खंड खंड सूचक के लिए KR 514ID-1 विकोडक - बाइनरी कोड से यह प्रत्येक खंड के लिए 7 आउटपुट प्राप्त करता है।
सोल्डरिंग के बिना बढ़ते के लिए विकास बोर्ड।
ब्रेडबोर्ड के लिए वायरिंग / जंपर्स।

हम एकत्रित करते हैं, सत्यापित करते हैं, त्रुटियों को सही करते हैं ... यह काम करता है। शॉक।

अब यह सब मशीन को नियंत्रित करने के लिए मजबूर करने की आवश्यकता है। इसके अलावा, ताकि मशीन की क्रियाएं तार्किक रूप से दबाए गए संख्या के अनुरूप हों: 2 - आगे, 4 - बाईं ओर, 6 - दाईं ओर, 8 - पीछे।

टास्क 2: DTMF डिकोडर से संकेतों के 4 निश्चित संयोजनों को 4 कार्यों में से एक को सक्रिय करना चाहिए

सबसे सरल विकल्प एक दशमलव डिकोडर है। K155ID10 एक खुले कलेक्टर के साथ खरीदा गया था - बाइनरी कोड के लिए 4 इनपुट, 10 आउटपुट 0 से 9 तक संख्याओं का प्रतीक है, वांछित आउटपुट में "0" होगा, और बाकी में "1" होगा। इस डिकोडर का उपयोग भार के साथ किया जाता है, जिसमें कार्यशील धारा 80 एमए (तापदीप्त बल्ब, रिले) तक पहुंच सकती है, जो सुविधाजनक है। हालांकि ट्रांजिस्टर का अभी भी उपयोग करना था।

टास्क 3: मोटर्स, एच-ब्रिज के लिए पोलरिटी रिवर्सल

मैंने बचपन में लेगो से कारों को इकट्ठा किया, जो बैटरी की ध्रुवीयता को मैन्युअल रूप से स्विच करके आगे और पीछे चले गए (मेरे पास कभी भी मोटर और रिमोट कंट्रोल के साथ लेगो सेट नहीं था)। अब वयस्क खिलौने खेलने का समय है।
सामान्य लोग ट्रांजिस्टर के साथ एक एच-ब्रिज बनाते हैं। उन्नत - इन्हीं ट्रांजिस्टर पर टर्नकी समाधान खरीदें। मैंने विद्युत चुम्बकीय रिले स्विच करने पर किया। बाद में मैंने शक्तिशाली (3A तक कलेक्टर धाराओं के लिए) खरीदा NPN और PNP ट्रांजिस्टर TIP31 C ST और TIP32 C ST, ने उनसे इस H-Bridge को इकट्ठा किया, लेकिन किसी कारण से इसने केवल ऑन-बोर्ड LED के साथ काम किया, और मोटर चालू नहीं हुआ बलों। मुझे पता नहीं क्यों

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

कार्य 4: एक टाइपराइटर इकट्ठा करें

मशीन में दो मोटर हैं: एक लेगो अंतर के माध्यम से पीछे के पहियों को घुमाता है, दूसरा सामने के पहियों को घुमाता है। गियरबॉक्स में प्लास्टिक गियर सिस्टम में दक्षता नहीं जोड़ते हैं, लेकिन यह सभी काम करता है।

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

विद्युत चुम्बकीय रिले, दो बिजली की आपूर्ति - क्या वहां बहुत अधिक कट्टर नहीं है? और आगे!

यह दशमलव डिकोडर से यह सब कनेक्ट करने के लिए बनी हुई है। आवश्यक निष्कर्ष 4 एनपीएन ट्रांसफार्मर बीसी 547 के उत्सर्जकों के लिए हैं, जिसके आधार पर डीटीएमएफ डिकोडर से एक संकेत है कि प्रत्येक कुंजी को ("पांचवें आउटपुट"), कलेक्टरों - प्रत्येक के लिए दबाया जाता है। कुटिल, अजीब, लेकिन यह काम करता है।

2. गैर-प्रोग्राम योग्य तर्क तत्वों पर कारों का निर्माण

मान लीजिए कि एक मशीन को एक ही समय में सवारी करने और चालू करने में सक्षम होना चाहिए। यह संख्या 1, 3, 7, 9 का उपयोग करने के लिए तर्कसंगत है, जब दबाया जाता है, तो दो रिले ट्रिगर हो जाएंगे। प्रारंभ में, मैंने इसे ट्रांजिस्टर एमिटर से डायोड को दशमलव डिकोडर से जोड़कर इसे लागू करने की योजना बनाई, लेकिन यह काम नहीं किया। अब यह मुझ पर निर्भर करता है कि अगर दशमलव डिकोडर "0" देता है, तो आपको एक पीएनपी ट्रांजिस्टर चाहिए जो इस "शून्य" के साथ खुलेगा। लेकिन मेरे पास केवल एनपीएन था।

कार्य 5: मशीन को 1, 3, 7 या 9 दबाए जाने पर मुड़ना चाहिए

मनोरंजन / विकास / उपयोग के उद्देश्यों के लिए, तार्किक तत्वों 4-I, 4-या, NOT, AND-NOT, OR-NOT, और एक समय में खरीदा गया था। पहला विचार दशमलव डिकोडर से आउटपुट का उपयोग करना है और एक साधारण लॉजिक सर्किट में DTMF डिकोडर से "पांचवां आउटपुट" है, जो अंततः आवश्यक ट्रांजिस्टर (और उनके माध्यम से रिले) को खोलेगा। लेकिन! "यूनिट" के रूप में दशमलव डिक्रिप्टर K155ID10 कुछ के साथ 2 वोल्ट का उत्पादन करता है। उनके निपटान में तार्किक तत्वों में से किसी ने भी इस तरह के संकेत को "इकाई" नहीं माना। 4-I (KR1533) को छोड़कर। यदि आप DTMF के साथ बाइनरी कोड के "नंगे" 4 बिट्स का उपयोग करते हैं, तो उपलब्ध तत्वों से आवश्यक तर्क को इकट्ठा करना संभव नहीं था। एक सामान्य दशमलव डिक्रिप्टर कार्य को कई बार खत्म कर देता है। और इसलिए यह इस तरह के एक छोटे से मजाक में बदल गया - करना मुश्किल है, लेकिन आप कर सकते हैं! (बिस्तर पर जाने और सुबह विवरण के लिए जाने का विचार अस्वीकार कर दिया गया था)।

यह याद रखते हुए कि दशमलव डिकोडर सभी निष्कर्षों पर अपना "पूर्ववत" देता है, डिक्रिप्टेड संख्या के साथ आउटपुट को छोड़कर, हम निम्नलिखित करते हैं।
पहले ... मी ... 4-I तत्व के इनपुट की चौकड़ी, हम संख्या 1, 2, 3 और "यूनिट" देते हैं; दूसरे पर - 7, 8, 9 और "यूनिट"। पहले के आउटपुट से हम "शून्य" प्राप्त करते हैं यदि 1, 2 या 3 दबाया गया (कार आगे जाती है), दूसरे के आउटपुट से - अगर 7, 8, 9 (पीछे)। अन्यथा, 4-I तत्व के दोनों आउटपुट "यूनिट" हैं।
अब मुड़ता है। हम 5 शेष तर्क तत्वों का उपयोग करते हैं और ट्रिकी सर्किट एकत्र करते हैं। यह संख्या 4 और 6 से मना करने का निर्णय लिया गया (क्यों मौके पर पहियों को चालू करें?!), लेकिन यहां तक कि केवल 1 और 7 (बाईं ओर), 3 और 9 (दाईं ओर) अकेले मोड़ के लिए आरेख को खींचना बहुत तनावपूर्ण बना।

नतीजतन, बोर्ड पर (मुझे एक और एक खरीदना था), एक DTMF डिकोडर, संकेतक, इसके लिए डिकोडर, दशमलव डिकोडर, 4-AND, NOT, 4-OR, OR-NOT, AND-NOT, 4 ट्रांसजेंडर, 4 रिले।
मशीन 6 अलग-अलग आदेशों को निष्पादित करती है, लेकिन यह नहीं जानता कि सामने के पहियों को बीच में कैसे लौटाया जाए। लेगो भागों की दक्षता और कम मोटर शक्ति एक वापसी वसंत या रबर की अनुमति नहीं देती है।
रिले कभी-कभी कई बार क्लिक करते हैं, कारण स्पष्ट नहीं होते हैं (व्यवधान?)।
तर्क के साथ काम करने के तर्क में महारत हासिल थी।

3. STM32 से शुरुआत करना

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

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

CooCox से CoIDE का वातावरण, जिसमें टैम्बोरिन के साथ केवल एक नृत्य की आवश्यकता थी - एक निश्चित फ़ोल्डर में कुछ फाइलों को मैनुअल डाउनलोड करना, काम शुरू करने के लिए सबसे अच्छा विकल्प लगता था। सच है, मैं फर्मवेयर को डिवाइस से अपलोड करने में सफल नहीं हुआ - मुझे बोर्ड निर्माता से एसटी-लिंक उपयोगिता का उपयोग करना होगा। वे कहते हैं कि आप सुविधाजनक उदात्त पाठ 2 से सीधे संकलन कर सकते हैं, लेकिन निर्देश की लंबाई ने मुझे बहुत अधिक संदेह करने की कोशिश की है।

यह देखते हुए कि मैंने कभी सी में नहीं लिखा, यहां तक कि सबसे सरल ब्लिंकिंग एलईडी ने मुझे महत्वपूर्ण कठिनाइयों का कारण बनाया। इसके अलावा, अस्पष्ट रजिस्टरों, एक हेक्साडेसिमल प्रणाली, एक व्यक्ति के लिए आउटपुट और इनपुट के विभिन्न ऑपरेटिंग मोड जो खराब खींचने वाले अवरोधक के उद्देश्य को नहीं समझते हैं ... लेकिन किसी के तैयार किए गए उदाहरणों की कॉपी-पेस्ट विधि ने चाल चली। बदले में, डिवाइस की कीमत आपको हार्डवेयर के सही कनेक्शन के साथ बहुत अधिक परेशान नहीं करने की अनुमति देती है। उदाहरण के लिए, मुझे अभी भी समझ नहीं आया है कि क्या प्रत्येक GND पैर को जमीन से जोड़ना आवश्यक है और क्या यह 4 उंगली की बैटरी से डिवाइस को बिजली के लिए हानिकारक है - जबकि सब कुछ जीवित और काम कर रहा है।

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

टास्क 6: देरी

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

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

कोड

int main(void) { unsigned int x=0; char something; while(1) { if (x>5000) { //  }; if (x==10000) { //  .    ,    x. }; if (something==1)//   { x=0; //        } if (x<15000) { x++; }; //  x       0,   x  15000. }; };

कार्य 7: एक निर्दिष्ट अंतराल पर अंतराल

मान लीजिए कि हमने क्वार्ट्ज गुंजयमान यंत्र को नहीं बदला, और प्रोसेसर की आवृत्ति 24 मेगाहर्ट्ज बनी रही। विशेष निर्देशों के माध्यम से 2400 वें प्रोसेसर की गिनती तक पहुंचने पर एक रुकावट पैदा करके, हम TIM6_DAC_IRQHandler फ़ंक्शन (यह एक बाधा हैंडलर है) को 100 हर्ट्ज - प्रत्येक 10 मिलीसेकंड की आवृत्ति के साथ प्राप्त करते हैं। नीचे दिया गया कोड मूल रूप से कहीं पर लिया गया है।

कोड

 unsigned int ti=0; int main(void) { //     6 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6,ENABLE); TIM6->PSC = 24000 - 1; //   1000    TIM6->ARR = 10 - 1; //     10-  TIM6->DIER |= TIM_DIER_UIE; //     TIM6->CR1 |= TIM_CR1_CEN; //  ! NVIC_EnableIRQ(TIM6_DAC_IRQn); //  TIM6_DAC_IRQn  }; //   TIM6_DAC void TIM6_DAC_IRQHandler(void) { ti++; TIM6->SR &= ~TIM_SR_UIF; //     }

इस रुकावट का मुख्य उद्देश्य चर ती का उपयोग करना है, जो हर 10 मिलीसेकंड पर वास्तव में बढ़ता है। जल्द ही मुझे पता चला कि मुख्य कार्यक्रम कोड में न केवल "पच्चर" बाधित होता है, बल्कि चर टीआई की तुलना या असाइन करने के संचालन को भी विकृत कर सकता है, क्योंकि इंटरप्ट हैंडलर में यह हर बार बदलता है। ऐसी स्थिति उत्पन्न हो सकती है, जब चर ti के मान को दूसरे चर को निर्दिष्ट करने के बजाय, पुराने मान का एक भाग और नए का एक भाग सौंपा जाएगा। वेब पर पाई गई समस्या के समाधान के बीच, मैंने निम्नलिखित पर प्रकाश डाला:

परमाणु संचालन का उपयोग (वे बाधित नहीं हैं) - अंतर प्रकार का असाइनमेंट ऐसा नहीं है, लेकिन "लंबे" प्रकार का उपयोग किया जाना चाहिए;
अतिरिक्त चर या रजिस्टर का उपयोग यह पता लगाने के लिए कि क्या विशिष्ट निर्देशों के निष्पादन के दौरान काम किया गया एक अवरोध थोड़ा बोझिल है और बहुत स्पष्ट नहीं है (मेरे लिए);
अन्य विकल्प ...

मैंने इस समस्या को इस तरह हल किया। जब तक यह "असाइन" नहीं किया जाता है, हम वेरिएबल ti को स्थानीय वेरिएबल sti को असाइन करते हैं। आप थोड़ा "बैकलैश" जोड़ सकते हैं यदि सटीकता मौलिक नहीं है।

 do { sti=ti; } while (ti>1+sti);

स्थानीय चर एसटीआई का उपयोग केवल उसी तरह के छोरों को सम्मिलित करने के लिए किया जाता है जहां हमें चर ती के मूल्य की आवश्यकता होती है।

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

 if (sti==0) { do { ti=0; } while (ti>1); }

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

टास्क 8: डिस्प्ले के रूप में एलईडी

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

 // - if ((todisp>0) && (sti%10==0)) { if ((sti%(todisp*20+100)<todisp*20) && (sti%20<10)) { GPIOC->BSRR=GPIO_BSRR_BS8; } else { GPIOC->BRR=GPIO_BRR_BR8; }; };

कार्यक्रम के किसी भी बिंदु पर, हम बोर्ड पर 3, और एलईडी नंबर 8 के लिए चर टोडिस्पेड असाइन करते हैं, तीन बार फ्लैश करेंगे, जिससे श्रृंखला के बीच दूसरा ठहराव होगा। वेरिएबल स्टि को हर 10 मिलीसेकंड (वेरिएबल टी के माध्यम से) बढ़ाया जाता है, इसके बजाय, आप मुख्य लूप के प्रत्येक पास के साथ वर्जनिंग, वेरिएबल x का उपयोग कर सकते हैं। इस मामले में, गुणांक को थोड़ा बढ़ाना होगा।

उदाहरण का उपयोग करें

 while (1) { do { sti=ti; todisp++; } while (ti>1+sti); todisp--; if ((todisp>0) && (sti%10==0)) { if ((sti%(todisp*20+100)<todisp*20) && (sti%20<10)) { GPIOC->BSRR=GPIO_BSRR_BS8; } else { GPIOC->BRR=GPIO_BRR_BR8; }; }; }

इस उदाहरण में, हर बार जब एक रुकावट के कारण, असाइनमेंट ऑपरेशन sti = ti विफल हुआ, और इसलिए, तुलनात्मक संचालन ti> 1 + sti वापस लौटाता है (जो तुलना के समय रुकावट भी हो सकता है), LED एक के लिए ब्लिंक करेगा अधिक बार। सिद्धांत रूप में, आप यह भी माप सकते हैं कि बोर्ड संचालन के एन मिनट के बाद एलईडी कितनी बार झपकी लेती है और औसत चक्र समय (रुकावट की आवृत्ति के आधार पर) की गणना करती है, और यह भी सुनिश्चित करती है कि इंटरप्ट का उपयोग करते समय इन सभी सावधानियों का कोई मतलब नहीं है।

टास्क 9: मशीन को माइक्रोकंट्रोलर कनेक्ट करें

एल ई डी पर पर्याप्त संख्या में प्रयोग करने के बाद, आप धीरे-धीरे उन्हें पहियों में बदल सकते हैं। हम पुराने बेस लॉजिक सर्किट से केवल सबसे आवश्यक हैं: एक डीटीएमएफ डिकोडर, सौंदर्य के लिए एक डिकोडर के साथ एक संकेतक, ट्रांजिस्टर के साथ एक रिले। आप आखिरकार दशमलव डिकोडर के बारे में भूल सकते हैं!

DTMF डिकोडर से आउटपुट कंट्रोलर पर इनपुट से जुड़े होते हैं जिन्हें हमने इन उद्देश्यों के लिए चुना है। कंट्रोलर से आउटपुट (फिर से, प्रोग्राम में चयनित और इनिशियलाइज़्ड) एक पारंपरिक NPN ट्रांजिस्टर के आधार पर (उदाहरण के लिए, 3 kOhm) (मैंने BC547 का उपयोग किया)। एमिटर - "प्लस" को, कलेक्टरों - संबंधित रिले के कॉइल को। पाँचवा रिले जोड़ें जो मुख्य मोटर की शॉर्टिंग ("ब्रेक" मोड) को रोकता है, स्वाद के लिए संकेतों / आयामों को चालू करें। मोटर्स के लिए "प्लस" एक अलग बैटरी पैक से रिले से जुड़ा हुआ है। सर्किट और मोटर्स दोनों को बिजली देने के लिए, मैं प्रत्येक 4 उंगली बैटरी / संचायक के लिए प्लास्टिक के मामलों (2 टुकड़े) का उपयोग करता हूं। उनकी लागत केवल 40 रूबल थी, और एक बच्चे के रूप में मुझे हमेशा स्कॉच टेप और पन्नी के साथ सताया जाता था ...

यह पता चला कि DTMF डिकोडर से तार आगे / पीछे बढ़ने के लिए जिम्मेदार रिले के ठीक ऊपर से गुजरते हैं। शायद यह रिले को चालू करने पर मौजूदा पावर सर्ज में हस्तक्षेप जोड़ता है। नतीजतन, सहपाठियों के सामने एक प्रस्तुति के दौरान, रिले समय-समय पर दरार करने लगे, और मशीन ने बिल्कुल भी वापस जाने से इनकार कर दिया - रिले ने गैर-रोक दिया, एक समान दरार का उत्सर्जन किया। "प्लस" की दिशा में रिले कॉइल के समानांतर जुड़े हुए डायोड ने इस स्थिति को प्रभावित नहीं किया। हम कार्यक्रम को अंतिम रूप दे रहे हैं - हर 10 मिलीसेकंड पर हम इनपुट के मूल्यों की जांच करते हैं और केवल पांच इनपुटों का संयोजन एक पंक्ति में 6 बार होने पर ही परिवर्तनों पर प्रतिक्रिया करते हैं। आंख में देरी लगभग अगोचर है, हस्तक्षेप के साथ समस्या हल हो गई है। यहां वे हैं, प्रोग्रामेबल माइक्रोकंट्रोलर्स के मुख्य लाभ!

4. सामने के पहियों के रोटेशन के कोण को निर्धारित करें - एडीसी (एनालॉग-टू-डिजिटल कनवर्टर) के माध्यम से प्रतिक्रिया

दूसरे भाग में, मैंने उल्लेख किया कि सामने के पहियों को यंत्रवत् रूप से मध्य में संरेखित करना संभव नहीं है। यह समस्या को हल करने का समय है, क्योंकि मशीन को एक सीधी रेखा में सवारी करने में सक्षम होना चाहिए!

टास्क 10: रिओस्टेट को कनेक्ट करें

समाधान स्वयं का सुझाव देता है - यदि वसंत नहीं है, तो मोटर को विपरीत दिशा में घुमाएं जब तक कि यह पहियों को संरेखित न करें। हाथ में कोई डिजिटल एनकोडर नहीं हैं, लेकिन एक अद्भुत 10 khe rheostat है, बोर्ड में 12-बिट एडीसी (यहां तक कि 2) है, इंटरनेट में एक कनेक्शन सर्किट और एक कोड है। रिओस्तात के छोर "प्लस" और "माइनस", स्लाइडर - इनपुट के लिए 1 kΩ अवरोधक के माध्यम से। वैसे, एडीसी के उद्देश्यों के लिए, आप किसी भी इनपुट का उपयोग नहीं कर सकते। मैंने उदाहरण में निर्दिष्ट एक का उपयोग किया था। नमूना कोड ADIDE सहित प्रत्येक लाइब्रेरी के लिए सीधे CoIDE में पाया जा सकता है (CoIDE में ADC लाइब्रेरी कनेक्ट करना न भूलें)। कॉपी-पेस्ट कोड मेरे कार्यक्रम में है और सबसे महत्वपूर्ण बात यह है कि यह काम करता है।

अब हम मशीन में रियोस्टैट स्थापित करते हैं, हम रोटरी तंत्र के "रिड्यूसर" के आउटपुट शाफ्ट के साथ सह-शाफ़्ट को सह-शाफ़्ट से जोड़ते हैं - यह मोटर से तीसरा है। गैर-लेगो भागों को लेगो भागों के साथ बाँधने की प्रक्रिया हमेशा उद्धार करती है, लेकिन मोटर अभी भी रिओस्टेट को घुमाने और पहियों को घुमाने का प्रबंधन करती है। कठिनाई के साथ, मुझे कहना होगा। रिओस्टेट से बोर्ड तक तीन तार खिंचते हैं, मोटरों से एक और चार खिंचाव।

कार्य 11: रिओस्टेट से डेटा का उपयोग करना

आनुभविक विधि 0 से 4095 तक संख्यात्मक मानों का चयन करती है, जो सामने वाले पहियों के रोटेशन के कोण के स्वीकार्य बाएं और दाएं सीमाओं के अनुरूप होती हैं, जब वे सीधे स्थापित होते हैं। ऐसा लगता है कि इस सीमा को मृत क्षेत्र कहा जाता है - इसके भीतर, पहियों को बीच में संरेखित माना जाता है। रोटेशन के अधिकतम कोण तक पहुंचने पर मैंने मोटर को बंद करने के लिए मूल्यों का चयन किया।

कोड

 js= 2500; //    j —     0  4095 () gist=150; //    full=500; //      while (1) { //... if ((x>=max*7) && (inpok)) // inpok  0,         .             . if ((num==1) || (num==4) || (num==7)) // { GPIOC->BRR=GPIO_BRR_BR7; if (j>0+full) { GPIOC->BSRR=GPIO_BSRR_BS6; } else { if (j<0+full-gist) { GPIOC->BRR=GPIO_BRR_BR6; } } } else { GPIOC->BRR=GPIO_BRR_BR1; } if ((num==3) || (num==6) || (num==9)) // { GPIOC->BRR=GPIO_BRR_BR6; if (j<4250-full) { GPIOC->BSRR=GPIO_BSRR_BS7; //   « » } else { if (j>4250-full+gist) { GPIOC->BRR=GPIO_BRR_BR7; //   « » } } } else { GPIOC->BRR=GPIO_BRR_BR3; } //     if ((num==2) || (num==5) || (num==8)) { if (j<js-gist*3) //       { GPIOC->BRR=GPIO_BRR_BR6; //   « » (    ) GPIOC->BSRR=GPIO_BSRR_BS7; //   « » } else { if (j>js-gist*2) { GPIOC->BRR=GPIO_BRR_BR7;   « » } }; if (j>js+gist*3) { GPIOC->BRR=GPIO_BRR_BR7; GPIOC->BSRR=GPIO_BSRR_BS6; } else { if (j<js+gist*2) { GPIOC->BRR=GPIO_BRR_BR6; } }; }; }; //.. }

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

आपको याद दिला दूं, कुछ कोड किसी और के उदाहरण से लिए गए थे।

मशीन नियंत्रण कार्यक्रम का अंतिम कोड

 /** ***************************************************************************** * @title ADC_simple.c * @author Claude * @date 2010 Dec 29 * @brief ADC Example, Blink a LED according to ADC value ******************************************************************************* */ #include<stm32f10x_rcc.h> #include<stm32f10x_gpio.h> #include<stm32f10x_adc.h> #include "stm32f10x.h" #include "stm32f10x_conf.h" GPIO_InitTypeDef GPIO_InitStructure; ADC_InitTypeDef ADC_InitStructure; unsigned int i,j,js,gist,full,ti=0; /* Blink a LED, blink speed is set by ADC value */ int main(void) { unsigned int x,max; unsigned int move[10]; unsigned int oldsti=0,sti=0,time[10],tit=0; unsigned short recheck=5; unsigned char todisp=0,todisp2=0; x=0; unsigned char ji,ju,inp0,inp1,inp2,inp3,inpok,ink,in0,in1,in2,in3,inok,num,oldnum,back; max=250; inp0=0; inp1=0; inp2=0; inp3=0; inpok=0; ink=0; back=0; num=0; void backreset(void) { back=0; for (ju=0;ju<10;ju++) { time[ju]=0; move[ju]=0; } GPIOC->BRR=GPIO_BRR_BR9; } GPIO_InitTypeDef PORT,GPIO_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); PORT.GPIO_Pin = (GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12| GPIO_Pin_8 | GPIO_Pin_9); PORT.GPIO_Mode = GPIO_Mode_Out_PP; PORT.GPIO_Speed = GPIO_Speed_2MHz; GPIO_Init( GPIOC , &PORT); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); //   A GPIO_InitStructure.GPIO_Pin = (GPIO_Pin_9 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7); //   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; GPIO_Init(GPIOB, &GPIO_InitStructure); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE); PORT.GPIO_Pin = (GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_5); PORT.GPIO_Mode = GPIO_Mode_Out_PP; PORT.GPIO_Speed = GPIO_Speed_2MHz; GPIO_Init( GPIOA , &PORT); // input of ADC (it doesn't seem to be needed, as default GPIO state is floating input) GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 ; // that's ADC1 (PA1 on STM32) GPIO_Init(GPIOA, &GPIO_InitStructure); //clock for ADC (max 14MHz --> 72/6=12MHz) RCC_ADCCLKConfig (RCC_PCLK2_Div6); // enable ADC system clock RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); // define ADC config ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; ADC_InitStructure.ADC_ScanConvMode = DISABLE; ADC_InitStructure.ADC_ContinuousConvMode = ENABLE; // we work in continuous sampling mode ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_NbrOfChannel = 1; ADC_RegularChannelConfig(ADC1,ADC_Channel_1, 1,ADC_SampleTime_28Cycles5); // define regular conversion config ADC_Init ( ADC1, &ADC_InitStructure); //set config of ADC1 // enable ADC ADC_Cmd (ADC1,ENABLE); //enable ADC1 // ADC calibration (optional, but recommended at power on) ADC_ResetCalibration(ADC1); // Reset previous calibration while(ADC_GetResetCalibrationStatus(ADC1)); ADC_StartCalibration(ADC1); // Start new calibration (ADC must be off at that time) while(ADC_GetCalibrationStatus(ADC1)); // start conversion ADC_Cmd (ADC1,ENABLE); //enable ADC1 ADC_SoftwareStartConvCmd(ADC1, ENABLE); // start conversion (will be endless as we are in continuous mode) // debug information RCC_ClocksTypeDef forTestOnly; RCC_GetClocksFreq(&forTestOnly); //this could be used with debug to check to real speed of ADC clock //     6 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6,ENABLE); TIM6->PSC = 24000 - 1; //      1000    // TIM6->ARR = 1000 ; //       TIM6->ARR =4; TIM6->DIER |= TIM_DIER_UIE; //    TIM6->CR1 |= TIM_CR1_CEN; //  ! NVIC_EnableIRQ(TIM6_DAC_IRQn); // TIM6_DAC_IRQn  j= 2500; js=j; gist=150; full=500; if (back==0) { for (ju=0;ju<10;ju++) { time[ju]=0; move[ju]=0; } } while (1) { // adc is in free run, and we get the value asynchronously, this is not a really nice way of doing, but it work! j = ADC_GetConversionValue(ADC1) ; // value from 0 to 4095 /* possible change : * ADC_ContinuousConvMode = DISABLE * then on the infinite loop, something like : * * ADC_SoftwareStartConvCmd(ADC1, ENABLE); // start ONE conversion * while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET); // wait end of conversion * j = ADC_GetConversionValue(ADC1) * 500; // get value * */ do { sti=ti; } while (ti>1+sti); //if ((back!=2) || GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_9)) if (oldsti!=sti) { oldsti=sti; if (ink<recheck) { in0+=GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_5); in1+=GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_6); in2+=GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_7); in3+=GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_8); inok+=GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_9); ink++; if (ink==recheck) { ink=0; if ((in0==0 || in0==recheck) && (in1==0 || in1==recheck) && (in2==0 || in2==recheck) && (in3==0 || in3==recheck) && (inok==0 || inok==recheck)) { if (in0==recheck) { in0=1; } if (in1==recheck) { in1=1; } if (in2==recheck) { in2=1; } if (in3==recheck) { in3=1; } if (inok==recheck) { inok=1; } if ((back==2) && (inok==1)) { backreset(); } if ( (back!=2) && (back!=4) && ((inp0!=in0) || (inp1!=in1) || (inp2!=in2) || (inp3!=in3) || (inpok!=inok)) ) { x=0; inp0=in0; inp1=in1; inp2=in2; inp3=in3; inpok=inok; oldnum=num; if (inp0) // -  { if (inp1) { if (inp2) { if (inp3) { num=15; } else { num=7; }; } else { if (inp3) { num=11; } else { num=3; }; }; } else { if (inp2) { if (inp3) { num=13; } else { num=5; }; } else { if (inp3) { num=9; } else { num=1; }; }; }; } else { if (inp1) { if (inp2) { if (inp3) { num=14; } else { num=6; }; } else { if (inp3) { num=10; } else { num=2; }; }; } else { if (inp2) { if (inp3) { num=12; } else { num=4; }; } else { if (inp3) { num=8; } else { num=0; }; }; }; }; }; } in0=0; in1=0; in2=0; in3=0; inok=0; } } }; //  if ((todisp>0) && (sti%10==0)) { if ((sti%(todisp*20+100)<todisp*20) && (sti%20<10)) { GPIOC->BSRR=GPIO_BSRR_BS8; } else { GPIOC->BRR=GPIO_BRR_BR8; }; }; if ((todisp2>0) && (sti%10==2)) { if ((sti%(todisp2*20+100)<todisp2*20) && (sti%20<10)) { GPIOC->BSRR=GPIO_BSRR_BS9; } else { GPIOC->BRR=GPIO_BRR_BR9; }; }; //   if ((num==12)) { switch (back) { case 0: if (inpok) { back=3; }; break; case 3: if (!inpok) { back=4;ji=0;inpok=0;x=0; sti=0; }; break; default: ; } }; if (back==4) { if (inpok==0) { while ((move[ji]<1) && (ji<10)) { ji++; }; if ((ji<10)) { if ((sti>100)) { x=0; sti=0; num=move[ji]; tit=time[ji]; inpok=1; GPIOC->BRR=GPIO_BRR_BR8; GPIOC->BSRR=GPIO_BSRR_BS9; } } else { backreset(); } } else { if (sti>tit) { inpok=0; sti=0; x=0; ji++; GPIOC->BSRR=GPIO_BSRR_BS8; } } }; //   if ((num==10)) { switch (back) { case 0: if (inpok) { back=1; }; break; case 1: if (!inpok) { back=2;ji=9;inpok=0;x=0; sti=0; }; break; default: ; } }; if (back==2) { if (inpok==0) { if ((ji>0) && (move[ji]>0)) { if ((sti>100)) { x=0; sti=0; num=move[ji]; if (num<4) { num+=6; } else { if (num>6) { num-=6; } } tit=time[ji]; inpok=1; GPIOC->BRR=GPIO_BRR_BR8; GPIOC->BSRR=GPIO_BSRR_BS9; } } else { backreset(); } } else { if (sti>tit) { inpok=0; x=0; sti=0; ji--; GPIOC->BSRR=GPIO_BSRR_BS8; } } }; //      "*" if (num==11) { backreset(); } if ((x==3*max)) { GPIOC->BRR=GPIO_BRR_BR12; if ((!inpok) || (num<1) || (num>9)) { GPIOC->BRR=GPIO_BRR_BR6; GPIOC->BRR=GPIO_BRR_BR7; GPIOC->BRR=GPIO_BRR_BR10; GPIOC->BRR=GPIO_BRR_BR11; } if ((back!=2)&&(back!=4)) { in0=inp0; in1=inp1; in2=inp2; in3=inp3; inok=inpok; } if ((move[9]>0)&&(move[9]<10)&&(!inpok)&&(back!=2)&&(back!=4)) { for (ju=0;ju<9;ju++) { time[ju]=time[ju+1]; } time[9]=sti; }; }; if ((x==5*max) && (inpok)) { if ((1<=num) && (num<=9)&&(back!=2)&&(back!=4)) { for (ju=0;ju<9;ju++) //    { move[ju]=move[ju+1]; } move[9]=num; sti=0; // ,       }; if ((num==1) || (num==2) || (num==3)) { GPIOC->BRR=GPIO_BRR_BR10; GPIOC->BSRR=GPIO_BSRR_BS11; GPIOC->BSRR=GPIO_BSRR_BS2; } else { GPIOC->BRR=GPIO_BRR_BR11; }; if ((num==7) || (num==8) || (num==9)) //  { GPIOC->BRR=GPIO_BRR_BR11; GPIOC->BSRR=GPIO_BSRR_BS10; GPIOC->BSRR=GPIO_BSRR_BS2; } else { GPIOC->BRR=GPIO_BRR_BR10; }; }; if ((x>=max*7) && (inpok)) // inpok  0,         .             . { if ((num==1) || (num==4) || (num==7)) // { GPIOC->BRR=GPIO_BRR_BR7; if (j>0+full) { GPIOC->BSRR=GPIO_BSRR_BS6; } else { if (j<0+full-gist) { GPIOC->BRR=GPIO_BRR_BR6; } } } else { GPIOC->BRR=GPIO_BRR_BR1; } if ((num==3) || (num==6) || (num==9)) // { GPIOC->BRR=GPIO_BRR_BR6; if (j<4250-full) { GPIOC->BSRR=GPIO_BSRR_BS7; } else { if (j>4250-full+gist) { GPIOC->BRR=GPIO_BRR_BR7; } } } else { GPIOC->BRR=GPIO_BRR_BR3; } //     if ((num==2) || (num==5) || (num==8)) { if (j<js-gist*3) //       { GPIOC->BRR=GPIO_BRR_BR6; //   « » (    ) GPIOC->BSRR=GPIO_BSRR_BS7; //   « » } else { if (j>js-gist*2) { GPIOC->BRR=GPIO_BRR_BR7;   « » } }; if (j>js+gist*3) { GPIOC->BRR=GPIO_BRR_BR7; GPIOC->BSRR=GPIO_BSRR_BS6; } else { if (j<js+gist*2) { GPIOC->BRR=GPIO_BRR_BR6; } }; }; }; if ((x==max*15)) { if (((num==1) || (num==2) || (num==3) || (num==5) || (num==7) || (num==8) || (num==9))&&(inpok)) //    { GPIOC->BSRR=GPIO_BSRR_BS12; } else { GPIOC->BRR=GPIO_BRR_BR12; } x++; } else { x++; if (x>max*20+300000) { if (!inpok) { GPIOC->BRR=GPIO_BRR_BR2;//   } x=max*20+1; } } //   if (x%80000<40000) { if ((num%3==1) && (inpok) && (num<10)) { GPIOC->BSRR=GPIO_BSRR_BS1; } else { GPIOC->BRR=GPIO_BRR_BR1; } if ((num%3==0) && (inpok) && (num<10)) { GPIOC->BSRR=GPIO_BSRR_BS3; } else { GPIOC->BRR=GPIO_BRR_BR3; } } else { GPIOC->BRR=GPIO_BRR_BR1; GPIOC->BRR=GPIO_BRR_BR3; } if (sti==0) { do { ti=0; } while (ti>1); } }; return 0; }; //   TIM6_DAC void TIM6_DAC_IRQHandler(void) { ti++; TIM6->SR &= ~TIM_SR_UIF; //  UIF }

यह इस तरह से कुछ काम करता है:

5. ध्वनियों को चलाने के लिए DAC (डिजिटल-से-एनालॉग कनवर्टर) का उपयोग करना

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

इस उदाहरण का उपयोग करके पहली ध्वनियाँ प्राप्त की गई थीं।

उदाहरण कोड

 #include "stm32f10x.h" #include "stm32f10x_rcc.h" #include "stm32f10x_gpio.h" /* ,       DAC    */ const uint16_t sin[32] = { 2047, 2447, 2831, 3185, 3498, 3750, 3939, 4056, 4095, 4056, 3939, 3750, 3495, 3185, 2831, 2447, 2047, 1647, 1263, 909, 599, 344, 155, 38, 0, 38, 155, 344, 599, 909, 1263, 1647}; unsigned char i=0; int main(void) { /*    */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); /*   */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE); /*   6 */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6,ENABLE); /*    */ GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOA, &GPIO_InitStructure); /*        */ TIM6->PSC = 0; TIM6->ARR = 500; TIM6->DIER |= TIM_DIER_UIE; //    TIM6->CR1 |= TIM_CR1_CEN; //  ! NVIC_EnableIRQ(TIM6_DAC_IRQn); // TIM6_DAC_IRQn  /*  DAC1 */ DAC->CR |= DAC_CR_EN1; /*   */ while (1) { } } /*    6 */ void TIM6_DAC_IRQHandler(void) { TIM6->SR &= ~TIM_SR_UIF; //  UIF DAC->DHR12R1=sin[i++]; //      if (i==32) i=0; //     32     }

यह गणना करना अच्छा होगा कि कार्यक्रम कोड के आधार पर भोजन की आवृत्ति क्या होनी चाहिए, और ट्यूनर के साथ परिणाम की तुलना करें। प्रोसेसर आवृत्ति: 24,000,000 हर्ट्ज। टाइमर TIM6-> PSC शून्य पर पहुंचने पर रीसेट हो जाता है, अर्थात हर हरा। टाइमर TIM6-> ARR 500 तक पहुंच जाता है, अर्थात व्यवधान प्रत्येक 501 वें रीसेट TIM6-> PSC के लिए ट्रिगर किया गया है - हमारे मामले में यह (24,000,000 हर्ट्ज / 1) / 501, 47,904 हर्ट्ज है। यह भविष्य के ऑडियो सिग्नल की नमूना आवृत्ति है । , - mp3 44 100 . , , — 16 12. , .

— , 32 sin. : 47 904 / 32 ≈ 1 497 . ( 5 ), … «!». F#6, , : 1 497,1 .

12:

क्योंकि , - . -, . , 5 , 10 . :
TIM6->PSC = 23; // 1 M
TIM6->ARR = 99; // PSC 23 ARR 99 100 (10 )
, , — 27,5 . , (440 , ),

11 ( ). ( 12 n ).

: , Excel . , . . , (), . 2 400 . Excel, , :

, 12 ( ).
( — 27,5 ) (# — +1 , — +2 , — +12 ).
, 10 000 , 10 000 .
.
0 4095, .

. परिणाम:

 //  const uint16_t noteC[]={ 76,2216,2383,2547,2709,2865,3017,3162,3299,3428,3547,3657,3755,3842,3917, 3979,4028,4064,4086,4095,4090,4070,4038,3991,3932,3860,3775,3679,3572, 3455,3328,3193,3050,2900,2744,2584,2419,2253,2085,1917,1749,1584,1422, 1264,1111,965,826,695,574,462,361,271,194,129,76,38,12,1,3,19,49,92,149, 218,300,393,498,613,738,871,1013,1161,1316,1475,1639,1805,1973 };

 //   const uint16_t noteCd[]={ 72,2226,2402,2576,2746,2911,3069,3220,3361,3493,3614,3722,3818,3901,3970, 4024,4063,4087,4095,4088,4065,4027,3974,3907,3825,3730,3622,3503,3372, 3231,3081,2924,2759,2590,2416,2239,2061,1883,1706,1532,1362,1196,1038, 887,744,612,490,381,284,200,130,75,35,10,0,6,27,64,116,182,263,357,464, 583,713,853,1002,1159,1323,1492,1666,1842,2020 }; const uint16_t noteD[]={ 68,2236,2423,2607,2786,2959,3124,3280,3425,3559,3680,3787,3879,3955,4016, 4059,4086,4095,4087,4061,4018,3959,3883,3792,3686,3566,3432,3288,3132, 2968,2795,2617,2433,2246,2057,1869,1682,1498,1318,1145,980,823,677,543, 421,314,221,143,82,38,10,0,7,32,74,133,207,298,403,523,655,799,954,1118, 1291,1469,1652,1839,2028 }; const uint16_t noteDd[]={ 63,2247,2445,2639,2828,3009,3181,3342,3490,3625,3745,3849,3935,4003, 4053,4084,4095,4087,4059,4012,3946,3862,3761,3643,3510,3363,3204, 3034,2854,2666,2473,2275,2076,1876,1678,1483,1293,1111,938,775, 625,488,366,260,171,100,48,14,0,6,31,76,139,220,319,434,565,710, 868,1037,1215,1402,1594,1792,1991 }; //  const uint16_t noteE[]={ 60,2259,2469,2673,2872,3061,3239,3405,3556,3691,3809,3907,3986,4044,4080, 4095,4087,4058,4008,3936,3844,3733,3604,3458,3297,3122,2937,2741,2538, 2330,2119,1907,1697,1490,1289,1097,914,744,588,447,324,219,133,69,25, 3,3,24,68,133,218,323,446,586,742,912,1095,1287,1488,1694,1905 }; const uint16_t noteF[]={ 57,2272,2493,2709,2917,3115,3300,3470,3623,3756,3870,3961,4029,4074, 4094,4089,4060,4007,3930,3831,3710,3569,3410,3234,3044,2842,2631, 2413,2190,1965,1742,1522,1309,1104,911,731,567,421,295,189,106,47, 11,0,14,51,113,199,306,434,582,748,929,1123,1329,1543,1763,1987 }; const uint16_t noteFd[]={ 54,2285,2519,2747,2966,3172,3362,3536,3689,3820,3927,4008, 4063,4091,4092,4065,4010,3929,3823,3693,3540,3367,3177, 2971,2753,2526,2291,2054,1817,1582,1354,1135,929,738,564, 410,279,171,89,33,4,3,29,83,163,269,399,550,723,912,1118,1336,1563,1797,2034 }; const uint16_t noteG[]={ 51,2299,2547,2787,3016,3230,3426,3602,3754,3880,3978,4047,4086, 4094,4071,4017,3934,3822,3683,3519,3333,3127,2905,2670,2426,2176, 1924,1674,1430,1194,972,766,580,416,276,163,79,25,1,8,47,115,213, 338,490,665,861,1075,1303,1543,1791,2042 }; const uint16_t noteGd[]={ 48,2314,2576,2829,3068,3290,3492,3668,3817,3936,4023,4076, 4095,4079,4028,3944,3828,3681,3506,3307,3086,2848,2596, 2335,2069,1802,1540,1286,1045,821,618,440,288,167,78,22, 0,14,61,143,257,401,574,771,991,1228,1479,1739,2005 }; const uint16_t noteA[]={ 45,2330,2606,2872,3123,3353,3558,3734,3878,3987,4059,4092, 4087,4043,3961,3842,3689,3504,3292,3056,2801,2532,2253, 1970,1689,1415,1153,907,684,486,319,184,85,23,0,16,71, 163,292,454,646,865,1107,1366,1639,1919 }; const uint16_t noteAd[]={ 42,2346,2639,2918,3179,3416,3624,3798,3934,4030,4083,4093, 4059,3982,3864,3707,3514,3290,3039,2767,2480,2183,1883, 1587,1301,1031,782,561,371,218,103,30,1,15,72,172,313, 490,700,940,1203,1484,1777 }; const uint16_t noteH[]={ 40,2364,2673,2967,3238,3481,3690,3859,3985,4064,4095,4076, 4009,3894,3736,3536,3301,3036,2747,2441,2126,1809,1498,1199, 922,671,453,274,137,46,3,10,65,168,316,506,732,991,1274,1577,1890 }; const uint16_t noteP[]={ //   1,2048 };

, ( 1, 2, 4, 8 ..):

 uint16_t mnote(const uint16_t *pa,char octave) //         { int ii=0; do {ii=i;} while (ii!=i); ii=(octave*ii)%pa[0]; ii=*(pa+ii); return ii; }

i 100 :

 /*    6 */ void TIM6_DAC_IRQHandler(void) { i++; TIM6->SR &= ~TIM_SR_UIF; //  UIF }

, . , Nokia:

 uint16_t *melody[]={ noteE,noteP,noteG,noteP, noteA,noteA,noteP,noteE, noteP,noteG,noteP,noteAd, noteA,noteA,noteP,noteP, noteE,noteP,noteG,noteP, noteA,noteA,noteP,noteG, noteP,noteE,noteP,noteP, noteP,noteP,noteP,noteP };

, ?..

(), , :

कोड

  uint16_t *melody2[]={ noteH,noteP,noteD,noteP, noteE,noteE,noteP,noteH, noteP,noteD,noteP,noteF, noteE,noteE,noteP,noteP, noteH,noteP,noteD,noteP, noteE,noteE,noteP,noteD, noteP,noteH,noteP,noteP, noteP,noteP,noteP,noteP }; uint16_t *melody3[]={ noteGd,noteP,noteH,noteP, noteCd,noteCd,noteP,noteGd, noteP,noteH,noteP,noteD, noteCd,noteCd,noteP,noteP, noteGd,noteP,noteH,noteP, noteCd,noteCd,noteP,noteH, noteP,noteGd,noteP,noteP, noteP,noteP,noteP,noteP };

( ). लेकिन! 0 4095, . , , . 100 …

.

 #include "stm32f10x.h" #include "stm32f10x_rcc.h" #include "stm32f10x_gpio.h" int i=0; uint16_t current=0; int loccurrent=0; uint16_t mnote(const uint16_t *pa,char octave) //         { int ii=0; do {ii=i;} while (ii!=i); ii=(octave*ii)%pa[0]; ii=*(pa+ii); return ii; } //      100 ,  0  4095 //  const uint16_t noteC[]={ 76,2216,2383,2547,2709,2865,3017,3162,3299,3428,3547,3657,3755,3842,3917,3979,4028,4064,4086,4095,4090,4070,4038,3991,3932,3860,3775,3679,3572,3455,3328,3193,3050,2900,2744,2584,2419,2253,2085,1917,1749,1584,1422,1264,1111,965,826,695,574,462,361,271,194,129,76,38,12,1,3,19,49,92,149,218,300,393,498,613,738,871,1013,1161,1316,1475,1639,1805,1973 }; //   const uint16_t noteCd[]={ 72,2226,2402,2576,2746,2911,3069,3220,3361,3493,3614,3722,3818,3901,3970,4024,4063,4087,4095,4088,4065,4027,3974,3907,3825,3730,3622,3503,3372,3231,3081,2924,2759,2590,2416,2239,2061,1883,1706,1532,1362,1196,1038,887,744,612,490,381,284,200,130,75,35,10,0,6,27,64,116,182,263,357,464,583,713,853,1002,1159,1323,1492,1666,1842,2020 }; const uint16_t noteD[]={ 68,2236,2423,2607,2786,2959,3124,3280,3425,3559,3680,3787,3879,3955,4016,4059,4086,4095,4087,4061,4018,3959,3883,3792,3686,3566,3432,3288,3132,2968,2795,2617,2433,2246,2057,1869,1682,1498,1318,1145,980,823,677,543,421,314,221,143,82,38,10,0,7,32,74,133,207,298,403,523,655,799,954,1118,1291,1469,1652,1839,2028 }; const uint16_t noteDd[]={ 63,2247,2445,2639,2828,3009,3181,3342,3490,3625,3745,3849,3935,4003,4053,4084,4095,4087,4059,4012,3946,3862,3761,3643,3510,3363,3204,3034,2854,2666,2473,2275,2076,1876,1678,1483,1293,1111,938,775,625,488,366,260,171,100,48,14,0,6,31,76,139,220,319,434,565,710,868,1037,1215,1402,1594,1792,1991 }; //  const uint16_t noteE[]={ 60,2259,2469,2673,2872,3061,3239,3405,3556,3691,3809,3907,3986,4044,4080,4095,4087,4058,4008,3936,3844,3733,3604,3458,3297,3122,2937,2741,2538,2330,2119,1907,1697,1490,1289,1097,914,744,588,447,324,219,133,69,25,3,3,24,68,133,218,323,446,586,742,912,1095,1287,1488,1694,1905 }; const uint16_t noteF[]={ 57,2272,2493,2709,2917,3115,3300,3470,3623,3756,3870,3961,4029,4074,4094,4089,4060,4007,3930,3831,3710,3569,3410,3234,3044,2842,2631,2413,2190,1965,1742,1522,1309,1104,911,731,567,421,295,189,106,47,11,0,14,51,113,199,306,434,582,748,929,1123,1329,1543,1763,1987 }; const uint16_t noteFd[]={ 54,2285,2519,2747,2966,3172,3362,3536,3689,3820,3927,4008,4063,4091,4092,4065,4010,3929,3823,3693,3540,3367,3177,2971,2753,2526,2291,2054,1817,1582,1354,1135,929,738,564,410,279,171,89,33,4,3,29,83,163,269,399,550,723,912,1118,1336,1563,1797,2034 }; const uint16_t noteG[]={ 51,2299,2547,2787,3016,3230,3426,3602,3754,3880,3978,4047,4086,4094,4071,4017,3934,3822,3683,3519,3333,3127,2905,2670,2426,2176,1924,1674,1430,1194,972,766,580,416,276,163,79,25,1,8,47,115,213,338,490,665,861,1075,1303,1543,1791,2042 }; const uint16_t noteGd[]={ 48,2314,2576,2829,3068,3290,3492,3668,3817,3936,4023,4076,4095,4079,4028,3944,3828,3681,3506,3307,3086,2848,2596,2335,2069,1802,1540,1286,1045,821,618,440,288,167,78,22,0,14,61,143,257,401,574,771,991,1228,1479,1739,2005 }; const uint16_t noteA[]={ 45,2330,2606,2872,3123,3353,3558,3734,3878,3987,4059,4092,4087,4043,3961,3842,3689,3504,3292,3056,2801,2532,2253,1970,1689,1415,1153,907,684,486,319,184,85,23,0,16,71,163,292,454,646,865,1107,1366,1639,1919 }; const uint16_t noteAd[]={ 42,2346,2639,2918,3179,3416,3624,3798,3934,4030,4083,4093,4059,3982,3864,3707,3514,3290,3039,2767,2480,2183,1883,1587,1301,1031,782,561,371,218,103,30,1,15,72,172,313,490,700,940,1203,1484,1777 }; const uint16_t noteH[]={ 40,2364,2673,2967,3238,3481,3690,3859,3985,4064,4095,4076,4009,3894,3736,3536,3301,3036,2747,2441,2126,1809,1498,1199,922,671,453,274,137,46,3,10,65,168,316,506,732,991,1274,1577,1890 }; const uint16_t noteP[]={ 1,2048 }; //,   uint16_t *melody[]={ noteE,noteP,noteG,noteP, noteA,noteA,noteP,noteE, noteP,noteG,noteP,noteAd, noteA,noteA,noteP,noteP, noteE,noteP,noteG,noteP, noteA,noteA,noteP,noteG, noteP,noteE,noteP,noteP, noteP,noteP,noteP,noteP }; //  uint16_t *melody2[]={ noteH,noteP,noteD,noteP, noteE,noteE,noteP,noteH, noteP,noteD,noteP,noteF, noteE,noteE,noteP,noteP, noteH,noteP,noteD,noteP, noteE,noteE,noteP,noteD, noteP,noteH,noteP,noteP, noteP,noteP,noteP,noteP }; //  uint16_t *melody3[]={ noteGd,noteP,noteH,noteP, noteCd,noteCd,noteP,noteGd, noteP,noteH,noteP,noteD, noteCd,noteCd,noteP,noteP, noteGd,noteP,noteH,noteP, noteCd,noteCd,noteP,noteH, noteP,noteGd,noteP,noteP, noteP,noteP,noteP,noteP }; int main(void) { GPIO_InitTypeDef PORT; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC , ENABLE); PORT.GPIO_Pin = (GPIO_Pin_9 | GPIO_Pin_8); PORT.GPIO_Mode = GPIO_Mode_Out_PP; PORT.GPIO_Speed = GPIO_Speed_2MHz; GPIO_Init(GPIOC, &PORT); /*    */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); /*   */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE); /*   6 */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6,ENABLE); /*    */ GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOA, &GPIO_InitStructure); TIM6->PSC = 23; // 24000-1  1000 TIM6->ARR = 99; // PSC 23  ARR 99   100  TIM6->DIER |= TIM_DIER_UIE; //    TIM6->CR1 |= TIM_CR1_CEN; //  ! NVIC_EnableIRQ(TIM6_DAC_IRQn); // TIM6_DAC_IRQn  /*  DAC1 */ DAC->CR |= DAC_CR_EN1; /*   */ while (1) { GPIOC->BRR=GPIO_BRR_BR8; GPIOC->BSRR=GPIO_BSRR_BS9; do { loccurrent=i; } while (i!=loccurrent); //  ,    GPIOC->BRR=GPIO_BRR_BR9; GPIOC->BSRR=GPIO_BSRR_BS8; current=(loccurrent/(2000))%32; //   ,  0  31. DAC->DHR12R1=(mnote(melody[current],1)+mnote(melody2[current],1)+mnote(melody[current],2)+mnote(melody2[current],2)+mnote(melody[current],4)+mnote(melody3[current],2))/6; } } /*    6 */ void TIM6_DAC_IRQHandler(void) { i++; TIM6->SR &= ~TIM_SR_UIF; //  UIF }

एक तार्किक प्रश्न उठता है: क्या एक एकल साइनसॉइड अवधि के बजाय कुछ अद्भुत ध्वनि को एक सरणी में लिखना संभव है? हां।

कार्य 13: किसी फ़ाइल से ध्वनि चलाएँ

, , STM32VLDiscovery, . :
1. Youtube Aston Martin.
2. ( ) .
3. ( Audacity ).
4. . 24 . , 2 , 2-3 -. .
5. WAV-.
6. ( WAV 2 TEXT) — -, . , .
7. 0 4095 Excel. 60 000 Notepad++ Sublime Text, . Excel 30 , — CoIDE …
8. .

, over 9000 . :

, , , , , :

कुछ इस तरह।

STM32 प्रोग्रामयोग्य माइक्रोकंट्रोलर - बल्ले से सही

सामग्री:

1. माइक्रोइलेक्ट्रॉनिक के साथ पहला संपर्क

टास्क 1: डीटीएमएफ सिग्नल रिकग्निशन

टास्क 2: DTMF डिकोडर से संकेतों के 4 निश्चित संयोजनों को 4 कार्यों में से एक को सक्रिय करना चाहिए

टास्क 3: मोटर्स, एच-ब्रिज के लिए पोलरिटी रिवर्सल

कार्य 4: एक टाइपराइटर इकट्ठा करें

2. गैर-प्रोग्राम योग्य तर्क तत्वों पर कारों का निर्माण

कार्य 5: मशीन को 1, 3, 7 या 9 दबाए जाने पर मुड़ना चाहिए

3. STM32 से शुरुआत करना

टास्क 6: देरी

कार्य 7: एक निर्दिष्ट अंतराल पर अंतराल

टास्क 8: डिस्प्ले के रूप में एलईडी

टास्क 9: मशीन को माइक्रोकंट्रोलर कनेक्ट करें

4. सामने के पहियों के रोटेशन के कोण को निर्धारित करें - एडीसी (एनालॉग-टू-डिजिटल कनवर्टर) के माध्यम से प्रतिक्रिया

टास्क 10: रिओस्टेट को कनेक्ट करें

कार्य 11: रिओस्टेट से डेटा का उपयोग करना

5. ध्वनियों को चलाने के लिए DAC (डिजिटल-से-एनालॉग कनवर्टर) का उपयोग करना

12:

कार्य 13: किसी फ़ाइल से ध्वनि चलाएँ

More articles: