माइक्रोकंट्रोलर सीखने का सबसे अच्छा समय

स्वीकार करें कि आपने प्रोग्रामिंग माइक्रोकंट्रोलर की मूल बातें माहिर करने के बारे में कितनी बार सोचा? निश्चित रूप से आपके सिर में संभावित परियोजनाओं के कई विचार हैं, लेकिन आपने उन्हें लागू करने के लिए कभी नहीं लिया। तो: अभी शुरू करने के लिए बेहतर समय केवल नहीं मिल सकता है।

मैंने यह क्यों तय किया कि यह सवाल ह्रोब दर्शकों के लिए दिलचस्पी का है? यह पसंदीदा में कुछ पोस्ट जोड़ने की मात्रा का विश्लेषण करने के लिए पर्याप्त है, और निष्कर्ष खुद का सुझाव देते हैं।

दूसरी ओर, मेरे वर्तमान परिवेश में बहुत सारे प्रोग्रामर हैं, लेकिन लगभग कोई भी imbedders नहीं हैं। जब मैं उनके साथ माइक्रोकंट्रोलर के बारे में बात करता हूं, तो मुझे यह धारणा मिलती है कि 10 साल पहले कई लोगों की उनके बारे में समान राय है।

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

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

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

निश्चित रूप से, अगर मैं कहता हूं कि मैं धोखा दे रहा हूं, तो मुझे कॉर्टेक्स-एम 3 आर्किटेक्चर को पूरी तरह से सीखना होगा और F103 डेटाशीट को धूम्रपान करना होगा - बेशक, CMSIS और StdPeriph_Lib पुस्तकालयों के लिए मेरा जुनून भी मेरी मदद करने के बजाय बाधा है, लेकिन नए के लिए प्रवेश करने की गति मुझे परिवार ने मारा था और तब भी मुझे महसूस हुआ कि नियंत्रकों की दुनिया बदल रही है और सरल और अधिक जटिल होती जा रही है।

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

आप EEx-TM4C123GXL लांचर को FedEx डिलीवरी के साथ $ 12.99 में खरीद सकते हैं (अर्थात, आप इसे जल्द ही प्राप्त करेंगे)। बोर्ड विभिन्न इलेक्ट्रॉनिक्स, जैसे डिस्कवरी F4 (बोर्ड पर एक एक्सीलेरोमीटर, साउंड सेंसर, डीएसी, एल ई डी का एक गुच्छा) के साथ पूरा नहीं होता है - यह सब आपको Tiva C लॉन्चपैड पर मिल जाएगा एक RGB डायोड और 2 बटन हैं, लेकिन इसकी ताकत नहीं है बोर्ड पर अतिरिक्त उपकरणों में।



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

थोड़ी देर बाद मैं आपको TivaWare डाउनलोड करने की पेशकश करूंगा और, यदि आप बहुत आलसी नहीं हैं, तो स्थापना के बाद आप निम्नलिखित वीडियो देख सकते हैं:

• Driverlib - यहाँ आप बाह्य उपकरणों के लिए ड्राइवरों को पा सकते हैं, जैसे कि adc, gpio और इतने पर (मैक्रोज़ के साथ हेडर फ़ाइल सहित रोम से कॉलिंग फ़ंक्शन के लिए - बाद में उस पर और अधिक)
• उदाहरण - यहाँ, निश्चित रूप से, उदाहरण। वे बोर्ड, बाह्य उपकरणों और परियोजना में विभाजित हैं। पहले में, निश्चित रूप से विशिष्ट डिबग बोर्डों के लिए परियोजनाएं, बाह्य उपकरणों के उपयोग के दूसरे उदाहरणों में और विभिन्न विकास परिवेशों (IAR, Keil, CCS) के लिए एक स्वच्छ परियोजना के तीसरे उदाहरण में - फाइलें बीएसडी लाइसेंस के तहत उपलब्ध हैं।
• इंक - tm4c123gh6pm फ़ाइल सहित मैक्रोज़ के साथ विभिन्न हेडर फाइलें, जो एक सरल प्रोजेक्ट बनाने के लिए हमारे लिए उपयोगी है
• डॉक्स - यह TI की पहचान है - सरल और सहज प्रलेखन। इसके अंदर यहां वर्णित घटकों से संबंधित कई उपयोगकर्ता मार्गदर्शिकाएँ हैं - DriverLib, उदाहरण, बूटलोडर, IQmath और इसी तरह, साथ ही साथ हमारे द्वारा उपयोग किए जाने वाले लांचर के लिए एक उपयोगकर्ता गाइड।
• Sensorlib - यह वास्तव में मुझे आश्चर्यचकित करता है: विभिन्न तृतीय-पक्ष सेंसर के लिए ड्राइवर हैं, जैसे कि sht21, lsm303d, MPU6050 और इसी तरह। मैं उत्तरार्द्ध का उपयोग करना पसंद करता हूं (यह एक ही क्रिस्टल पर एक्सीलरोमीटर और गायरोस्कोप का ऐसा एमईएमएस असेंबली है) और इससे पहले कि मैं हमेशा इन्वेंसेंस उदाहरणों से फाड़े गए लिबास से जुड़ा था, इसलिए मैं टीआई से बड़े करीने से लिखे गए स्रोतों से बहुत खुश था (इसके अलावा, मुझे काम के लिए कच्चा माल वहीं मिला था। मात्राओं के साथ)।
• IQmath एल्गोरिदम का एक पुस्तकालय है जो स्टेलारिस (Tiva C) उपकरणों पर फ्लोटिंग पॉइंट नंबरों के साथ काम करने के लिए अनुकूलित है।
• बर्तन - कमांड लाइन, सीरियल पोर्ट, शेड्यूलर और बहुत कुछ के साथ काम करने के लिए अक्सर उपयोगिताओं का उपयोग किया जाता है।
• शेष निर्देशिका में बूटलोडर, कच्चे तीसरे पक्ष के निर्माता (FreeRTOS, उदाहरण के लिए), USB के साथ काम करने के लिए एक पुस्तकालय, विंडोज के लिए ड्राइवर और इतने पर हैं।

अपने लॉन्चर पर कोई भी उदाहरण चलाने के लिए, अपने पसंदीदा IDE में उदाहरण / बोर्ड / ek-tm4c123gxl फ़ोल्डर से प्रोजेक्ट खोलें - वहां सब कुछ तैयार है (मैं IAR का उपयोग करता हूं, इसलिए मैंने ek-t44123gxl.eww खोला और इसने मुझे डाउनलोड किया पहले से ही कॉन्फ़िगर किया गया कार्यक्षेत्र)। लेकिन, आप जानते हैं, अब लगभग हर माइक्रोकंट्रोलर के पास ऐसे ट्यून किए गए उदाहरण हैं, और असली कठिनाइयाँ तब शुरू होती हैं जब हम अपना कुछ बनाने की कोशिश करते हैं।

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

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

तो, पहली चीज जो हमें चाहिए वह है लाइब्रेरी को डाउनलोड और इंस्टॉल करना (यदि आपने अब तक ऐसा नहीं किया है)। इसके अलावा, आपको एक आईडीई और एक फ्लैशर स्थापित करने की आवश्यकता है।



मैं एक आईडीई के रूप में IAR का उपयोग करूंगा (इसलिए उदाहरण इसके साथ होंगे), हालांकि आप किसी भी समर्थित का उपयोग कर सकते हैं।

कौन नहीं जानता, IAR में मुफ्त उपयोग के लिए 2 विकल्प हैं - एक समय सीमा और एक कोड आकार सीमा के साथ। और, निश्चित रूप से, अन्य विकल्प हैं यदि ये 2 आपको सूट नहीं करते हैं (आप खुद जानते हैं कि कौन से हैं)। मैं IAR को स्थापित करने और पंजीकृत करने की प्रक्रिया का वर्णन नहीं करूंगा - वहां सब कुछ सरल है, लेकिन अगर आपको कोई कठिनाई है तो टिप्पणियों में प्रश्न पूछने में संकोच न करें।

इसलिए, सबसे पहले, एक नया प्रोजेक्ट बनाएं। हम परियोजना के गुणों में कुछ सेटिंग्स बदल देंगे।



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

फ़ोल्डर में (वास्तव में "समूह में", लेकिन फ़ोल्डर किसी तरह अधिक परिचित हैं) एसआरसी हमारे पास हमारे स्रोत कोड हैं। उदाहरणों में, लाइब्रेरी फ़ाइलों के स्रोत फ़ाइलों को भी वहां जोड़ा जाता है, लेकिन मेरा मानना ​​है कि यह केवल परियोजना को भ्रमित करेगा।

लाइब्रेरी फ़ोल्डर में DriverLib की फाइलें होती हैं। TI वहां पहले से संकलित फ़ाइल जोड़ता है (IAR के मामले में, यह ड्राइवरलीब / ewarm / Exe / driverlib.a फ़ाइल है), आप ऐसा ही कर सकते हैं, लेकिन मैं इसके बजाय स्रोत को जोड़ने का सुझाव दूंगा, और केवल यदि आवश्यक हो तो यह याद रखना आसान है कि क्या कहाँ है स्थित है, और स्रोत कोड को देखने उपयोगी है। यदि आप एक ही फ़ोल्डर में अन्य पुस्तकालयों (उदाहरण के लिए) से फाइल जोड़ने की योजना बनाते हैं, तो एक और पदानुक्रम स्तर बनाना बेहतर है।

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

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

इसलिए, Src फ़ोल्डर में, main.c फ़ाइल बनाएँ

लाइब्रेरी फ़ोल्डर में startup_ewarm.c को जोड़ें - इसे इंटरप्ट वेक्टर के उचित इनिशियलाइज़ेशन के लिए आवश्यक है। आप इसे प्रोजेक्ट_0 (इस उदाहरण में) से ले सकते हैं, उदाहरण के लिए।

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

void main(void) { volatile uint32_t ui32Counter; //  while(1) { //     for(ui32Counter = 0; ui32Counter < 1000000; ui32Counter++) { } //     for(ui32Counter = 0; ui32Counter < 1000000; ui32Counter++) { } } } 

मुझे लगता है कि सब कुछ स्पष्ट है: uint32_t जैसे प्रकारों का उपयोग करना एक अच्छी आदत है, यह विभिन्न नियंत्रकों पर चर के आकार के साथ अस्पष्टता को हल करने में मदद करता है (इसके अलावा, यह MISRA-C मानकों का अनुपालन करता है); वाष्पशील - संकलक को बताता है कि इस चर को अनुकूलित नहीं किया जाना चाहिए (क्योंकि हम इसे आम तौर पर बेकार ऑपरेशन के लिए उपयोग करेंगे)। अगला अंतहीन चक्र है (जैसा कि छात्रों को सिखाया जाता है, माइक्रोकंट्रोलर पर कार्यक्रम कभी समाप्त नहीं होना चाहिए) और देरी के लिए 2 काउंटर।
इस कोड को संकलित करने के लिए, फ़ाइल की शुरुआत में जोड़ें।

 #include <stdint.h> 

अब हम सीधे चमकती एल ई डी के लिए आगे बढ़ेंगे।

लॉन्चर पेज से Tiva C Series TM4C123G लॉन्चपैड मूल्यांकन किट उपयोगकर्ता का मैनुअल डाउनलोड करें और उपयोगकर्ता स्विच और RGB उपयोगकर्ता एलईडी अनुभाग में पढ़ें कि डायोड पीएफ 1 (लाल), पीएफ 2 (नीला) और पीएफ 3 (हरा) से जुड़ा है।
अब SW-TM4C-DRL-UG (TivaWare डॉक्स फ़ोल्डर में) खोलें और GPIO सेक्शन को देखें। परिचय से, हम समझते हैं कि पहले पिंस को कॉन्फ़िगर किया जाना चाहिए (निश्चित रूप से, आउटपुट में कई कॉन्फ़िगरेशन हैं)। हमने वहीं पढ़ा कि सबसे उपयोगी कार्यों में से एक GPIOPinRead () और GPIOPinWrite () है। वे क्या करते हैं यह समझने योग्य है, यह मापदंडों की सूची को स्पष्ट करने के लिए उनके विवरण को देखने के लिए बनी हुई है। तुरंत हम पाते हैं कि फ़ंक्शन GPIOPinTypeGPIOOutput () का उपयोग पिन आउटपुट को पंजीकृत करने के लिए किया जाता है। इसलिए, हम अपने कोड में टिप्पणियों को निम्न में बदलते हैं:

 GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2); //  // GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0xFF); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0); // GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0xFF); 

डायोड को चालू और बंद करना।

स्वाभाविक रूप से, लाइब्रेरी फ़ोल्डर में Driverlib / gpio.c फ़ाइल को जोड़ना न भूलें, साथ ही साथ

 #include "driverlib/gpio.h" 

सुर्खियों में।

इसके अलावा, संकलन प्रक्रिया के दौरान, हम देखते हैं कि 2 और हेडर फाइलें जोड़ना आवश्यक है:

 #include <stdbool.h> //    bool,    gpio #include "inc/hw_memmap.h" //   . 

अब हमारा कार्यक्रम इस तरह दिखता है:

 #include <stdint.h> #include <stdbool.h> #include "driverlib/gpio.h" #include "inc/hw_memmap.h" void main(void) { volatile uint32_t ui32Counter; GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); while(1) { GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0xFF); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0); for(ui32Counter = 0; ui32Counter < 2000000; ui32Counter++) { } GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0); GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0xFF); for(ui32Counter = 0; ui32Counter < 2000000; ui32Counter++) { } } } 

और, यदि आप इसे संकलित और चलाते हैं, तो आप डायोड के वैकल्पिक रंग परिवर्तन का निरीक्षण कर सकते हैं।

लेकिन एलईडी को ब्लिंक करना हमारे लिए बहुत आसान है। आइए थोड़ा और आगे बढ़ें और I / O पोर्ट सपोर्ट जोड़ें।
क्रियाएं समान हैं। हम पाते हैं कि कौन से पोर्ट UART से जुड़े हैं, UserGuide में मॉड्यूल के कॉन्फ़िगरेशन के बारे में पढ़ें, इसे कॉन्फ़िगर करें, इसे लिखने और पढ़ने के लिए फ़ंक्शन का उपयोग करें।

मेरा uart आरंभीकरण फ़ंक्शन उदाहरण से फ़ंक्शन के समान निकला, लेकिन एक दिलचस्प अंतर के साथ। यहाँ उदाहरण से आरंभ है:

 void ConfigureUART(void) { // // Enable the GPIO Peripheral used by the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Enable UART0 // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Configure GPIO Pins for UART mode. // ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Use the internal 16MHz oscillator as the UART clock source. // UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); // // Initialize the UART for console I/O. // UARTStdioConfig(0, 115200, 16000000); } 

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

ROM के साथ काम करने के लिए, आपको कई स्थिरांक कॉन्फ़िगर करने की आवश्यकता है: प्रोजेक्ट विकल्पों में, C / C ++ कंपाइलर में, Preprocessor टैब पर, TARGET_IS_BLIZZARD_RB1 को डेफिनिट सिंबल फ़ील्ड में जोड़ें। PART_TM4C123GH6PM और ewarm को वहीं जोड़ें - उन्हें लाइब्रेरी फ़ाइलों को सफलतापूर्वक संकलित करने की आवश्यकता है।



इसके अलावा, आपको प्रोजेक्ट ट्री में गुम फाइलों को जोड़ना होगा:



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

UART को प्रारंभ करने के लिए आपके पास पहले से ही एक फ़ंक्शन है। हम तीसरे पिन को जोड़ने के लिए बंदरगाहों के आरंभीकरण को बदलते हैं (पहले हमने आउटपुट के लिए केवल 2 कॉन्फ़िगर किया था)। आप UARTprintf () फ़ंक्शन का उपयोग करके टर्मिनल को एक स्ट्रिंग आउटपुट कर सकते हैं; बर्तन / uartstdio.c लाइब्रेरी से (स्वाभाविक रूप से, आपको इसे प्रोजेक्ट में जोड़ना होगा और हेडर फ़ाइल को शामिल करना होगा)।

हम UARTCharGet () फ़ंक्शन के साथ वर्ण पढ़ते हैं। यह लूप में तब तक प्रवेश करता है जब तक कि कोई प्रतीक वार्ट में न आ जाए। उसके बाद, हम पिंस पर कार्रवाई करते हैं और चक्र की शुरुआत में लौटते हैं।

 #include <stdint.h> #include <stdbool.h> #include "inc/hw_memmap.h" #include "inc/hw_types.h" #include "driverlib/gpio.h" #include "driverlib/rom.h" #include "driverlib/sysctl.h" #include "driverlib/uart.h" #include "driverlib/pin_map.h" #include "utils/uartstdio.h" void ConfigureUART(void) { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); UARTStdioConfig(0, 115200, 16000000); } void main(void) { volatile uint32_t ui32Loop; uint32_t ui32Color; uint8_t ui8Red = 0xFF; uint8_t ui8Green = 0xFF; uint8_t ui8Blue = 0xFF; GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); ConfigureUART(); UARTprintf("Hello HabraHabr!\n"); while (1) { UARTprintf("Please, enter color(r,g,b) \n"); ui32Color = UARTCharGet(UART0_BASE); switch (ui32Color) { case 'r': GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, ui8Red); ui8Red = ~ui8Red; break; case 'b': GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, ui8Blue); ui8Blue = ~ui8Blue; break; case 'g': GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, ui8Green); ui8Green = ~ui8Green; break; default: UARTprintf("Incorrect color! \n"); break; } } } 

TivaWare में मुझे एक दिलचस्प काम मिला - बर्तन / cmdline। यह आपको कमांड लाइन से दर्ज कमांड बनाने और प्रोसेस करने की अनुमति देता है। मैं इसे और कुछ अन्य दिलचस्प पुस्तकालयों का उपयोग करके एक दिलचस्प परियोजना बनाना चाहता था, लेकिन समय समाप्त हो रहा है, इसलिए मैं इसके बारे में बाद में लिख सकता हूं अगर ब्याज (साथ ही रुकावटें भी यहां फ्रीआरटीओएस के बारे में उल्लेख नहीं किया गया है)।
खैर, अब इस बारे में कि मैंने इस तथ्य के बारे में कई बार क्यों लिखा कि समय समाप्त हो रहा है और क्यों, नियंत्रक अध्ययन शुरू करने के लिए सभी अनुकूल समयों में से, सबसे अनुकूल अब है: 22 जनवरी को, एंबेडेड सिस्टम - आकृति विश्व पाठ्यक्रम edX पर शुरू होगा।



पंजीकरण मुफ्त है, लेकिन यदि आप एक प्रमाण पत्र प्राप्त करना चाहते हैं, तो आपको एक शुल्क (कम से कम $ 50) का भुगतान करना होगा। व्यक्तिगत रूप से, मैंने $ 50 का भुगतान किया - प्रमाणपत्र के कारण नहीं, लेकिन ऐसे पाठ्यक्रमों के लिए और उनके समर्थन में बस प्यार से बाहर।

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

लेकिन आपको चिंता नहीं करनी चाहिए: मुझे नहीं लगता कि पहले पाठ में आपको तुरंत हार्डवेयर के साथ काम करने की आवश्यकता होगी, शायद आप अपने कार्यक्रम का अनुकरण कर सकते हैं।

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

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