🚖 🐲 🖐🏿 IAR पर्यावरण में Atmega16 C microcontroller के प्रोग्रामिंग और JTAG डिबगिंग, भाग 1 👱 🐔 🙏🏾

परिचय

मेरी राय में, दुनिया में मौजूद लगभग किसी भी माइक्रोकंट्रोलर को प्रोग्राम करने के लिए जल्दी से सीखने के लिए, आपको तकनीकी दस्तावेज का अध्ययन करने के अलावा, सी भाषा को मास्टर करने और JTAG डीबगिंग का उपयोग करने की आवश्यकता है। मैं अपने विचार समझाऊंगा। सी भाषा संकलक लगभग सभी मौजूदा माइक्रोकंट्रोलर के लिए मौजूद हैं। इसलिए, भाषा सी ने लंबे समय तक खुद को एक क्रॉस-प्लेटफॉर्म असेंबलर के रूप में स्थापित किया है। उनका ज्ञान माइक्रोकंट्रोलर्स के प्रत्येक नए परिवार के लिए विधानसभा निर्देश सीखने की आवश्यकता को समाप्त करता है। JTAG डिबगिंग, बदले में, न केवल इन-सर्किट त्रुटि खोज की संभावना प्रदान करता है, बल्कि अंदर से माइक्रोकंट्रोलर का अध्ययन करने में भी मदद करता है। मुझे लगता है कि यह सभी के लिए स्पष्ट है कि जब हम केवल साधारण माइक्रोकंट्रोलर को डिबग किए बिना प्रोग्राम करते हैं, तो हम इनपुट और आउटपुट के साथ एक ब्लैक बॉक्स के रूप में सिस्टम के अध्ययन से संपर्क करते हैं। यह दृष्टिकोण, विशेष रूप से प्रारंभिक चरण में, सीखने को कठिन बनाता है। दूसरी ओर, JTAG « आपको अंदर जाने की अनुमति देता है, देखें कि प्रोग्राम को चरणों में कैसे निष्पादित किया जाता है, देखें कि मेमोरी और रजिस्टरों में क्या होता है, ब्रेकपॉइंट्स के लिए उत्तेजना शुरू करें और प्रोग्राम के असंतुष्ट संस्करण को निष्पादित करें। यह सुविधा आपको सीखने में काफी तेजी लाने की अनुमति देती है।

AVR, STM8, MSP430, AVR32, STM32, EFM32, रेनेसस RX जैसे माइक्रोकंट्रोलर्स में JTAG इंटरफ़ेस का उपयोग करके C भाषा संकलनकर्ता और डीबगिंग हैं। इन कई अन्य माइक्रोकंट्रोलर के लिए एकल क्रॉस-प्लेटफॉर्म वातावरण एंबेडेड वर्कबेंच है। हालांकि पर्यावरण को भुगतान किया जाता है, यह 30-दिन के मुफ्त संस्करण या कोड आकार की सीमा वाले संस्करण का उपयोग करना संभव है। महीने के एक नए परिवार के शुरुआती अध्ययन के लिए काफी पर्याप्त हो सकता है। फिर आप परिवार के बारे में अपना मन बना सकते हैं और इसके साथ नि: शुल्क साधनों पर काम करना जारी रखने का निर्णय ले सकते हैं या छोटी परियोजनाओं के लिए उस कोड के संस्करण का उपयोग कर सकते हैं जो आकार में सीमित है। बड़े वाणिज्यिक उत्पादों के लिए, आप इस माध्यम को भी खरीद सकते हैं।

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

नीचे चर्चा किए गए उदाहरणों के लिए, मैंने AVR को चुना, क्योंकि यह माइक्रोकंट्रोलर दुनिया में सबसे लोकप्रिय परिवार है। मुझे लगता है कि इसे शुरू करना आसान है, लेकिन आपको इसे अपने तक सीमित नहीं रखना चाहिए।

एक JTAG डिबगर का चयन करना

C में लिखे गए प्रोग्राम के इन-सर्किट डिबगिंग के लिए, हमें AVR माइक्रोकंट्रोलर्स के लिए JTAG डिबगर की आवश्यकता है। सबसे सस्ती और आसान निर्माण AVR JTAGICE मालिकाना डिबगर के क्लोन हैं। इस तरह के क्लोन को ईबे के साथ कम कीमत पर ऑर्डर किया जा सकता है। गुणवत्ता एक लॉटरी की तरह है।

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

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

]

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

फर्मवेयर को AVR स्टूडियो 4 के इंस्टॉलेशन फ़ोल्डर में पाया जा सकता है या यहां डाउनलोड किया जा सकता है ।

ऊपर वर्णित JTAGICE क्लोन का नुकसान यह है कि वे AVR स्टूडियो 6 में समर्थित नहीं हैं। हालाँकि, AVR स्टूडियो 4 के पुराने संस्करण और AVR के लिए IAR के पुराने और नए संस्करणों में, इन क्लोनों को अच्छी तरह से समर्थन प्राप्त है।

बाद में लिखे गए सी कोड उदाहरणों को डीबग करने के लिए, मैंने इस योजना के अनुसार बने क्लोन का उपयोग किया। इसमें MAX3232 चिप ADM3202 के लिए एक प्रतिस्थापन है, जो सार को नहीं बदलता है।

JTAGICE का यह क्लोन मुझे विरासत में मिला था। मुझे काम पर इलेक्ट्रॉनिक कचरे के साथ एक बॉक्स में मिला। यह काम नहीं किया, और मैंने इसे फिर से शुरू करने का फैसला किया। आपको एक विशेष एडाप्टर बनाने की आवश्यकता क्यों थी, क्योंकि, जैसा कि फोटो में देखा जा सकता है, Atmega16L प्रोग्रामिंग के लिए AVR ISP कनेक्टर आकार को कम करने के लिए आउटपुट नहीं है। फर्मवेयर के बाद, JTAGICE ने "जीवनकाल" अर्जित किया और प्राप्त किया।

अब जब COM पोर्ट अप्रचलित हो गया है, तो मैंने "पुराने दोस्त" को नहीं छोड़ा और USB-to-RS-232 केबल कनवर्टर खरीदा।

डिबग बोर्ड

डिबग बोर्ड के रूप में, मैं एक डिजिटल थर्मामीटर का उपयोग करूंगा जिसे मैंने ब्रेडबोर्ड पर इकट्ठा किया था। बोर्ड यूएसबी द्वारा संचालित है, कोर एक डीआईपी पैकेज में एक एटमेगा 16 माइक्रोकंट्रोलर है। माइक्रोकंट्रोलर को 16 मेगाहर्ट्ज की आवृत्ति के साथ एक क्वार्ट्ज गुंजयमान यंत्र से देखा जाता है और निष्क्रिय घटकों के न्यूनतम आवश्यक सेट (क्वार्ट्ज के लिए 22 पीएफ कैपेसिटर, पावर को रीसेट लाइन खींचने के लिए 10 kΩ रोकनेवाला, शक्ति के लिए 0.1 μF कैपेसिटर) के साथ बांधा जाता है। माइक्रोकंट्रोलर के मानक प्रोग्रामिंग और डिबगिंग के लिए, दो मानक छह-पिन AVR ISP और दस-पिन AVR JTAG सॉकेट स्थापित हैं। बोर्ड में एक एनालॉग तापमान सेंसर, तीन अंकों का स्टैटिक सात-सेगमेंट संकेतक और एक अतिरिक्त एलईडी है। संकेत एलईडी और संकेतक खंड 500 ओम के वर्तमान-सीमित प्रतिरोधों के माध्यम से माइक्रोकंट्रोलर से जुड़े हैं। तीन सात-खंड संकेतकों में से प्रत्येक पोर्ट ए, बी और डी में से छह के माध्यम से टर्मिनलों से जुड़ा हुआ है। एलईडी पोर्ट डी के 7 वें पिन से जुड़ा है। एनालॉग सेंसर आउटपुट पोर्ट ए के 7 वें पिन से जुड़ा है (बिल्ट-इन एडीसी का 7 वां चैनल) )।

सभी तत्वों को MGTF तार द्वारा टांका गया था।

IAR विकास पर्यावरण

लेखन और डिबगिंग कार्यक्रमों के लिए, हम Atmel AVR वातावरण के लिए IAR एंबेडेड वर्कबेंच का उपयोग करेंगे, अर्थात् इसका मुफ्त संस्करण 4 के कोड आकार की सीमा के साथ होगा। एवीआर परिवार के माइक्रोकंट्रोलर्स के लिए सी भाषा में छोटी परियोजनाओं के लिए, यह काफी पर्याप्त है।

आइए, यहां पढ़ें और पढ़ें कि मौजूदा समय में AVAR के लिए IAR का नवीनतम संस्करण क्या प्रदान करता है। JTAGICE डिबगर ऊपर उल्लेखित है, पहले की तरह समर्थित है।

समर्थित परिवारों की सूची में मेगाएवीआर शामिल है।

यह सुनिश्चित करने के बाद कि हमारे JTAG डिबगर और डिबग बोर्ड चलते हैं, IAR डाउनलोड करें ।

इंस्टॉलर आपको किकस्टार्ट लाइसेंस के साथ पंजीकरण करने की अनुमति देता है।

स्थापना के बाद, IAR को पंजीकृत करने के लिए, आपको पंजीकरण फॉर्म भरना होगा।

प्रश्नावली भरने के बाद, एक कुंजी आपके मेल पर आ जाएगी, जिसे दर्ज करके हम समय में एक मुफ्त पंजीकृत किकस्टार्ट संस्करण असीमित प्राप्त करेंगे।

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

भाषा चुनने के बाद, हम एक पूरी तरह से लगभग खाली स्रोत-फ़ाइल देखेंगे।

आइए हमारी परियोजना की सेटिंग पर जाएं। क्योंकि हम Atmega16 के लिए प्रोग्राम लिखेंगे, हम कॉलम प्रोसेसर कॉन्फ़िगरेशन में इस माइक्रोकंट्रोलर का चयन करेंगे।

डीबगर मेनू आइटम में, JTAGICE का चयन करें।

मेनू आइटम डीबगर-> जेटजीस में, COM पोर्ट नंबर चुनें, जिसमें डीबगर जुड़ा हुआ है।

पर्यावरण पुस्तकालयों में माइक्रोकंट्रोलर के परिधीय रजिस्टरों के महत्वपूर्ण बिट्स की परिभाषाओं के सही संचालन के लिए, आपको भी डाल देना चाहिए

सामान्य विकल्प-> सिस्टम मेनू आइटम में I / O- फ़ाइलें शामिल करें चेकबॉक्स में थोड़ी परिभाषाएँ सक्षम करें।

प्रोग्रामिंग और डिबगिंग

उदाहरणों का वर्णन शुरू करने से पहले, IAR पर्यावरण की कुछ विशेषताओं की व्याख्या करना आवश्यक है। Iom16.h हेडर फ़ाइल, जिसमें Atmega16 के लिए रजिस्टर एड्रेस परिभाषाएँ शामिल हैं, में मैक्रोज़ हैं जो आपको परिधीय रजिस्टर के विशिष्ट बिट्स तक पहुंचने की अनुमति देते हैं, निम्नानुसार हैं:

... * Examples of how to use the expanded result: * TCCR2 |= (1<<5); * or if ENABLE_BIT_DEFINITIONS is defined * TCCR2 |= (1<<COM21); * or like this: * TCCR2_Bit5 = 1; * or like this: * TCCR2_COM21 = 1; ***************************************************************************/

वास्तव में, आप इनमें से किसी भी विकल्प का उपयोग कर सकते हैं। और यहां विकल्प, वास्तव में, एक विशेष विकल्प का उपयोग करने की सुविधा है और जो लिखा गया है उसकी बाद की समझ की सरलता है।

IAR वातावरण में, __delay_cycles (x) अंतर्निहित विलंब फ़ंक्शन का उपयोग करना संभव है, जहां एक्स टिक में देरी का समय है। हमारे मामले के लिए, एक घड़ी चक्र द्वारा देरी 1/16000000 = 62.5 एनएस है।

अब जब हम इन दो बिंदुओं को जानते हैं, तो हम पहले उदाहरण पर आगे बढ़ सकते हैं, जहां एलईडी केवल विशेष रूप से या का उपयोग करके झपकाता है।

 /*  */ #include <ioavr.h> #include <intrinsics.h> /* */ //  #define F_CPU 16000000 /*  */ //   #define DELAY_US(us) __delay_cycles((F_CPU / 1000000) * (us)); //   #define DELAY_MS(ms) __delay_cycles((F_CPU / 1000) * (ms)); /*  */ //   void main( void ) { //   //  // 7-   D   DDRD_DDD7 = 1; // 7-   D   "0" PORTD_PORTD7 = 0; //   for(;;) { // 7-   D  "0"  "1"   "1"  "0" //    PORTD_PORTD7 ^= 1; //    DELAY_MS(1000); }//end for }

आवश्यक अवधि की देरी के गठन को सरल बनाने के लिए, देरी मैक्रो फ़ंक्शंस DELAY_US (us) और DELAY_MS (ms) बनाए जाते हैं, जो आपको देरी चक्र में नहीं, बल्कि माइक्रोसेकंड और मिलीसेकंड में तुरंत सेट करने की अनुमति देते हैं। अगला, हम मुख्य () कार्यक्रम के मुख्य फ़ंक्शन पर जाएंगे, जिसमें हम माइक्रोकंट्रोलर को चालू करने या रीसेट के बाद प्राप्त करते हैं। यह तर्कसंगत है कि स्विच करने के बाद हमें जो पहली चीज करनी चाहिए वह यह है कि हमारे मामले में ऑपरेशन के लिए आवश्यक परिधीय ब्लॉकों को कॉन्फ़िगर करना है, यह केवल पोर्ट डी का एक पिन है। इसे पिन करने के लिए कॉन्फ़िगर करने के लिए, बस एक से डीडीआरडी डेटा दिशा का डीडी 7 बिट सेट करें। पैर पर "1" (5 V) सेट करने के लिए, PORTD डेटा रजिस्टर में PORTD7 बिट सेट करना आवश्यक है, पैर में "0" (जमीन) सेट करने के लिए, PORTD7 बिट को रीसेट करना होगा। आप इसके बारे में अधिक डेटाशीट में पढ़ सकते हैं।

बिटर्ज़ डिस्जंक्शन और कंजंक्शन (DDRD | = 0x01, DDRD & = ~ 0x01, DDRD = = (1 << 0), बिना कंट्रोलर DDRD और PORTD के बिट्स सेट करने और लिखने के लिए (DDRD = 0x01, DDRD = 0x00) बस लिखना अवांछनीय है। DDRD & = ~ (1 << 0)), क्योंकि यदि यह रजिस्टर में शेष बिट्स को मिटाता है जो इस ऑपरेशन से पहले सेट किए गए थे। इसे समझना जरूरी है।

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

मुख्य अनंत लूप में, बिटवाइज़ ऑपरेशन को छोड़कर या उपयोग करके "0" से "1" तक निरंतर स्विचिंग होती है, फिर "1" से "0" तक। यह एक सेकंड की देरी के साथ होता है, जो मैक्रो फ़ंक्शन DELAY_MS (एमएस) द्वारा प्रदान किया जाता है।

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

दूसरा उदाहरण भी एक निमिष एलईडी है, लेकिन अतिरिक्त मैक्रो फ़ंक्शन के उपयोग के साथ।

 /*  */ #include <ioavr.h> #include <intrinsics.h> /* */ //  #define F_CPU 16000000 //    #define DELAY_TIME 1000 //     //  #define LED_DDR DDRD #define LED_PORT PORTD #define LED_PIN DDD7 /*  */ //   #define LED_INIT() ( LED_DDR |= (1<<LED_PIN) ); //  #define LED_LOW() ( LED_PORT &=~ (1<<LED_PIN) ); //  #define LED_HIGH() ( LED_PORT |= (1<<LED_PIN) ); //  #define LED_TOG() ( LED_PORT ^= (1<<LED_PIN) ); //   #define DELAY_US(us) __delay_cycles((F_CPU / 1000000) * (us)); //   #define DELAY_MS(ms) __delay_cycles((F_CPU / 1000) * (ms)); /*  */ //   void main( void ) { //   //  LED_INIT(); //  LED_LOW(); //   for(;;) { //  LED_TOG(); //    DELAY_MS(DELAY_TIME); }//end for }

मैक्रो फ़ंक्शन दृष्टिकोण दो तरह से सुविधा प्रदान करता है। पहला है बेहतर कोड पठनीयता प्रदान करना। दूसरा संभावित सुधारों का सरलीकरण है। अब, यदि एलईडी को किसी अन्य पोर्ट के किसी अन्य पिन में पुन: कॉन्फ़िगर किया जाना है, तो यह LED_DDR, LED_PORT, LED_PIN की तीन परिभाषाओं को बदलने के लिए पर्याप्त है, और पूरे प्रोग्राम टेक्स्ट में सुधार नहीं करें। पुस्तकालयों को लिखते समय, यह जीवन को सरल बनाता है।

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

 /*  */ #include <ioavr.h> #include <intrinsics.h> /* */ //  #define F_CPU 16000000 //    #define DELAY_TIME_LF 1000 #define DELAY_TIME_AF 500 #define DELAY_TIME_HF 100 //     #define LIMIT_CNT_LF 4 #define LIMIT_CNT_AF 8 #define LIMIT_CNT_HF 40 //  #define UCHAR unsigned char //    #define STATE_LOW_FREQ_BLINK 0 #define STATE_AVR_FREQ_BLINK 1 #define STATE_HIGH_FREQ_BLINK 2 //     //  #define LED_DDR DDRD #define LED_PORT PORTD #define LED_PIN DDD7 /*  */ //   #define LED_INIT() ( LED_DDR |= (1<<LED_PIN) ); //  #define LED_LOW() ( LED_PORT &=~ (1<<LED_PIN) ); //  #define LED_HIGH() ( LED_PORT |= (1<<LED_PIN) ); //  #define LED_TOG() ( LED_PORT ^= (1<<LED_PIN) ); //   #define DELAY_US(us) __delay_cycles((F_CPU / 1000000) * (us)); //   #define DELAY_MS(ms) __delay_cycles((F_CPU / 1000) * (ms)); /*   */ //    UCHAR curr_state = STATE_LOW_FREQ_BLINK; //    //  UCHAR state_cnt = 0; /*  */ //   void main( void ) { //   //  LED_INIT(); //  LED_LOW(); //   for(;;) { //  switch(curr_state) { //      case STATE_LOW_FREQ_BLINK: //  LED_TOG(); //    DELAY_MS(DELAY_TIME_LF); //  state_cnt++; //     //,    if (state_cnt==LIMIT_CNT_LF) { curr_state = STATE_AVR_FREQ_BLINK; //  state_cnt = 0; }//end if break; //      case STATE_AVR_FREQ_BLINK: //  LED_TOG(); //    DELAY_MS(DELAY_TIME_AF); //  state_cnt++; //     //,    if (state_cnt==LIMIT_CNT_AF) { curr_state = STATE_HIGH_FREQ_BLINK; //  state_cnt = 0; }//end if break; //      case STATE_HIGH_FREQ_BLINK: //  LED_TOG(); //    DELAY_MS(DELAY_TIME_HF); //  state_cnt++; //     //,    if (state_cnt==LIMIT_CNT_HF) { curr_state = STATE_LOW_FREQ_BLINK; //  state_cnt = 0; }//end if break; } }//end for }

हमारे उदाहरण में, तीन राज्य STATE_LOW_FREQ_BLINK, STATE_AVR_FREQ_BLINK, STATE_HIGH_FREQ_BLINK हैं, जो क्रमशः कम आवृत्ति, मध्यम आवृत्ति और उच्च आवृत्ति के साथ एलईडी के चमकने के अनुरूप हैं। प्रत्येक राज्य का अपना विलंब मान DELAY_TIME_LF, DELAY_TIME_AF, DELAY_TIME_HF है, जो प्रत्येक राज्य पास में किया जाता है। प्रत्येक राज्य में होने की समान अवधि को LIMIT_CNT_LF, LIMIT_CNT_AF, LIMIT_CNT_HF की परिभाषाओं द्वारा प्रदान किया जाता है, जो प्रत्येक राज्य के लिए स्विचिंग पास की संख्या निर्धारित करते हैं। स्विच स्टेटमेंट करंट_स्टैट वैरिएबल के वर्तमान मूल्य के अनुसार राज्यों के बीच स्विचिंग प्रदान करता है। जब तक राज्य स्विचिंग सीमा पूरी नहीं हो जाती, तब तक प्रत्येक राज्य पास में state_cnt चर बढ़ाया जाता है। यदि कथन यह निर्धारित करता है कि स्विचिंग सीमा समाप्त हो गई है या नहीं। यदि सीमा समाप्त हो जाती है, तो अगले राज्य में एक संक्रमण होता है, राज्य_कंट पास काउंटर रीसेट हो जाता है।

डिबगिंग के तहत, अब, ऊपर वर्णित पहले से ही, व्यू-> वॉच में आप cur_state और state_cnt वैरिएबल का मान देख सकते हैं।

चौथा उदाहरण microcotroller के आठ-बिट टाइमर (TIMER0) के साथ काम करने के लिए समर्पित है। इस उदाहरण में, पोर्ट डी के 6 वें पिन से जुड़े सात-खंड सूचक खंडों में से एक का उपयोग दूसरी एलईडी के रूप में किया जाता है।

 /*  */ #include <ioavr.h> #include <intrinsics.h> #include <ina90.h> /* */ //  #define F_CPU 16000000 //   #define TCNT0_VALUE 99 //    #define T0_TICK_CNT_LIMIT 100 //  #define UINT unsigned int /*  */ //   #define DELAY_US(us) __delay_cycles((F_CPU / 1000000) * (us)); //   #define DELAY_MS(ms) __delay_cycles((F_CPU / 1000) * (ms)); /*   */ //     T0 UINT T0_tick_cnt=0; /*  */ //   void main( void ) { //   //  // 6-   D   DDRD_DDD6 = 1; // 6-   D   "0" PORTD_PORTD6 = 0; //  // 7-   D   DDRD_DDD7 = 1; // 7-   D   "0" PORTD_PORTD7 = 0; //  ( Normal) TCCR0_CS02=1;//   16 000 000  TCCR0_CS01=0;// 16 000 000  / 1024 = 15 625  TCCR0_CS00=1;// 1 / 15 625  = 0,000064  =64  TCNT0 = TCNT0_VALUE; // 156 * 0,000064 c = 0,009984 c (10 ) //      255-156 = 99 TIMSK_TOIE0=1; //      //  _SEI(); //   for(;;) { //     _NOP(); // 6-   D  "0"  "1"   "1"  "0" //    PORTD_PORTD6 ^= 1; //    DELAY_MS(500); }//end for } /*   T0  */ #pragma vector=TIMER0_OVF_vect __interrupt void ISR_TickTimer(void) { //     _NOP(); //    T0 T0_tick_cnt++; //  1  if (T0_tick_cnt >= T0_TICK_CNT_LIMIT) { //    T0 T0_tick_cnt=0; // 7-   D  "0"  "1"   "1"  "0" //    PORTD_PORTD7 ^= 1; } //   //   TCNT0=TCNT0_VALUE; }//end func

इस उदाहरण में, मुख्य () फ़ंक्शन में, एलईडी सेट करने के बाद, शून्य टाइमर सेट किया गया है, जिसमें टीसीसीआरओ नियंत्रण रजिस्टर में बिट्स सेट करना शामिल है। क्योंकि हम सामान्य टाइमर मोड का उपयोग करेंगे, फिर बिट्स WGM00 और WGM01 शून्य होना चाहिए। प्रारंभिक मूल्य पहले से ही शून्य है, इसलिए हम उन्हें स्पर्श नहीं करते हैं। बिट्स CS00, CS01, CS02 को 16 मेगाहर्ट्ज की घड़ी आवृत्ति का अधिकतम विभक्त (1024) प्राप्त करने के लिए सेट किया गया है।

विभाजित करने के बाद, हमें टाइमर की आवृत्ति 15625 हर्ट्ज मिलती है, जो 64 μ के टिक से मेल खाती है। अगर हम टिक को 156 (156 * 0.000064 c = 0.009984 c = 10 ms) से गुणा करते हैं, तो हम 10 एमएस के सबसे करीब हो जाते हैं। इसलिए, प्रत्येक 10 एमएस में एक अतिप्रवाह घटना को संसाधित करने के लिए एक बाधा पीढ़ी प्राप्त करने के लिए, गिनती 99NT0 में रजिस्टर 99 (255-156 = 99) लोड करना आवश्यक है। क्योंकि टाइमर 99 से गणना करना शुरू कर देता है, और जब यह 255 तक पहुंचता है, तो अवरोध उत्पन्न होता है, फिर हम 156 टिकों के लिए रास्ता प्राप्त करेंगे।

उदाहरण में आगे, शून्य टाइमर के अतिप्रवाह के लिए व्यवधान उत्पन्न करने के लिए, TOIE0 बिट TIMSK इंटरप्ट मास्किंग रजिस्टर में सेट किया गया है। उसके बाद, हम मैक्रो फ़ंक्शन _SEI () के साथ सभी नकाबपोश व्यवधानों का वैश्विक समाधान करते हैं।

सभी रुकावट वैक्टर की परिभाषाएँ iom16.h हेडर फ़ाइल में हैं:

 /*==============================*/ /* Interrupt Vector Definitions */ /*==============================*/ /* NB! vectors are specified as byte addresses */ #define RESET_vect (0x00) #define INT0_vect (0x04) #define INT1_vect (0x08) #define TIMER2_COMP_vect (0x0C) #define TIMER2_OVF_vect (0x10) #define TIMER1_CAPT_vect (0x14) #define TIMER1_COMPA_vect (0x18) #define TIMER1_COMPB_vect (0x1C) #define TIMER1_OVF_vect (0x20) #define TIMER0_OVF_vect (0x24) #define SPI_STC_vect (0x28) #define USART_RXC_vect (0x2C) #define USART_UDRE_vect (0x30) #define USART_TXC_vect (0x34) #define ADC_vect (0x38) #define EE_RDY_vect (0x3C) #define ANA_COMP_vect (0x40) #define TWI_vect (0x44) #define INT2_vect (0x48) #define TIMER0_COMP_vect (0x4C) #define SPM_RDY_vect (0x50)

कार्यक्रम का तर्क पहले से ही पहले उदाहरण में वर्णित है, एक सुपर साइकिल के साथ एक प्रणाली, जो मुख्य लूप और इंटरप्ट हैंडलर का अर्ध-समांतर संचालन प्रदान करता है। मुख्य लूप में, पोर्ट डी के छठे पिन को 500 एमएस की अवधि के साथ स्विच किया जाता है। शून्य लूप ओवरफ्लो द्वारा एक बाधा को संसाधित करने के लिए मुख्य लूप हर 10 एमएस से बाधित होता है। ISR_TickTimer () हैंडलर फ़ंक्शन का उपयोग करके प्रसंस्करण किया जाता है, जिसे इस घटना पर कहा जाता है। इस फ़ंक्शन में, चर T0_tick_cnt बढ़ाकर, 10 मिलीसेकंड टिकों की गणना की जाती है। जब चर T0_tick_cnt 100 तक पहुंचता है (यानी, एक सेकंड बीत चुका है), यह घटना हैंडलर में दिए गए कथन का उपयोग करके निर्धारित की जाती है। उसके बाद, चर T0_tick_cnt पोर्ट 7 के पिन 7 को स्विच करता है, जो 1000 एमएस की अवधि के साथ दूसरी एलईडी की चमक को सुनिश्चित करता है।

इस उदाहरण को डीबग करते समय, आप मुख्य लूप और इंटरप्ट हैंडलर में एक ब्रेकपॉइंट सेट कर सकते हैं।

पांचवा उदाहरण है, काम के तर्क के अनुसार, पिछले उदाहरण, लेकिन मैक्रो फ़ंक्शन का उपयोग करना।

 /*  */ #include <ioavr.h> #include <intrinsics.h> #include <ina90.h> /* */ //  #define F_CPU 16000000 //    #define DELAY_TIME 500 //     //   #define LED1_DDR DDRD #define LED1_PORT PORTD #define LED1_PIN DDD7 //     //   #define LED2_DDR DDRD #define LED2_PORT PORTD #define LED2_PIN DDD6 //      #define F_CPU_DIV_1 (0<<CS02)|(0<<CS01)|(1<<CS00) #define F_CPU_DIV_8 (0<<CS02)|(1<<CS01)|(0<<CS00) #define F_CPU_DIV_64 (0<<CS02)|(1<<CS01)|(1<<CS00) #define F_CPU_DIV_256 (1<<CS02)|(0<<CS01)|(0<<CS00) #define F_CPU_DIV_1024 (1<<CS02)|(0<<CS01)|(1<<CS00) //     #define TCNT0_VALUE 99 //     #define T0_TICK_CNT_LIMIT 100 //  #define UINT unsigned int /*  */ //    #define LED1_INIT() ( LED1_DDR |= (1<<LED1_PIN) ); //   #define LED1_LOW() ( LED1_PORT &=~ (1<<LED1_PIN) ); //   #define LED1_HIGH() ( LED1_PORT |= (1<<LED1_PIN) ); //   #define LED1_TOG() ( LED1_PORT ^= (1<<LED1_PIN) ); //    #define LED2_INIT() ( LED2_DDR |= (1<<LED2_PIN) ); //   #define LED2_LOW() ( LED2_PORT &=~ (1<<LED2_PIN) ); //   #define LED2_HIGH() ( LED2_PORT |= (1<<LED2_PIN) ); //   #define LED2_TOG() ( LED2_PORT ^= (1<<LED2_PIN) ); //    #define TIMER0_SET_CLK_DIV(x) ( TCCR0 |= x ); //     #define TIMER0_SET_CNT(x) ( TCNT0 = x ); //      #define TIMER0_OVF_INT_ON() ( TIMSK|=(1<<TOIE0) ); //   #define DELAY_US(us) __delay_cycles((F_CPU / 1000000) * (us)); //   #define DELAY_MS(ms) __delay_cycles((F_CPU / 1000) * (ms)); /*   */ //     T0 UINT T0_tick_cnt=0; /*  */ //   void main( void ) { //   //  LED1_INIT(); LED2_INIT(); //  LED1_LOW(); LED2_LOW(); //  ( Normal) TIMER0_SET_CLK_DIV(F_CPU_DIV_1024);//   16 000 000  // 16 000 000  / 1024 = 15 625  // 1 / 15 625  = 0,000064  =64  TIMER0_SET_CNT(TCNT0_VALUE); // 156 * 0,000064 c = 0,009984 c (10 ) //      255-156 = 99 TIMER0_OVF_INT_ON(); //      //  _SEI(); //   for(;;) { //     _NOP(); //   LED1_TOG(); //    DELAY_MS(DELAY_TIME); }//end for } /*   T0  */ #pragma vector=TIMER0_OVF_vect __interrupt void ISR_TickTimer(void) { //     _NOP(); //    T0 T0_tick_cnt++; //  1  if (T0_tick_cnt >= T0_TICK_CNT_LIMIT) { //    T0 T0_tick_cnt=0; //   LED2_TOG(); }//end for //   //   TIMER0_SET_CNT(TCNT0_VALUE); }//end func

शो नियंत्रण में बिट रजिस्टर शून्य TCCRO टाइमर, जब सेटिंग मैक्रो TIMER0_SET_CLK_DIV (x) का उपयोग किया जाता है, एक तर्क एक्स जो निर्धारित करता है कि आवृत्ति विभाजित किया जाएगा और घड़ी परिभाषाएँ F_CPU_DIV_1, F_CPU_DIV_8, F_CPU_DIV_64, F_CPU_DIV_256, F_CPU_DIV_1024 का एक सेट से चुना। प्रारंभिक मान मैक्रो फ़ंक्शन TIMER0_SET_CNT (x) का उपयोग करते हुए खाता रजिस्टर TCNT0 में दर्ज किया जाता है, जहां तर्क x स्वयं प्रारंभिक मूल्य है (हमारे मामले में TCNT0_VALUE = 99)। TIMSK इंटरप्ट मास्क रजिस्टर में TOIE0 बिट की स्थापना मैक्रो फ़ंक्शन TIMER0_OVF_INT_ON () का उपयोग करके की जाती है।

IAR परियोजना के रूप में सभी उदाहरण यहां डाउनलोड किए जा सकते हैं ।

निष्कर्ष

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

इसके अलावा

यदि IAR में लिखे गए प्रोग्राम की हेक्स-फाइल प्राप्त करने की आवश्यकता है, तो ऐसा करना बिल्कुल भी मुश्किल नहीं है। यह लिंकर पर प्रोजेक्ट सेटिंग्स में पर्याप्त है-> आउटपुट टैब और लिंकर पर-> अतिरिक्त आउटपुट टैब सेटिंग्स बनाने के लिए, जैसा कि नीचे स्क्रीनशॉट में है। उसके बाद, यदि आप प्रोजेक्ट पर क्लिक करके प्रोजेक्ट का पुनर्निर्माण करते हैं-> सबफ़ोल्डर में सभी पुनर्निर्माण करें [प्रोजेक्ट का नाम] \ Debug \ Exe आप हेक्स फ़ाइल पा सकते हैं। जिसे AVR910 प्रोग्रामर, STK500 क्लोन या किसी अन्य उपलब्ध प्रोग्रामर के साथ सिल दिया जा सकता है।

IAR पर्यावरण में Atmega16 C microcontroller के प्रोग्रामिंग और JTAG डिबगिंग, भाग 1