स्टेलारिस LM4F120 लॉन्चपैड मूल्यांकन बोर्ड के साथ पहला कदम

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

मुझे तुरंत यह कहना होगा कि मैं इलेक्ट्रॉनिक्स के साथ थोड़ा सख्त हूं, इसलिए लेख इस पर अपनी राय व्यक्त करेगा कि यह कैसे काम करता है, जो वास्तविकता के साथ मेल नहीं खा सकता है। मैं शब्दावली के साथ बहुत बुरा हूं, इसलिए यदि आप सही शब्द जानते हैं, तो कृपया सही करें।

ट्रेनिंग

सबसे पहले, आपको विकास के लिए आवश्यक सॉफ़्टवेयर स्थापित करना होगा:

• संकलक और विकास का वातावरण
• एसडीके (स्टेलारिसवेयर)
• डीबग मॉड्यूल ड्राइवर
• फर्मवेयर प्रोग्राम
• प्रलेखन

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


सीसीएस का मुफ्त संस्करण पूरी तरह कार्यात्मक है और मैं इसका उपयोग करूंगा। ऊपर दिए गए लिंक का उपयोग करके, आप EK-LM4F120XL-CCS के भाग संख्या के पीछे छिपी "सीडी" को डाउनलोड कर सकते हैं, जिस पर विकास के लिए आवश्यक सब कुछ होगा, लेकिन संग्रह की सामग्री कुछ पुरानी है और अद्यतन नहीं लगती है। लेकिन आप सब कुछ व्यक्तिगत रूप से डाउनलोड कर सकते हैं:

कोड कम्पोज़र स्टूडियो , स्टेलारिसवेयर, SW-EK-LM4F120XL के भाग संख्या के पीछे यहां छिपा है , स्टेलारिस ICDI ड्राइवर , LMFlash प्रोग्रामर , इवैल्यूएशन बोर्ड यूजर मैनुअल , डेटशीट । निर्देशिका में StellarisWare को स्थापित करने के बाद जहां आपने इसे स्थापित किया था, आप दस्तावेज़ के साथ डॉक्स को उपनिर्देशिका पा सकते हैं। वहां, मुख्य रुचि फ़ाइल SW-DRL-UG-9453.pdf है (संख्या SW संस्करण के आधार पर भिन्न हो सकती है) - एसडीके द्वारा प्रदान किए गए कार्यों पर प्रलेखन (यदि आप SW-EK-LM420120XL-UG-9453.pdf को देखें, तो आप कर सकते हैं) एलईड और बटन के साथ काम करने के लिए उच्च-स्तरीय फ़ंक्शन खोजने के लिए, लेकिन यह वास्तविक जेडी का तरीका नहीं है: क्या हम समझना चाहते हैं कि अंदर क्या हो रहा है?

मुझे कहना होगा कि टीआई ने कुछ नाम बदला , और बोर्ड में उपयोग किए जाने वाले LM4F120H5QR माइक्रोकंट्रोलर को क्रमशः TM4C1233H6PM कहा जाता था, इस समय, दूसरे नाम का उपयोग सूचना खोजने के लिए किया जाना चाहिए।

आप टेक्सास इंस्ट्रूमेंट्स वेबसाइट पर बोर्ड और मुद्रित सामग्री के बारे में वीडियो व्याख्यान पा सकते हैं।

हम बोर्ड को कंप्यूटर से जोड़ते हैं:

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

विंडोज 8.1 के बारे में एक नोट। डिफ़ॉल्ट रूप से यह ऑपरेटिंग सिस्टम आपको अहस्ताक्षरित ड्राइवरों को डाउनलोड करने की अनुमति नहीं देता है, जो ICDI ड्राइवरों को स्थापित करना असंभव बनाता है। इसे निम्नानुसार माना जाता है: Win + I → पावर दबाएं, Shift दबाएं और पुनः प्रारंभ करें क्लिक करें, प्रतीक्षा करें, मरम्मत विकल्प वाला एक मेनू दिखाई देगा, समस्या निवारण → उन्नत विकल्प → स्टार्टअप सेटिंग्स → पुनरारंभ करें का चयन करें। रिबूट करने के बाद, एक मेनू दिखाई देता है जिसमें आपको "ड्राइवर के हस्ताक्षर प्रवर्तन अक्षम करें" का चयन करना होगा।

बहुत पहले कार्यक्रम

इसलिए, हमने आपकी ज़रूरत की हर चीज़ को स्थापित कर दिया है। यह लिखने का समय है। CCS में एक प्रोजेक्ट बनाएँ: फ़ाइल → नया → CCS प्रोजेक्ट। हम इसे चित्र के समान कॉन्फ़िगर करते हैं:

हमें वह परियोजना प्राप्त होगी जिसमें स्रोत कोड के साथ एक बार दो फाइलें lm4f120h5qr_startup_ccs.c : खाली main.c और lm4f120h5qr_startup_ccs.c । दूसरी फ़ाइल में इंटरप्ट को संभालने के लिए इंटरप्ट टेबल और स्टब फ़ंक्शंस को शुरू करने के लिए बॉयलरप्लेट कोड होता है।

शीर्ष लेख फ़ाइलों और पुस्तकालयों की खोज के लिए पथ को तुरंत कॉन्फ़िगर करें, मेनू प्रोजेक्ट पर जाएं → गुण, फिर:


बेशक, रास्तों को खुद से बदलें।

#include को main.c जोड़ें और सत्यापित करें कि सब कुछ संकलित है:

 #include <inc/hw_types.h> #include <inc/hw_gpio.h> #include <inc/hw_memmap.h> #include <driverlib/sysctl.h> #include <driverlib/gpio.h> int main(void) { return 0; } 

यदि यह काम नहीं करता है, तो इसे सुधारें, यदि यह काम करता है, तो आप कुछ उपयोगी करना शुरू कर सकते हैं।

काम करने की आवृत्ति

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

फिलहाल, हम "सिस्टम क्लॉक" आउटपुट में रुचि रखते हैं। डेटा शीट के अनुसार, निम्नलिखित का उपयोग घड़ी के स्रोत के रूप में किया जा सकता है:

• परिशुद्धता आंतरिक ओएससी 16 मेगाहर्ट्ज
• मुख्य OSC (इस बोर्ड पर Y1 लेबल किया गया है, और इसकी आवृत्ति 16 मेगाहर्ट्ज है)
• आंतरिक OSC 30 kHz
• हाइबरनेशन OSC (32.768 kHz) - Y2 बोर्ड पर
• पीएलएल
• 4 विभक्त के माध्यम से परिशुद्धता आंतरिक OSC

इन स्रोतों में से, दो बाहरी हैं, माइक्रोकंट्रोलर (मुख्य ओएससी और हाइबरनेशन ओएससी) के संबंध में, बाकी इसके अंदर हैं।

आरेख में SYSDIV के रूप में नामित डिवाइडर को 1x - 64x आवृत्ति में कमी के लिए तैयार किया जा सकता है। यदि PLL को स्रोत के रूप में उपयोग किया जाता है, तो DIV400 बिट द्वारा नियंत्रित अतिरिक्त 2-बिट फ़्रीक्वेंसी विभक्त का उपयोग किया जा सकता है (डिफ़ॉल्ट रूप से सक्षम)। PLL कार्य करने के लिए, एक मास्टर पल्स जनरेटर की आवश्यकता होती है। इसकी आवृत्ति व्यापक रूप से भिन्न हो सकती है, लेकिन इसे आरंभीकरण के दौरान निर्दिष्ट किया जाना चाहिए। PLL का उपयोग अधिकतम आवृत्ति पर माइक्रोकंट्रोलर शुरू करने का एकमात्र तरीका है, इसलिए हम इसका उपयोग करेंगे (हालांकि हमारे उद्देश्यों के लिए इस तरह के पागल आवृत्ति की आवश्यकता नहीं है)। पीएलएल क्लॉकिंग के लिए, बाहरी क्रिस्टल और आंतरिक दोनों का उपयोग किया जा सकता है।

StellarisWare SysCtlClockSet फ़ंक्शन प्रदान करता है कि सिस्टम घड़ी से संबंधित सभी चीज़ों को एक ही झटके में कॉन्फ़िगर कर दिया जाए। ऐसा करने के लिए, वह प्रवेश द्वार पर झंडे का एक गुच्छा प्राप्त करती है:
शुरू करने के लिए, हम तय करते हैं कि हम PLL ( SYSCTL_USE_PLL ) का उपयोग करते हैं या कुछ और ( SYSCTL_USE_OSC ) - आरेख पर BYPASS ध्वज।
यदि हम PLL का उपयोग करते हैं, तो हमें यह चुनना होगा कि मास्टर ऑसिलेटर कौन होगा: मुख्य OSC ( SYSCTL_OSC_MAIN ) या प्रेसिजन आंतरिक OSC ( SYSCTL_OSC_INT )। यदि हम मुख्य OSC का उपयोग करते हैं, तो हमें इसकी आवृत्ति (हमारे मामले में, SYSCTL_XTAL_16MHZ ) को निर्दिष्ट करना होगा।
यदि हम PLL का उपयोग नहीं करते हैं, तो आपको स्रोत निर्दिष्ट करना होगा:

• परिशुद्धता आंतरिक OSC - SYSCTL_OSC_INT
• 4 - SYSCTL_OSC_INT4 द्वारा विभाजक के माध्यम से परिशुद्धता आंतरिक OSC
• मुख्य OSC - SYSCTL_OSC_MAIN
• आंतरिक OSC - SYSCTL_OSC_INT30
• हाइबरनेशन OSC - SYSCTL_OSC_EXT32

और अंत में, आपको विभक्त को कॉन्फ़िगर करने की आवश्यकता है। SYSCTL_SYSDIV_1 लिए SYSCTL_SYSDIV_64 से SYSCTL_SYSDIV_1 तक SYSCTL_SYSDIV_64 । यदि आप PLL का उपयोग करते हैं, तो आप वैकल्पिक रूप से macros SYSCTL_SYSDIV_2_5 (/ 2.5) - SYSCTL_SYSDIV_63_5 (/63.5) का उपयोग कर सकते हैं। मेरे लिए अज्ञात कारणों से, SysCtlClockSet को कॉल करने के लिए SysCtlClockSet PLL आवृत्ति को 200 मेगाहर्ट्ज के बराबर माना जाता है, अर्थात। 80 मेगाहर्ट्ज की आवृत्ति पर काम करने के लिए, 2.5 का एक विभाजक निर्दिष्ट किया जाना चाहिए।

कुल मिलाकर, SysCtlClockSet कॉल इस तरह दिख सकती है:

  //  PLL,   - Main OSC   16 ,   2.5,   80  SysCtlClockSet(SYSCTL_USE_PLL | SYSCTL_SYSDIV_2_5 | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); 

या तो:

  //  PLL,   - Precision Internal OSC,   2.5,   80 ,  Main OSC SysCtlClockSet(SYSCTL_USE_PLL | SYSCTL_SYSDIV_2_5 | SYSCTL_OSC_INT | SYSCTL_MAIN_OSC_DIS); 

या आपको जो अच्छा लगे।

पलक झपकते एलईडी

यह एक कार्यक्रम बनाने का समय है, जिसके परिणाम को देखा जा सकता है। बोर्ड के लिए प्रलेखन में एल ई डी चालू करने के लिए एक सर्किट है:


यानी एल ई डी 1-3 जीपीआईओ पोर्ट एफ के पैरों से जुड़े होते हैं (यदि किसी को पता है कि एक अवरोधक ट्रांजिस्टर के आधार और उत्सर्जक के बीच क्यों है, तो कृपया बताएं, और यह संकेत क्यों नहीं दिया गया है?)। GPIO पोर्ट में आठ पैर होते हैं, जिनमें से प्रत्येक को इनपुट या आउटपुट के रूप में व्यक्तिगत रूप से कॉन्फ़िगर किया जा सकता है। लेखन और पढ़ना एक साथ सभी पैरों से किया जाता है एक बार लिखकर या मेमोरी में मैप किए गए GPIODATA रजिस्टर को GPIODATA (क्रमशः, हम एक-एक बाइट - सभी पैरों की स्थिति को पढ़ते / लिखते हैं)। पोर्ट तक पहुँचने के दो तरीके हैं: एडवांस्ड पेरीफेरल बस (APB) के माध्यम से या एडवांस्ड हाई-परफॉर्मेंस बस (ABB) के माध्यम से। पहला तरीका "पुराना" और धीमा है, दूसरा आधुनिक और तेज़ है। ईमानदारी से, प्रोग्रामिंग के दृष्टिकोण से उनके बीच क्या अंतर है, मुझे नहीं पता (पोर्ट के लिए कम से कम आधार पते अलग हैं), मैंने एपीबी का उपयोग किया, पोर्ट एफ के लिए आधार पता 0x40025000 है।

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

वांछित बिट्स सेट करने का कार्य इस तरह दिख सकता है:

 void pinWrite(unsigned int base, unsigned char pins, unsigned char value) { *((unsigned char *)base + ((unsigned int)pins << 2)) = value; } 

StellarisWare एक ही हस्ताक्षर के साथ GPIOPinWrite फ़ंक्शन प्रदान करता है जो GPIOPinWrite कार्य करता है।

केवल एक चीज गायब है: आपको पोर्ट चालू करने और पैरों को कॉन्फ़िगर करने की आवश्यकता है, जिसमें एलईड आउटपुट के रूप में जुड़े हुए हैं। जो लोग एसडीके के बिना करना चाहते हैं, उनके लिए प्रक्रिया माइक्रोकंट्रोलर की डेटा शीट की धारा 10.3 में वर्णित है। StellarisWare के साथ, यह SysCtlPeripheralEnable और GPIOPinTypeGPIOInput / GPIOPinTypeGPIOOutput कहकर किया जाता है।

 #include <inc/hw_types.h> #include <inc/hw_gpio.h> #include <inc/hw_memmap.h> #include <driverlib/sysctl.h> #include <driverlib/gpio.h> const unsigned int LED_RED = 0x02; const unsigned int LED_GREEN = 0x08; const unsigned int LED_BLUE = 0x04; const unsigned int LEDS_ALL = 0x02 | 0x08 | 0x04; int main(void) { SysCtlClockSet(SYSCTL_USE_PLL | SYSCTL_SYSDIV_2_5 | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); SysCtlPeripheralEnable(SYSCTL_PERIPH2_GPIOF); SysCtlDelay(2); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LEDS_ALL); const unsigned long int delay = 80000000 / 3 / 2; // 80 , 3    , 1/2    while (1) { GPIOPinWrite(GPIO_PORTF_BASE, LEDS_ALL, LEDS_ALL); SysCtlDelay(delay); GPIOPinWrite(GPIO_PORTF_BASE, LEDS_ALL, 0); SysCtlDelay(delay); } return 0; } 

SysCtlDelay फ़ंक्शन एक खाली लूप की पुनरावृत्तियों को करता है, जिससे आपको वांछित लंबाई की देरी करने की अनुमति मिलती है। प्रत्येक पुनरावृत्ति प्रोसेसर के 3 घड़ी चक्र तक रहता है। संकलित करें, भागो (सीसीएस में एफ 11, फिर आपको एफ 8 को दबाने की आवश्यकता होगी, क्योंकि कार्यक्रम की शुरुआत में डिफ़ॉल्ट रूप से एक अंतर्निहित विराम बिंदु है)। बोर्ड पर एलईडी को एक सेकंड की अवधि के साथ सफेद झपकी शुरू करना चाहिए। यदि LEDS_ALL बजाय LEDS_ALL पहली कॉल का तीसरा तर्क पारित किया गया है, उदाहरण के लिए, LED_GREEN , तो यह हरे रंग का झपकी देगा।

बटन!

दो बटन इस योजना के अनुसार GPIO पोर्ट F के पैर 0 और 4 से जुड़े हैं:

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

इसलिए, इनपुट के लिए पैर 0 और 4 सेट करें, पुल-अप सक्षम करें:

  GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4); GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); 

GPIOPadConfigSet फ़ंक्शन GPIOPadConfigSet वर्तमान सेट करने की अनुमति देता है कि पैर (2, 4 या 8 एमए) और इसका मोड बाहर दे सकता है। यह ध्यान देने योग्य है कि माइक्रोकंट्रोलर को कुछ GPIO पोर्ट (जो कि JTAG / SWD पोर्ट के लिए उपयोग किए जा सकते हैं) (पोर्ट C के 0-3 बिट्स) या किसी अनमास्क इंटरप्ट के इनपुट के लिए - NMI (पोर्ट डी और 0 बिट्स के बिट्स) के लिए सेटिंग्स को बदलने से सुरक्षा मिलती है। port F)): इन टांगों के लिए पुल-अप / पुल-डाउन सेटिंग्स बदलना केवल तभी संभव है जब 1. GPIOCR रजिस्टर में लिखा हो। GPIOCR रजिस्टर केवल तभी लिखा जा सकता है जब GPIOCR रजिस्टर में एक विशेष "मैजिक नंबर" लिखा हो।

यह सब एक साथ रखना:

 #include <inc/hw_types.h> #include <inc/hw_gpio.h> #include <inc/hw_memmap.h> #include <driverlib/sysctl.h> #include <driverlib/gpio.h> const unsigned int LEDS_ALL = GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3; const unsigned int SW1 = GPIO_PIN_0; const unsigned int SW2 = GPIO_PIN_4; void crSet(unsigned int base, unsigned char value); int main(void) { int led = 2; SysCtlClockSet(SYSCTL_USE_PLL | SYSCTL_SYSDIV_2_5 | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); SysCtlPeripheralEnable(SYSCTL_PERIPH2_GPIOF); SysCtlDelay(2); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LEDS_ALL); GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, SW1 | SW2); HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD; crSet(GPIO_PORTF_BASE, 1); GPIOPadConfigSet(GPIO_PORTF_BASE, SW1 | SW2, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU); crSet(GPIO_PORTF_BASE, 0); HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0; while (1) { unsigned int state = ~GPIOPinRead(GPIO_PORTF_BASE, SW1 | SW2); led = ((state & SW1) << 1) | ((state & SW2) >> 1); GPIOPinWrite(GPIO_PORTF_BASE, LEDS_ALL, led); } return 0; } void crSet(unsigned int base, unsigned char value) { unsigned long v = (HWREG(GPIO_PORTF_BASE + GPIO_O_CR) & 0xFFFFFF00) | value; HWREG(base + GPIO_O_CR) = v; } 

यह अद्भुत कार्यक्रम और 12 रुपये के लिए एक शुल्क, आखिरकार, आपको एक दर्जन से कम भागों के एक साधारण योजनाबद्ध के रूप में एक ही करने की अनुमति देता है, 10 रूबल की कीमत, बधाई!