🎪 🌨️ 🛵 Stm32 माइक्रोकंट्रोलर अनुप्रयोग विकास का एक संक्षिप्त परिचय 👧🏿 🌜 🧑🏿‍🤝‍🧑🏼

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

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

हर कोई जो stm32 के साथ काम करना शुरू करने के लिए इच्छुक है, बिल्ली का स्वागत करता है।

हमें आगे के काम के लिए क्या चाहिए

एआरएम v7.30 पर्यावरण के लिए आईएआर एंबेडेड कार्यक्षेत्र में पालन किए जाने वाले सभी उदाहरण। पर्यावरण विंडोज़ एक्सपी पर स्थापित है, जो मैक ओएस एक्स एल कप्तान से लॉन्च की गई वर्चुअलबॉक्स वर्चुअल मशीन में स्थापित है। ST-LINK प्रोग्रामर का भी उपयोग किया जाता है, जो ~ 120₽ के लिए AliExpress पर खरीदे गए ब्लू पिल बोर्ड से जुड़ता है।

एक विशिष्ट परियोजना बनाने के लिए आपको आवश्यकता होगी:

ब्लू पिल मॉड्यूल या समान

वे आसानी से AliExpress पर "stm32f103c8t6 बोर्ड" और लगभग 100 रूबल की लागत के अनुरोध पर स्थित हैं।
प्रोग्रामर एसटी-लिंक

यह अलीस्टप्रेस पर "स्टिंकल वी 2" के अनुरोध पर भी आसानी से उपलब्ध है और इसकी लागत लगभग 100 रूबल है।

एक अधिक पूर्ण संस्करण है, जो एक मानक रिबन कनेक्टर IDC20 को जोड़ने के लिए डिज़ाइन किया गया है
IAR विकास पर्यावरण 7.30 या बाद में

सीमित संस्करण 8.10 आधिकारिक वेबसाइट से डाउनलोड किया जा सकता है।
एक परियोजना टेम्पलेट जिसमें सभी आवश्यक घटक शामिल हैं

यहां टेम्प्लेट डाउनलोड किया जा सकता है।
STDPeripheralLibrary3.5.0 फ़ंक्शन संदर्भ

परियोजना में StdPeriph3.5.0 फ़ंक्शन का एक पुस्तकालय शामिल है। गंभीर परियोजनाओं के लिए थोड़ा पुराना है, लेकिन शुरुआती लोगों के लिए यह काफी सरल है और माइक्रोकंट्रोलर की परिधि के साथ काम करने पर सिरदर्द से बचा जाता है। WinHelp (CHM) प्रारूप में हैंडबुक डाउनलोड की जा सकती है
यहाँ से
RM0008 संदर्भ मैनुअल

Stm32f103c8 परिवार के माइक्रोकंट्रोलर्स के लिए संदर्भ मैनुअल। संदर्भ पुस्तक में माइक्रोकंट्रोलर की कोर और परिधि का विवरण, इसकी वास्तुकला और रजिस्टरों का विवरण शामिल है। यह सलाह दी जाती है, समय के साथ, साथ और भर में पढ़ने और यह जानने के लिए कि प्रत्येक परिधीय घटक कैसे काम करता है। यदि आप नग्न CMSIS के समर्थक हैं, तो इस PDF के बिना आप ऐसा नहीं कर सकते। यदि नौसिखिया जो पेरलिब का उपयोग करता है, तो आपको अभी भी यह पढ़ने की आवश्यकता है कि यह या वह परिधीय मॉड्यूल कैसे काम करता है। आप STMicroelectonics वेबसाइट से संदर्भ डाउनलोड कर सकते हैं

प्रोजेक्ट टेम्प्लेट

संलग्न प्रोजेक्ट टेम्प्लेट पूरी तरह से इंटरनेट पर कहीं से नहीं लिया गया था, लेकिन हमारे अपने हाथों से बनाया गया था जो कि पेरिफेरल रूट्स में गए, CMSIS पैकेज से फाइलें और हमारे अपने सुधार। प्रोजेक्ट टेम्प्लेट में ऐसी फाइलें शामिल नहीं हैं जो किसी भी विकास के माहौल से संबंधित हैं और उनमें से किसी के लिए भी उपयोग किया जा सकता है (मैंने इसका परीक्षण नहीं किया है, लेकिन मुझे ऐसा लगता है)।

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

परियोजना निर्देशिका संरचना

config
stm32f10x_conf.h

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

इस निर्देशिका में CMSIS फ़ाइलें हैं जो ARM CortexM3 प्रोसेसर कोर के लिए विशिष्ट हैं।
perlib

इस निर्देशिका में शीर्ष और src निर्देशिकाओं में पेरलिब लाइब्रेरी के हेडर फाइलें और स्रोत कोड शामिल हैं।
स्टार्टअप

यहां कंट्रोलर के प्राइमरी इनिशियलाइज़ेशन कोड वाली फाइलें हैं, जो ARM कर्नेल इंटरप्ट हैंडलर इंस्टॉल करते हैं और कर्नेल क्लॉक सिस्टम और PLL इनिशियलाइज़ेशन के इनिशियलाइज़ेशन फंक्शन को कॉल करते हैं। प्रत्येक प्रकार के माइक्रोकंट्रोलर की अपनी अलग फाइल होती है।

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

उदाहरण के लिए, 72 मेगाहर्ट्ज पर काम करने के लिए stm32f103c8t6 माइक्रोकंट्रोलर के लिए, और डिफ़ॉल्ट 8 मेगाहर्ट्ज के लिए, आपको प्रोजेक्ट में स्टार्टअप_stm32f10x_md.s फ़ाइल कनेक्ट करने की आवश्यकता है।
प्रणाली

इस निर्देशिका में फ़ाइलें शामिल हैं, जिसमें सिस्टम के प्रारंभिक आरंभीकरण के सभी कार्य शामिल हैं, एआरएम कर्नेल के लिए बाधा हैंडलर, साथ ही साथ माइक्रोकंट्रोलर रजिस्टरों के नाम और फ़ील्ड्स का विवरण।

stm32f10x.h

यह CMSIS पैकेज की एक फ़ाइल है जिसमें पते, रजिस्टरों के नाम और माइक्रोकंट्रोलर की परिधि के लिए उनके क्षेत्र शामिल हैं। प्रत्येक परिधीय मॉड्यूल को यहां एक संरचना के रूप में प्रस्तुत किया गया है, जिसके क्षेत्र रजिस्टरों हैं। यह रजिस्टर फ़ील्ड के लिए स्थिरांक और बिट मास्क को भी परिभाषित करता है।

stm32f10x_it

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

प्रोसेसर कोर इंटरप्ट हैंडलिंग और पेरीफेरल इंटरप्ट हैंडलिंग को भ्रमित न करें। पेरिफेरल रुकावट, जैसे कि टाइमर या USART, अपने प्रोजेक्ट फाइलों में किया जाना चाहिए, जिसे आप स्वयं लिखते हैं और प्रोजेक्ट डायरेक्टरी की जड़ में जोड़ते हैं।

system_stm32f10x

इन दो फ़ाइलों में कर्नेल क्लॉक और PLL के समान आरंभीकरण कार्य होते हैं जिन्हें स्टार्टअप डायरेक्टरी में आरंभीकरण फ़ाइल से कहा जाता है। अर्थात्, फ़ंक्शंस SystemInit और SystemCoreClockUpdate।

एक प्रोजेक्ट बनाएं

हमारी पहली परियोजना बनाने के लिए, आपको सबसे पहले इसके लिए एक फ़ोल्डर बनाना होगा। चलो इसे EX01 कहते हैं।
हम IAR लॉन्च करते हैं और प्रोजेक्ट मेनू में Create New Project का चयन करते हैं।

चित्र 1. एक नई परियोजना का निर्माण

टूलचेन का मूल्य एआरएम पर छोड़ दिया जाना चाहिए, और हम प्रोजेक्ट टेम्पलेट सी → मुख्य का चयन करते हैं। अगला, ठीक पर क्लिक करें।

चित्र 2. किसी खाली प्रोजेक्ट को सहेजना

एक सेव प्रोजेक्ट विंडो दिखाई देगी। इसमें, आपको पहले से बनाए गए फ़ोल्डर का चयन करना चाहिए। आइए परियोजना का नाम ex01 रखें। अब, आप Save पर क्लिक कर सकते हैं।

नतीजतन, एक खाली मुख्य फ़ाइल और एक खाली परियोजना बनाई जाएगी, जिसमें अभी तक कोई सेटिंग नहीं है। अगला कदम कार्यक्षेत्र को बचाने के लिए है ताकि भविष्य में यह हमारे सवालों में हस्तक्षेप न करे। फ़ाइल → कार्यक्षेत्र सहेजें पर क्लिक करें। इसे ex01 पर कॉल करें और सेव पर क्लिक करें ।

चित्र 3. कार्यक्षेत्र को सहेजना

अब हम प्रोजेक्ट टेम्पलेट का उपयोग करने के लिए तैयार हैं। इसे संग्रह से हमारे EX01 फ़ोल्डर में कॉपी करें।

चित्रा 4. एक नई परियोजना के लिए एक टेम्पलेट से फ़ाइलों की नकल

प्रोजेक्ट टेम्पलेट बनाने वाली मुख्य फ़ाइलों को प्रोजेक्ट से फ़ाइलों के साथ प्रतिस्थापित किया जाना चाहिए।

प्रोजेक्ट टेम्पलेट की प्रतिलिपि बनाने के बाद, आपको प्रोजेक्ट को स्वयं कॉन्फ़िगर करना चाहिए।

ऐसा करने के लिए, मेनू प्रोजेक्ट → विकल्प का चयन करें। एक विंडो खुल जाएगी जिसमें बाईं ओर विकल्पों की श्रेणियों की एक सूची होगी, जिनमें से प्रत्येक में कुछ बुकमार्क होंगे।

इसमें सामान्य विकल्प श्रेणी और लक्ष्य टैब चुनें। प्रोसेसर वेरिएंट समूह में, डिवाइस विकल्प का चयन करें और उसके बगल में एक विशिष्ट डिवाइस का चयन करने के लिए बटन पर क्लिक करें। हमारे मामले में, यह ST → STM32F103 → ST STM32F103x8 होगा।

चित्रा 5. परियोजना के लिए लक्ष्य डिवाइस का चयन करना

अगली श्रेणी जिसे हमारे ध्यान की आवश्यकता है वह है C / C ++ कंपाइलर श्रेणी और प्रीप्रोसेसर टैब।

चित्रा 6. प्रीप्रोसेसर बुकमार्क सेटिंग्स

अतिरिक्त शामिल निर्देशिकाओं को परियोजना टेम्पलेट निर्देशिकाओं के लिंक के साथ भरा जाना चाहिए।

PreInclude फ़ाइल, आपको PerLib लाइब्रेरी कॉन्फ़िगरेशन फ़ाइल का चयन करने की आवश्यकता है, और परिभाषित प्रतीकों को STM32F10X_MD के साथ निर्दिष्ट किया जाना चाहिए ताकि आरंभीकरण फ़ाइलें सही कर्नेल घड़ी स्थापित करें और सही ढंग से PLL कॉन्फ़िगर करें।

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

चित्र 7. डिबगिंग टूल चुनना

अब आपको नियंत्रक पर फर्मवेयर अपलोड को कॉन्फ़िगर करने की आवश्यकता है। आप इसे डाउनलोड टैब पर उसी श्रेणी में कर सकते हैं। हम Verify डाउनलोड और फ़्लैश लोडर (ओं) के विकल्पों में रुचि रखते हैं।

चित्रा 8. माइक्रोकंट्रोलर में फर्मवेयर अपलोड मापदंडों को कॉन्फ़िगर करना

चूंकि हमने एसटी-लिंक को नियंत्रक और डीबगिंग के लिए फर्मवेयर अपलोड करने के साधन के रूप में चुना है, आपको इसके चालक को कॉन्फ़िगर करना चाहिए ताकि यह हमारे नियंत्रक के साथ काम करे। ब्लू पिल बोर्ड में एक पूर्ण JTAG कनेक्टर नहीं है जो पूर्ण JTAG प्रोटोकॉल का उपयोग करके काम कर सकता है। इसके बजाय, हम इसके सरलीकृत मोड का उपयोग करेंगे, जिसे SWD कहा जाता है। यह JTAG मोड केवल तीन लाइनों का उपयोग करता है। ये GND, SWDCLK और SWDIO हैं। डिफ़ॉल्ट रूप से, पूर्ण JTAG मोड सक्षम है, इसलिए हमें इसे SWD में बदलने और कोर आवृत्ति को 72MHz पर सेट करने की आवश्यकता है।
श्रेणी सूची में, ST-LINK का चयन करें और इंटरफ़ेस समूह में SWD में विकल्प बदलें।

अब आप ठीक क्लिक कर सकते हैं, हमारी परियोजना कॉन्फ़िगर की गई है।

चित्र 9. ST-LINK ड्राइवर को कॉन्फ़िगर करना

अब यह अंतिम, लेकिन बहुत महत्वपूर्ण कार्य है, इससे पहले कि हम अपना पहला कार्यक्रम संकलित करें। आपको टेम्प्लेट से प्रोजेक्ट में फ़ाइलें जोड़ने की आवश्यकता है।

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

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

हम प्रत्येक निर्देशिका के लिए प्रोजेक्ट टेम्पलेट से समूह बनाएंगे और टेम्पलेट फ़ाइलों को वहां रखेंगे।

सबसे पहले, विन्यास समूह बनाएँ और उसमें stm32f10x_conf.h फ़ाइल को निर्देशिका निर्देशिका से डालें।
ऐसा करने के लिए, कार्यस्थान विंडो में प्रोजेक्ट नाम पर राइट-क्लिक करें और ड्रॉप-डाउन मेनू में Add → Add Group चुनें। समूह का नाम कॉन्फ़िगर करें।

इस समूह में फ़ाइलें जोड़ने के लिए, इस पर राइट-क्लिक करें और Add → Add फ़ाइलें चुनें। खुलने वाली विंडो में, कॉन्फ़िगर फ़ोल्डर खोलें और stm32f10x_conf.h फ़ाइल चुनें।

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

चित्रा 11. एक खाली और पूरी तरह से कॉन्फ़िगर परियोजना का पूरा दृश्य

अब यह परियोजना आगे के विकास के लिए पूरी तरह से तैयार है।

सिद्धांत की बिट

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

माइक्रोकंट्रोलर, मल्टीथ्रेडिंग के आयोजन के लिए, थ्रेडएक्स या फ्रीआरटीओएस जैसे रियल टाइम ऑपरेटिंग सिस्टम (आरटीओएस) का उपयोग करते हैं। वे सभी आपको कई ऐसे चक्र बनाने की अनुमति देते हैं जिनमें एक के बाद एक कार्य निष्पादित होते हैं, केवल एक ही समय में चक्र काम करते हैं। कई Arduins की तरह एक माइक्रोकंट्रोलर में घुसा।

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

RTOS प्रत्येक थ्रेड के लिए एक छोटा समय अंतराल आवंटित करता है। इस अंतराल के बाद, आरटीओएस अगली धारा में बदल जाता है (इससे कोई फर्क नहीं पड़ता कि पिछले एक ने अपने कार्यों को पूरा किया है या नहीं) और इसी तरह। विभिन्न धाराएँ अपनी प्राथमिकता के आधार पर अलग-अलग समय अंतराल प्राप्त कर सकती हैं। इस तरह के मल्टीथ्रेडिंग को बाहर भीड़ कहा जाता है।

थोड़े समय के अंतराल के लिए प्रवाह को नियंत्रित करने और उन पर नियंत्रण स्थानांतरित करने के लिए, आरटीओएस घटक, जिसे "अनुसूचक" कहा जाता है, जिम्मेदार है।

नौसिखिए प्रोग्रामर के लिए stm32 के विशाल और जटिल बाह्य उपकरणों को तुरंत मास्टर करना मुश्किल है और साथ ही साथ आरटीओएस भी सीखते हैं।

सौभाग्य से, आरटीओएस के बिना बहु-थ्रेडेड एप्लिकेशन बनाने के तरीके बिल्कुल भी नहीं हैं। इसके लिए, हमारी सहायता के लिए "सहकारी बहुआयामी" आता है। सहकारी मल्टीथ्रेडिंग आपको आरटीओएस की भागीदारी के बिना अपेक्षाकृत छोटे मल्टीथ्रेडेड प्रोजेक्ट करने की अनुमति देता है।

सहकारी मल्टीथ्रेडिंग का सार क्या है? इस तरह के मल्टीथ्रेडिंग के साथ, प्रत्येक थ्रेड में उतना ही प्रोसेसर समय लगता है जितना इसकी आवश्यकता होती है, लेकिन एक बार में इसके संपूर्ण कार्य को पूरा करने के लिए पर्याप्त नहीं है। यह सहकारी बहु-थ्रेडेड अनुप्रयोगों की लेखन शैली के लिए बहुत कठोर आवश्यकताओं को सामने रखता है।

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

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

सहकारी बहु-थ्रेडेड अनुप्रयोग संरचना

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

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

Stm32 माइक्रोकंट्रोलर्स के साथ काम करने के कई वर्षों के लिए, मैंने एक सहकारी बहु-थ्रेडेड एप्लिकेशन की कुछ संरचना विकसित की है, जिसे मैं आपको पेश करना चाहता हूं।

प्रत्येक स्ट्रीम एक अलग मॉड्यूल (हेडर फ़ाइल और कोड फ़ाइल) है।

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

void XXX_Init(); void XXX_Control();

XXX_Init () फ़ंक्शन को मुख्य लूप में मुख्य फ़ंक्शन () फ़ंक्शन से पहले कहा जाता है, और XXX_Control () फ़ंक्शन को मुख्य फ़ंक्शन के मुख्य लूप में कहा जाता है।

 void main() { //   XXX XXX_Init(); //   YYY YYY_Init(); //   ZZZ ZZZ_Init(); while(true){ XXX_Control(); YYY_Control(); ZZZ_Control(); } }

XXX मॉड्यूल फ़ाइल इस तरह दिख सकती है:

xxx.c

 #include "xxx.h" #define XXX_WATER_MAX_THRESHOLD 100500 #define XXX_WATER_MIN_THRESHOLD 9000 typedef enum{ idle, state1, state2, : stateX, }XXX_States; static XXX_States xxxCurrentState = idle; static int xxxToiletWaterLevel=0; //---------    -------- void private_init1() { } void private_init2() { } void private_measureLevel() { } void private_flush() { } void private_superFlush() { } //--------    --------- void XXX_Init() { xxxCurrentState=idle; } void XXX_Reset() { private_superFlush(); xxxCurrentState=idle; } void XXX_Control() { switch(xxxCurrentState) { case idle: private_measureLevel(); if(xxxToiletWaterLevel>XXX_WATER_MIN_THRESHOLD) xxxCurrentState=state1; break; case state1: if(xxxToiletWaterLevel<XXX_WATER_MAX_THRESHOLD) { private_flush(); xxxCurrentState=idle; } else xxxCurrentState=state2; break; case state2: //   break; } }

सहकारी बहु-थ्रेडेड अनुप्रयोग उदाहरण

बहुत सारगर्भित नहीं होने के लिए, आइए एक वास्तविक चुनौती की कल्पना करें। मान लें कि हमारे पास एक धारा है जो एक एलईडी (प्रति सेकंड दो बार) चमकती है, जो एक कैथोड द्वारा पीसी 13 पोर्ट से जुड़ी है। हमारे पास एक स्ट्रीम भी है जो सीरियल पोर्ट के माध्यम से कमांड प्राप्त करता है। यदि चरित्र '0' (0x30) आता है, तो पलक झपकना बंद हो जाता है और ग्राहक को एक '-' चिन्ह भेज दिया जाता है। यदि चरित्र '1' (0x31) आता है, तो पलक झपकती है और चरित्र '*' क्लाइंट को वापस कर दिया जाता है। किसी भी अन्य कुंजी को दबाने से चरित्र 'E' लौटता है।

हम एलईडी फ्लैशिंग के नियंत्रण प्रवाह को modLed.h और modLed.c फाइलों में रखेंगे। यह धागा शुरू में निष्क्रिय अवस्था में है और कुछ भी नहीं करता है। हालाँकि, इसका सार्वजनिक कार्य MODLED_command, जब modled_on तर्क प्राप्त होता है, स्ट्रीम की स्थिति पर स्विच करता है
modled_st_on। इस स्थिति में, स्ट्रीम एलईडी को रोशनी देता है, Global_count काउंटर के प्रारंभिक मूल्य को याद करता है, और स्टैंडबाय स्थिति modled_st_wait1 में प्रवेश करता है। इस स्थिति में, यह लगातार global_count काउंटर के वर्तमान मूल्य की जांच करता है, और जब चालू खाते और प्रारंभिक खाते के बीच अंतर MODLED_BLINK_DELAY_ON होता है, तो स्ट्रीम modled_st_off अवस्था में बदल जाता है। इस स्थिति में, स्ट्रीम एलईडी बंद कर देता है, खाते के वर्तमान मूल्य को याद रखता है और modled_st_wait2 स्थिति पर स्विच करता है। इस स्थिति में, थ्रेड प्रारंभ के साथ global_count काउंटर के वर्तमान मान की तुलना करता है, और जब अंतर MODLED_BLINK_DELAY_OFF होता है, तो यह modled_st_on स्थिति में चला जाता है। और इसलिए यह तब तक जारी रहेगा जब तक कोई modled_off तर्क के साथ MODLED_command फ़ंक्शन को कॉल नहीं करता। फिर, फ़ंक्शन स्ट्रीम की स्थिति को modled_st_clamp में बदल देगा। धागा एलईडी को बंद कर देगा और modled_st_idle स्थिति में चला जाएगा।

मॉडल्ड स्ट्रीम का प्रारंभ मुख्य फ़ंक्शन में MODLED_init () फ़ंक्शन को कॉल करके शुरू होता है। यह फ़ंक्शन GPIOC पोर्ट को प्रारंभ करता है और स्ट्रीम की प्रारंभिक स्थिति सेट करता है। फिर, लूप में, MODLED_control () फ़ंक्शन को लगातार कहा जाता है, जो एक पुनरावृत्ति में वर्तमान स्थिति की जांच करता है और इसके लिए छोटे कार्य करता है।

सीरियल पोर्ट नियंत्रण प्रवाह समान है।

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

प्रारंभ में, moduart स्ट्रीम moduart_st_idle स्थिति में होती है, जिसमें यह एक बाइट प्राप्त होने की प्रतीक्षा कर रही है। जैसे ही एक बाइट प्राप्त होता है और एक चर में संग्रहीत होता है, इंटरप्ट हैंडलर स्ट्रीम की स्थिति को moduart_st_command में बदल देता है और स्ट्रीम प्राप्त बाइट को चेक करता है। यदि प्राप्त बाइट '0' कमांड है, तो MODLED_command फ़ंक्शन को modled_off तर्क और '-' वर्ण के साथ लौटाया जाता है। यदि प्राप्त बाइट '1' कमांड है, तो MODLED_command फ़ंक्शन को modled_on तर्क के साथ कहा जाता है और '*' वर्ण वापस आ जाता है। अन्य मामलों में, चरित्र 'ई' बस वापस आ गया है।

MODUART_init () फ़ंक्शन को कॉल करके MODUART स्ट्रीम का प्रारंभ मुख्य फ़ाइल में भी होता है। यह फ़ंक्शन पोर्ट और परिधीय मॉड्यूल USART1 को आरंभ करता है और स्ट्रीम को स्टैंडबाय मोड में डालता है। मुख्य लूप में, स्ट्रीम MODUART_control () का नियंत्रण फ़ंक्शन कहा जाता है, जो वर्तमान स्थिति की जांच करता है और इसके प्रसंस्करण से जुड़े कोड के एक छोटे टुकड़े को निष्पादित करता है।

प्रत्येक राज्य के लिए कोड के छोटे टुकड़े करने के लिए सहकारी बहु-थ्रेडेड अनुप्रयोगों का संपूर्ण रहस्य ठीक है।

Global_count चर

संभवतः इस global_count चर के बारे में एक अलग चर्चा के लायक है।

स्टार्टअप \ startup_stm32f10x_md.s इनिशियलाइज़ेशन फ़ाइल में एक माइक्रोकंट्रोलर इंटरप्ट टेबल होता है। इसमें सभी परिधीय अवरोधों के लिए हैंडलर के पते शामिल हैं
और गुठली। हालाँकि, परिधि में व्यवधान केवल तब होता है जब परिधि प्रारंभिक होती है। इसलिए, शुरू में, हैंडलर अस्थायी स्टब को इंगित करते हैं। लेकिन कॉर्टेक्स एम 3 कर्नेल बाधा हैंडलर वास्तव में मौजूद हैं और सिस्टम \ stm32f10x_it फ़ाइल में निहित हैं। ऐसा ही एक व्यवधान SysTick सिस्टम टाइमर का रुकावट है। इस टाइमर का उपयोग RTOS द्वारा कार्य शेड्यूलर को लागू करने के लिए किया जाता है। लेकिन, मैं इसका उपयोग टाइमिंगडेले_डेकमेंट फ़ंक्शन को कॉल करने के लिए करता हूं, जो वास्तव में मुख्य फ़ाइल में परिभाषित किया गया है।

 //------------------------------------------------------------------- //   volatile unsigned long global_count=0; //       SysTick,  //    stm32f10x_it.c void TimingDelay_Decrement(void) { //    global_count++; if (TimingDelay != 0x00) { TimingDelay--; } }

मुख्य समारोह की शुरुआत में SysTick टाइमर आवृत्ति को 1 एमएस पर सेट किया जा रहा है। इसलिए,
SysTick बीच हैंडलर में सेकंड के हर हजारवें हिस्से पर काउंटर बढ़ेगा।

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

उपसंहार

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

इंटरनेट पर पाए जाने वाले अन्य समान "एलईडी पर एलईडी की चमकती रोशनी" की तुलना में, जो कि खदानों के बजाय खदान के रूप में निकली हैं। हालाँकि, इस तरह के खाके पर, मैं नई और जटिल परियोजनाएँ शुरू करता हूँ और 2-5 मिनट बिताने से यह नहीं लगता कि यह मेरे लिए इतना भयानक नुकसान है।

ModLed.h फ़ाइल का स्रोत कोड

ModLed.h फ़ाइल

 #ifndef __MODLED_H #define __MODLED_H #include "stm32f10x.h" typedef enum{ modled_off, modled_on, }MODLED_Commands; void MODLED_init(); void MODLED_command(MODLED_Commands aCmd); void MODLED_control(); #endif

ModLed.c फ़ाइल का स्रोत कोड

ModLed.c फ़ाइल

 #include "modLed.h" #include "main.h" //      #define MODLED_BLINK_DELAY_ON 250 #define MODLED_BLINK_DELAY_OFF 250 //   typedef enum{ modled_st_idle, modled_st_on, modled_st_wait1, modled_st_off, modled_st_wait2, modled_st_clamp, }MODLED_States; //  ,    1  . extern unsigned long global_count; static MODLED_States modledState=modled_st_idle; static uint32_t modledStart, modledEnd; /* PC13 - led (Open drain) */ void modled_init_gpio() { //    GPIOC RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); GPIO_DeInit(GPIOC); GPIO_InitTypeDef gpio; GPIO_StructInit(&gpio); /*  Blue Pill    ,   PC13. :  PC13      (3 )           .    . */ //   ,  . gpio.GPIO_Mode=GPIO_Mode_Out_OD; gpio.GPIO_Speed=GPIO_Speed_2MHz; gpio.GPIO_Pin=GPIO_Pin_13; GPIO_Init(GPIOC, &gpio); //   GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_SET); } void MODLED_init() { modled_init_gpio(); modledState=modled_st_idle; modledStart=global_count; } //   . void MODLED_command(MODLED_Commands aCmd) { switch(aCmd) { case modled_on: modledState=modled_st_on; break; case modled_off: modledState=modled_st_clamp; break; } } void MODLED_control() { switch(modledState) { case modled_st_idle: break; case modled_st_on: //     GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_RESET); //     modledStart=global_count; //       modledState=modled_st_wait1; break; case modled_st_wait1: //    modledEnd=global_count; //           if((modledEnd-modledStart)>=MODLED_BLINK_DELAY_ON) { //         modledState=modled_st_off; } break; case modled_st_off: //   GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_SET); //     modledStart=global_count; //       modledState=modled_st_wait2; break; case modled_st_wait2: //    modledEnd=global_count; //           if((modledEnd-modledStart)>=MODLED_BLINK_DELAY_OFF) { //         modledState=modled_st_on; } break; case modled_st_clamp: //       GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_SET); modledState=modled_st_idle; break; default: modledState=modled_st_idle; } }

ModUart.h फ़ाइल का स्रोत कोड

ModUart.h फ़ाइल

 #ifndef __MOD_UART_H #define __MOD_UART_H #include "stm32f10x.h" void MODUART_init(); void MODUART_control(); #endif

ModUart.c फ़ाइल का स्रोत कोड

ModUart.c फ़ाइल

 #include "modUart.h" #include "modLed.h" #define MODUART_BAUDRATE 115200 typedef enum{ moduart_st_idle, moduart_st_command, }MODUART_STATES; static MODUART_STATES moduartState=moduart_st_idle; static uint16_t moduartCmd=0; /* PA9 UART1_TX PA10 UART1_RX */ void moduart_init_gpio() { //RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); //    GPIOA RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); GPIO_InitTypeDef gpio; GPIO_StructInit(&gpio); gpio.GPIO_Mode=GPIO_Mode_AF_PP; gpio.GPIO_Speed=GPIO_Speed_2MHz; gpio.GPIO_Pin=GPIO_Pin_9; GPIO_Init(GPIOA, &gpio); gpio.GPIO_Mode=GPIO_Mode_IN_FLOATING; gpio.GPIO_Pin=GPIO_Pin_10; GPIO_Init(GPIOA, &gpio); } void moduart_init_uart1() { //     UART1 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); USART_InitTypeDef uart; USART_StructInit(&uart); uart.USART_BaudRate=MODUART_BAUDRATE; uart.USART_HardwareFlowControl=USART_HardwareFlowControl_None; uart.USART_Mode=USART_Mode_Rx|USART_Mode_Tx; uart.USART_Parity=USART_Parity_No; uart.USART_StopBits=USART_StopBits_1; uart.USART_WordLength=USART_WordLength_8b; USART_Init(USART1, &uart); //     // --     USART1 USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); //         NVIC_EnableIRQ(USART1_IRQn); //   USART1. USART_Cmd(USART1, ENABLE); } //    USART1 void USART1_IRQHandler() { //    if(USART_GetITStatus(USART1, USART_IT_RXNE)!=RESET) { //    USART_ClearITPendingBit(USART1, USART_IT_RXNE); //    moduartCmd = USART_ReceiveData(USART1); moduartState = moduart_st_command; } } void moduart_processCmd() { //   uint16_t r = 'E'; switch(moduartCmd) { //    case '0': { MODLED_command(modled_off); r = '-'; } break; //    case '1': { MODLED_command(modled_on); r = '*'; } break; } //    USART_SendData(USART1, r); moduartCmd=0; } void MODUART_init() { moduartState=moduart_st_idle; moduart_init_gpio(); moduart_init_uart1(); } void MODUART_control() { switch(moduartState) { case moduart_st_idle: break; case moduart_st_command: moduart_processCmd(); moduartState=moduart_st_idle; break; default: moduartState=moduart_st_idle; } }

Main.c फ़ाइल का स्रोत कोड

फ़ाइल main.c

 #include "main.h" #include "modUart.h" #include "modLed.h" // Imported value static __IO uint32_t TimingDelay; RCC_ClocksTypeDef RCC_Clocks; int main() { RCC_GetClocksFreq(&RCC_Clocks); //   SysTick      SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000); //    MODLED_init(); //     MODUART_init(); do{ //      MODLED_control(); //      MODUART_control(); }while(1); #pragma diag_suppress=Pe111 return 0; } //------------------------------------------------------------------- void Delay(__IO uint32_t nCount) { TimingDelay = nCount; while(TimingDelay != 0); } //------------------------------------------------------------------- //   volatile unsigned long global_count=0; //       SysTick,  //    stm32f10x_it.c void TimingDelay_Decrement(void) { //    global_count++; if (TimingDelay != 0x00) { TimingDelay--; } } //------------------------------------------------------------------- #ifdef USE_FULL_ASSERT void assert_failed(uint8_t *file, uint32_t line) { while(1){} } #endif

पूरा प्रोजेक्ट यहां से डाउनलोड किया जा सकता है ।

Stm32 माइक्रोकंट्रोलर अनुप्रयोग विकास का एक संक्षिप्त परिचय