सबसे छोटे के लिए एआरएम

कुछ दिन पहले मैंने प्रकाशित किया और फिर अचानक एआरएम वास्तुकला के लिए अपने ओएस बनाने के बारे में लिखने की योजना के बारे में एक लेख तैयार किया। मैंने ऐसा इसलिए किया क्योंकि मुझे हैबे और जी + दोनों पर काफी दिलचस्प समीक्षाएं मिलीं।

आज मैं दूसरी ओर इस मुद्दे पर बात करने की कोशिश करूंगा, मैं इस बात की चर्चा करूंगा कि बढ़ती जटिलता के उदाहरणों के साथ एआरएम माइक्रोकंट्रोलर को कैसे प्रोग्राम किया जाए, जब तक कि हम अपना ओएस नहीं लिखते या जब तक मैं ऊब नहीं जाता। या हो सकता है कि हम Contiki, TinyOS, ChibiOS या FreeRTOS में पिकिंग पर कूदेंगे, जो जानते हैं, इतने सारे अलग-अलग और दिलचस्प हैं (और TinyOS की अपनी प्रोग्रामिंग भाषा भी है!)।

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

वास्तुकला में एक छोटा सा विषयांतर

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

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

लोहे के टुकड़े!

एक लक्ष्य मंच के रूप में, हम कोर्टेक्स-एम के साथ काम करने पर विचार करेंगे, क्योंकि यह क्रमशः सबसे सरल है, हमें कम प्रश्नों में तल्लीन करने की आवश्यकता है। एक परीक्षण उपकरण के रूप में, मैं आपको LPC1114 - NXP MCU, एक सर्किट प्रदान करता हूं, जिस पर आप अपने घुटने पर शाब्दिक रूप से इकट्ठा कर सकते हैं (नहीं, हालांकि, आपको केवल MCU ही चाहिए, 3.3 V FTDI केबल, कई एल ई डी और प्रतिरोधक)। LPC1114 Cortex-M0 पर आधारित है, इसलिए यह प्लेटफ़ॉर्म का सबसे अलग किया गया संस्करण होगा।



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

चलिए शुरू करते हैं

आधुनिक एआरएम की एक दिलचस्प विशेषता यह है कि उन्हें पूरी तरह से सी में पूरी तरह से प्रोग्राम किया जा सकता है, बिना कोडांतरक आवेषण का उपयोग किए बिना (हालांकि कोडांतरक जटिल नहीं है, कॉर्टेक्स-एम 0 में केवल 56 कमांड हैं)। यद्यपि C कमांड से कुछ कमांड उपलब्ध नहीं हैं, CMSIS - कॉर्टेक्स माइक्रोकंट्रोलर सॉफ्टवेयर इंटरफ़ेस स्टैंडर्ड इस समस्या को हल करता है। यह एक प्रोसेसर के लिए एक ड्राइवर है जो इसे प्रबंधित करने के सभी बुनियादी कार्यों को हल करता है।

प्रोसेसर कैसे लोड होता है? एक विशिष्ट स्थिति तब होती है जब यह केवल 0x00000000 पते से आदेशों को निष्पादित करना शुरू कर देता है। हमारे मामले में, प्रोसेसर कुछ हद तक अधिक बुद्धिमान है, और मेमोरी की शुरुआत में एक विशेष रूप से परिभाषित डेटा प्रारूप पर निर्भर करता है, अर्थात्, बाधा वैक्टर की एक तालिका:


कार्यक्रम निम्नानुसार शुरू होता है: प्रोसेसर 0x00000000 पर मूल्य पढ़ता है और इसे एसपी को लिखता है ( एसपी रजिस्टर है जो स्टैक के शीर्ष पर इंगित करता है), जिसके बाद यह 0x00000004 पर मूल्य पढ़ता है और इसे पीसी पर लिखता है ( पीसी यह रजिस्टर है जो इंगित करता है) वर्तमान निर्देश + 4 बाइट्स)। इस प्रकार, कुछ उपयोगकर्ता कोड निष्पादित होना शुरू हो जाते हैं, जबकि हमारे पास पहले से ही मेमोरी में कहीं न कहीं एक स्टैक होता है (यानी, C प्रोग्राम को निष्पादित करने के लिए सभी शर्तें)।

परीक्षण अभ्यास के रूप में, हम एलईडी को ब्लिंक करेंगे। Mbed में हम उनमें से चार हैं, LPC1114 के साथ सर्किट में (बाद में "बोर्ड" के रूप में संदर्भित) हम मैन्युअल रूप से एलईडी स्थापित करते हैं।

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

Cortex-M0 के लिए मेमोरी कार्ड इस तरह दिखता है:



( Cortex ™ -M0 डिवाइसेस जेनेरिक यूजर गाइड से छवि)

कोर्टेक्स-एम 3 पर, यह अनिवार्य रूप से समान है, लेकिन कुछ हद तक अधिक विस्तृत है। यहाँ समस्या यह है कि NXP की अपनी समस्या है, इस मुद्दे पर अलग नज़र डालें, इसलिए हम प्रोसेसर के दस्तावेज़ीकरण में मेमोरी कार्ड की जाँच करते हैं:



( LPC111x / LPC11Cxx उपयोगकर्ता पुस्तिका से छवि)

वास्तव में, SRAM 0x10000000 से शुरू होता है! तो, कुछ मानक, अन्य मानक, लेकिन आपको अभी भी प्रलेखन संस्करणों के माध्यम से स्क्रॉल करने की आवश्यकता है।

इस ज्ञान के साथ, हम कोड लिखने जा रहे हैं। शुरुआत के लिए, एक बाधा तालिका:

.cpu cortex-m0 /*      */ .thumb .word _stack_base /*      ,    */ .word main /* Reset:         */ .word hang /* NMI         */ .word hang /* HardFault */ .word hang /* MemManage */ .word hang /* BusFault */ .word hang /* UsageFault */ .word _boot_checksum /*   */ .word hang /* RESERVED */ .word hang /* RESERVED*/ .word hang /* RESERVED */ .word hang /* SVCall */ .word hang /* Debug Monitor */ .word hang /* RESERVED */ .word hang /* PendSV */ .word hang /* SysTick */ .word hang /*   0 */ /* ... */ /*    32   LPC1114  35  LPC1768,     ,         */ .thumb_func hang: b . /*    :   */ .global hang 

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

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

अब हम मुख्य कार्य के कार्यान्वयन को लिखते हैं:

 #if defined(__ARM_ARCH_6M__) /* Cortex-M0  ARMv6-M,   LPC1114 */ #define GPIO_DIR_REG 0x50018000 /* GPIO1DIR     GPIO 1 */ #define GPIO_REG_VAL 0x50013FFC /* GPIO1DATA     GPIO 1 */ #define GPIO_PIN_NO (1<<8) /* 8-    8-  */ #elif defined(__ARM_ARCH_7M__) /*      LPC1768 */ #define GPIO_DIR_REG 0x2009C020 /* FIO1DIR     GPIO 1 */ #define GPIO_REG_VAL 0x2009C034 /* FIO1PIN     GPIO 1 */ #define GPIO_PIN_NO (1<<18) /* 18-    18-  */ #else #error Unknown architecture #endif void wait() { volatile int i=0x20000; while(i>0) { --i; } } void main() { *((volatile unsigned int *)GPIO_DIR_REG) = GPIO_PIN_NO; while(1) { *((volatile unsigned int *)GPIO_REG_VAL) = GPIO_PIN_NO; wait(); *((volatile unsigned int *)GPIO_REG_VAL) = 0; wait(); } /* main() **   ! */ } 

Mbed में, पहला LED GPIO 1.18 पोर्ट से जुड़ा है, बोर्ड पर हमने LED को GPIO 1.8 से जोड़ा है। एक ही पिन अलग-अलग कार्य कर सकता है, ये डिफ़ॉल्ट रूप से GPIO (सामान्य प्रयोजन I / O - सामान्य प्रयोजन I / अन्य लाइन्स) की तरह काम करते हैं।

कोड अपेक्षाकृत सरल है, यदि आप LPC-shny उपयोगकर्ता पुस्तिका ( एक और दूसरा ) को हाथ में रखते हैं। शुरू करने के लिए, हम GPIO_DIR_REG रजिस्टर के माध्यम से GPIO ऑपरेटिंग मोड का संकेत देते हैं (हमारे प्रोसेसर पर वे विभिन्न स्थानों में हैं, और वास्तव में LPC1768 GPIO के साथ अधिक कुशलता से काम कर सकते हैं), जहां 1 आउटपुट है, 0 इनपुट है। फिर हम एक अंतहीन चक्र शुरू करते हैं, जिसमें हम पोर्ट को वैकल्पिक रूप से मान 0 और 1 (0 V और 3.3 V, क्रमशः) लिखते हैं।

"ठहराव" फ़ंक्शन केवल अपेक्षाकृत लंबे चक्र को स्क्रॉल करके यादृच्छिक रूप से काम करता है ( volatile int कंपाइलर को इस चक्र को पूरे के रूप में अनुकूलित करने से रोकता है)।

अंत में, यह सब सही ढंग से एक साथ रखा जाना चाहिए:

 _stack_base = 0x10002000; _boot_checksum = 0 - (_stack_base + main + 1 + (hang + 1) * 5); MEMORY { rom(RX) : ORIGIN = 0x00000000, LENGTH = 0x8000 ram(WAIL) : ORIGIN = 0x10000000, LENGTH = 0x2000 } SECTIONS { .text : { *(.text*) } > rom .bss : { *(.bss*) } > ram } 

लिंकर स्क्रिप्ट उसे समझाती है कि हमारे पास फ्लैश कहां है, रैम कहां है, उनके पास क्या आकार हैं (यहां LPC1114 के लिए आकार का उपयोग किया जाता है, क्योंकि LPC1768 के पास सबसे अधिक हैं, शिफ्ट सौभाग्य से, समान हैं)। मेमोरी कार्ड का निर्धारण करने के बाद, हम संकेत देते हैं कि कौन से सेगमेंट को कॉपी करना है, .text (प्रोग्राम कोड) फ्लैश में, .bs (स्टैटिक वैरिएबल जो हमारे पास अभी तक नहीं है) - मेमोरी में। इसके अलावा, हम दो अक्षर निर्दिष्ट करते हैं जिनका उपयोग boot.s: _stack_base - के शीर्ष पर होता है और _boot_checksum (स्पष्टीकरण के लिए धन्यवाद Zuy !) - बूटलोडर cxum लिखता है। चेक राशि की गणना सूत्र द्वारा की जाती है: ऊपर के क्षेत्रों के योग से एक अतिरिक्त कोड (2 की प्रशंसा) (जैसे कि स्टैक का पता, और सभी चेक योग के लिए बाधित होता है)। यद्यपि फ़र्मवेयर के लिए उपयोगिताओं (नीचे देखें) स्वयं चेकबॉक्स को एक सही करने के लिए तय करेगी, अगर हम कोड को स्वयं एप्लिकेशन से फ्लैश करते हैं, तो हम फिर से बूट नहीं कर पाएंगे।

अब हमारे पास तीन फाइलें हैं: boot.s, main.c, mem.ld, यह सब संकलित करने और अंत में इसे चलाने का समय है। हम जीसीसी को एक उपकरण श्रृंखला के रूप में उपयोग करेंगे, बाद में, शायद, मैं दिखाऊंगा कि एलएलवीएम के साथ कैसे करें। ओएस एक्स उपयोगकर्ता, मैं आपको लिनोरो से टूलचैन लेने की सलाह देता हूं - सूची के बहुत अंत में: नंगे-धातु जीसीसी एआरएम एंबेडेड। अन्य OS के उपयोगकर्ताओं के लिए, मैं आपको टूलकिन को वहां ले जाने की सलाह देता हूं :-) (जब तक कि क्रॉसदेव को बचाने के लिए जेंटुशनिक के लिए और जीसीसी को संकलित करना आसान नहीं होगा)।

 arm-none-eabi-as boot.s -o boot.o arm-none-eabi-gcc -O2 -nostdlib -nostartfiles -ffreestanding -Wall -mthumb -mcpu=cortex-m0 -c main.c -o main-c0.o arm-none-eabi-gcc -O2 -nostdlib -nostartfiles -ffreestanding -Wall -mthumb -mcpu=cortex-m3 -c main.c -o main-c3.o arm-none-eabi-ld -o blink-c0.elf -T mem.ld boot.o main-c0.o arm-none-eabi-ld -o blink-c3.elf -T mem.ld boot.o main-c3.o arm-none-eabi-objdump -D blink-c0.elf > blink-c0.lst arm-none-eabi-objdump -D blink-c3.elf > blink-c3.lst arm-none-eabi-objcopy blink-c0.elf blink-c0.bin -O binary arm-none-eabi-objcopy blink-c3.elf blink-c3.bin -O binary 

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

प्रश्न: लिंकर को कैसे पता चलता है कि रुकावट तालिका कहां रखी जाए? और वह नहीं जानता, यह वहां नहीं लिखा है :-)। यह केवल एक पंक्ति में लिंक करता है, शून्य पते से शुरू होता है, इसलिए फाइलों का क्रम (बूट.ओ, फिर मुख्य-सी0.ओ) बहुत महत्वपूर्ण है! दूसरे तरीके से लिंक करने या बूट करने के लिए दो बार लिंक करने का प्रयास करें और आउटपुट को lst फ़ाइल में तुलना करें।

एक अच्छा विचार यह है कि अंतिम लिस्टिंग (lst फ़ाइल) देखें या बाइनरी को डिस्सेम्बलर में छोड़ दें। यहां तक ​​कि अगर आप ARM UAL नहीं बोलते हैं, तो आप नेत्रहीन जांच कर सकते हैं कि कम से कम रुकावट तालिका में है:




आप एक मजेदार क्षण पर भी ध्यान दे सकते हैं - जब कोर्टेक्स-एम 3 के तहत संकलन करते हैं, तो जीसीसी कॉर्टेक्स-एम 0 के तहत संस्करण की तुलना में अधिक प्रतीक्षा () फ़ंक्शन उत्पन्न करता है। सच है, यदि आप अनुकूलन को सक्षम करते हैं, तो यह उसके दिमाग को स्थापित करेगा।

चमकती!

हमारे लिए जो कुछ भी है वह बायनेरिज़ को हमारे परीक्षण प्लेटफार्मों पर अपलोड करना है। एमबेड के साथ, सब कुछ जितना संभव हो उतना सरल है, बस वर्चुअल फ्लैश ड्राइव पर blink-c3.bin को कॉपी करें और रीसेट (दबाए गए) पर रीसेट करें। एक बोर्ड के साथ सब कुछ थोड़ा और अधिक जटिल है। सबसे पहले, बूटलोडर में जाने के लिए, हमें GND और GPIO 0.1 के बीच एक अवरोधक की आवश्यकता होती है। दूसरे, आपको सीधे फर्मवेयर के लिए एक कार्यक्रम की आवश्यकता है। आप फ्लैश मैजिक (विन, ओएस एक्स) का उपयोग कर सकते हैं, आप कंसोल उपयोगिता का उपयोग कर सकते हैं - lpc21isp :

 lpc21isp.out -verify -bin /path/to/blink-c0.bin /dev/ftdi/tty/device 115200 12000 

फर्मवेयर प्रक्रिया इस प्रकार है:

• j5 और j7 (10 kOhm करेगा) के बीच एक अवरोधक डालें;
• प्रेस रीसेट;
• हम lpc21isp शुरू करते हैं;
• अवरोधक को हटा दें;
• प्रेस फिर से रीसेट - आवेदन शुरू होता है।

यदि आपके पास विभिन्न उपकरणों पर उदाहरण चलाने का अवसर है, तो आप देखेंगे कि उन पर पलक की गति समान नहीं है। यह इस तथ्य के कारण है कि विभिन्न उपकरणों में क्रमशः अलग-अलग कोर आवृत्तियों हैं, वे अलग-अलग समय पर wait() को निष्पादित करते हैं। अगले भाग में, हम दोलन मुद्दों का अधिक विस्तार से अध्ययन करेंगे और एक स्पष्ट उलटी गिनती करेंगे।

पाठ में मेरी त्रुटियों को ठीक करने के लिए समय निकालने के लिए पीएसएफ़ेक्टम हब्रायुज़र का पीएस विशेष धन्यवाद :-)।

PPS उन लोगों के लिए अनुरोध करता है जिनके पास ARM- आधारित परीक्षण प्लेटफ़ॉर्म है - टिप्पणियों में लिखें - जो एक। मैं आगे के लेखों के लिए हार्डवेयर बेस की समीक्षा कर सकता हूं।