सबसे छोटे के लिए ARM: लेआउट -2, इंटरप्ट और हेल्लो वर्ल्ड!

मुझे एक और लेख के साथ चक्र को "समाप्त" करने का अवसर मिला, जहां मैं एक छोटे परिणाम को संक्षेप में बताऊंगा। वास्तव में, केवल अब हम उस बिंदु पर पहुंच गए हैं जहां हम आमतौर पर प्रोग्रामिंग शुरू करते हैं:

• "जटिल" GNU ld बिल्ड स्क्रिप्ट पर विचार करें;
• इंटरप्ट का उपयोग करना सीखना
• अंत में हैलो दुनिया के लिए जाओ!

श्रृंखला में पिछले लेख:

• सबसे छोटे के लिए एआरएम
• सबसे छोटे के लिए एआरएम: क्या समय है?
• सबसे छोटे के लिए एआरएम: संकलन और लिंकर की सूक्ष्मता

लेख से कोड उदाहरण: https://github.com/farcaller/arm-demos



पिछली बार हमें पता चला था कि संकलित एप्लिकेशन में हमें किन वर्गों से सामना करना पड़ सकता है और उनकी विशिष्ट सामग्री क्या है। विशेष रूप से, हमने .bss और .bss पता .bss । मुझे याद दिलाना है कि .data संकलन के दौरान निर्दिष्ट मूल्य के साथ वैश्विक (स्थिर) चर संग्रहीत करता है। इस अनुभाग को फ्लैश मेमोरी से रैम तक कॉपी किया जाना चाहिए। .bss एक शून्य मान के साथ वैश्विक चर स्टोर करता है, इसे रीसेट किया जाना चाहिए।

विशिष्ट परिस्थितियों में, crt0.a से प्रक्रियाएं crt0.a (विकिपीडिया सुझाव देता है कि इस नाम का अर्थ है सी रनटाइम 0, जहाँ 0 का अर्थ है आवेदन के जीवन की शुरुआत)। आज हम अपने खिलौना प्लेटफार्मों के लिए crt0 का एक एनालॉग लिखेंगे।

अस्वीकरण। GNU ld में, एक ही तरह की कई चीजों को अलग-अलग तरीकों से किया जा सकता है, जिसमें सिंटैक्स वेरिएशन और लेआउट फ्लैग का उपयोग किया जाता है। नीचे वर्णित सभी विधियां मेरी कल्पना का एक अनुमान हैं, जो LPCXpresso से लेआउट स्क्रिप्ट के प्रभाव के तहत लिखी गई हैं। यदि आप किसी भी वर्णित परिस्थितियों को हल करने के लिए एक अधिक प्रभावी तरीका जानते हैं, तो मुझे लिखें!

इन-मेमरी डेटा इनिशियलाइज़ेशन

04-helloworld/platform/protoboard/layout.ld । सामान्य तौर पर, पिछले संस्करण के सापेक्ष कोई महत्वपूर्ण परिवर्तन नहीं होते हैं: कई स्थिरांक, स्मृति का वर्णन, अनुभाग। आइए एक उदाहरण के लिए .data अनुभाग देखें:

 .data : ALIGN(4) { _data = .; *(SORT_BY_ALIGNMENT(.data*)) . = ALIGN(4); _edata = .; } > ram AT>rom = 0xff 

4 बाइट्स के संरेखण के साथ .data सेक्शन आउटपुट फाइल को लिखा जाता है (यानी, यदि कर्सर इस सेक्शन से पहले 0x00000101 के पते की ओर इशारा करता है, तो .data से शुरू होगा)। अनुभाग रैम ( > ram ) में है, लेकिन फ्लैश मेमोरी ( AT>rom ) से लोड किया गया है।

निर्माण =0xff भरण पैटर्न को परिभाषित करता है। यदि आउटपुट अनुभाग में अनडाइड बाइट्स उत्पन्न होते हैं, तो उनका मान प्लेसहोल्डर बाइट पर सेट किया जाएगा। 0xff का चयन इस कारण से किया जाता है कि मिटाई गई फ्लैश मेमोरी सभी इकाइयाँ हैं, अर्थात 0xff (0x00 के विपरीत, उदाहरण के लिए) लिखना एक खाली ऑपरेशन है।

अगला, _data , वर्तमान कर्सर स्थिति बच जाती है। चूंकि अनुभाग मुख्य मेमोरी में है, _data इस मामले में इसकी शुरुआत की ओर संकेत करेगा: 0x10000000।

एक-एक करके, सभी स्रोत खंडों के साथ शुरू होने वाले नामों के साथ। सभी इनपुट फ़ाइलों में से .data को अनुभाग में कॉपी किया जाता है, जबकि उन्हें आकार के अनुसार क्रमबद्ध किया जाता है। छंटनी एक बहुत ही महत्वपूर्ण भूमिका निभाती है, इसे एक उदाहरण से समझें:

 uint16_t static_int = 0xab; uint8_t static_int2 = 0xab; uint16_t static_int3 = 0xab; uint8_t static_int4 = 0xab; 

चार खंड यहाँ .data अनुभाग के लिए परिभाषित किए गए हैं। अंतिम फ़ाइल को क्या मिलता है?

 .data 0x0000000010000000 0xc load address 0x00000000000007b0 0x0000000010000000 _data = . *(.data*) .data.static_int2 0x0000000010000000 0x1 build/d0f0154f60ed1a9c2083183e7c731846451d2bdb_helloworld.o 0x0000000010000000 static_int2 *fill* 0x0000000010000001 0x3 ff .data.static_int3 0x0000000010000004 0x4 build/d0f0154f60ed1a9c2083183e7c731846451d2bdb_helloworld.o 0x0000000010000004 static_int3 .data.static_int4 0x0000000010000008 0x1 build/d0f0154f60ed1a9c2083183e7c731846451d2bdb_helloworld.o 0x0000000010000008 static_int4 *fill* 0x0000000010000009 0x1 ff .data.static_int 0x000000001000000a 0x2 build/d0f0154f60ed1a9c2083183e7c731846451d2bdb_helloworld.o 0x000000001000000a static_int 0x000000001000000c . = ALIGN (0x4) 0x000000001000000c _edata = . 

सूचना *fill* बाइट्स कि शब्द सीमाओं के आसपास चर संरेखित करें। एक खराब आदेश के कारण, हमने उसी तरह 4 बाइट खो दिए। ऑपरेशन को दोहराएं, इस बार SORT_BY_ALIGNMENT का उपयोग करते हुए:

 .data 0x0000000010000000 0x8 load address 0x00000000000007b0 0x0000000010000000 _data = . *(SORT(.data*)) .data.static_int3 0x0000000010000000 0x4 build/d0f0154f60ed1a9c2083183e7c731846451d2bdb_helloworld.o 0x0000000010000000 static_int3 .data.static_int 0x0000000010000004 0x2 build/d0f0154f60ed1a9c2083183e7c731846451d2bdb_helloworld.o 0x0000000010000004 static_int .data.static_int2 0x0000000010000006 0x1 build/d0f0154f60ed1a9c2083183e7c731846451d2bdb_helloworld.o 0x0000000010000006 static_int2 .data.static_int4 0x0000000010000007 0x1 build/d0f0154f60ed1a9c2083183e7c731846451d2bdb_helloworld.o 0x0000000010000007 static_int4 0x0000000010000008 . = ALIGN (0x4) 0x0000000010000008 _edata = . 

चर बड़े करीने से सॉर्ट किए जाते हैं, और हमने मेमोरी का एक गुच्छा (33%) बचाया!

कर्सर पर वापस, जो अब तुरंत सभी .data के अंत का संकेत देता है। निर्माण . = ALIGN(4) . = ALIGN(4) शब्द सीमा के साथ कर्सर (यदि इनपुट अनुभागों में डेटा पूर्ण संरेखण के लिए अपर्याप्त है . = ALIGN(4) संरेखित करता है। अंतिम मूल्य _edata को लिखा गया है।

स्मृति में पतों के अलावा, हमें यह जानना होगा कि फ्लैश मेमोरी में सेक्शन कहां स्थित है, इस उद्देश्य के लिए स्क्रिप्ट की शुरुआत में प्रतीक घोषित किया गया है: _data_load = LOADADDR(.data) । LOADADDR एक फ़ंक्शन है जो किसी अनुभाग का लोड पता देता है। इसके अतिरिक्त, कुछ और भी दिलचस्प कार्य हैं: ADDR बाइट्स में "वर्चुअल" पता, SIZEOF - अनुभाग आकार देता है।

.data अनुभाग, 04-hello-world/platform/common/platform.c के लिए प्रारंभिक कोड पर एक नज़र डालें:

 uint32_t *load_addr = &_data_load; for (uint32_t *mem_addr = &_data; mem_addr < &_edata;) { *mem_addr++ = *load_addr++; } 

लूप में, हम load_addr से load_addr तक मान कॉपी करते हैं।

आमतौर पर, इस आरंभीकरण को यथासंभव पहले किया जाता है, यदि संभव हो - बहुत पहले कार्यों में से एक के रूप में। इसके लिए काफी उचित व्याख्या है: आरंभीकरण से पहले, सी से वैश्विक चर तक पहुंच "कचरा" वापस कर देगा। हमारे मामले में, platform_init कॉल के बाद इनिशियलाइज़ेशन किया जाता है, क्योंकि यह फ़ंक्शन .data .bss / .bss पर निर्भर नहीं करता है, और इसका निष्पादन बाद के कोड को तेज़ी से निष्पादित करने की अनुमति देगा, जो अंत में, एक प्रदर्शन को बढ़ावा देगा। नकारात्मक पक्ष एक अलग platform_init_post का उद्भव था, जहां सिस्टम चर की आवृत्ति के साथ वैश्विक चर का प्रारंभ होता है।

अंतिम खंड - /DISCARD/ - विशेष है, यह एक तरह का / dev / null लिंकर है। सभी आने वाले वर्गों को बस फेंक दिया जाएगा (जैसा कि आपको याद है, यदि कोई अनुभाग स्पष्ट रूप से निर्दिष्ट नहीं किया गया है, तो यह स्वचालित रूप से एक उपयुक्त मेमोरी क्षेत्र में जोड़ा जाएगा)। यह खंड स्पष्टता के लिए अधिक वर्णित है, क्योंकि ARMv6-M0 के मामले में इनपुट अनुभाग खाली होने की गारंटी है।

विभिन्न व्यवधानों के बारे में

थोड़ा संशोधित पहले खंड पर ध्यान .isr_vector_nvic । .isr_vector_nvic , जहां दो नए आते हैं: .isr_vector और .isr_vector_nvic । दोनों एक केईईपी निर्देश में लिपटे हुए हैं, जो लिंकर को अनावश्यक रूप से "अनुकूलित" करने से रोकता है। .isr_vector में कॉर्टेक्स-एम के लिए एक आम रुकावट तालिका है, जिसे platform/common/isr.c में जांच की जा सकती है:

 __attribute__ ((weak)) void isr_nmi(); __attribute__ ((weak)) void isr_hardfault(); __attribute__ ((weak)) void isr_svcall(); __attribute__ ((weak)) void isr_pendsv(); __attribute__ ((weak)) void isr_systick(); __attribute__ ((section(".isr_vector"))) void (* const isr_vector_table[])(void) = { &_stack_base, main, // Reset isr_nmi, // NMI isr_hardfault, // Hard Fault 0, // CM3 Memory Management Fault 0, // CM3 Bus Fault 0, // CM3 Usage Fault &_boot_checksum, // NXP Checksum code 0, // Reserved 0, // Reserved 0, // Reserved isr_svcall, // SVCall 0, // Reserved for debug 0, // Reserved isr_pendsv, // PendSV isr_systick, // SysTick }; 

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

तालिका की निरंतरता को एक समान संरचना isr_vector_table_nvic में रखा गया है, क्योंकि यह पहले से ही विशेष प्रोसेसर पर निर्भर करता है, लेकिन सार समान रहता है।

और रुकावटों के बारे में

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

एनवीआईसी - एक नेस्टेड वेक्टर इंटरप्ट कंट्रोलर प्रक्रिया एआरएम कोर के पीछे परिधि से बाधित होती है। यह आपको अलग-अलग प्राथमिकताओं के साथ अलग-अलग व्यवधान सेट करने, उन्हें केंद्रीय रूप से अक्षम करने, या प्रोग्रामेटिक रूप से एक बाधा उत्पन्न करने की अनुमति देता है।

नए सिस्टिक-आधारित टाइमर कार्यान्वयन पर एक नज़र डालें:

 static volatile uint32_t systick_10ms_ticks = 0; void platform_delay(uint32_t msec) { uint32_t tenms = msec / 10; uint32_t dest_time = systick_10ms_ticks + tenms; while(systick_10ms_ticks < dest_time) { __WFI(); } } // override isr_systick from isr.c void isr_systick(void) { ++systick_10ms_ticks; } 

जब तक सिस्टम काउंटर आवश्यक मूल्य से अधिक नहीं हो जाता, तब तक स्टैंडबाय चक्र प्रोसेसर को बीच में स्टैंडबाई मोड (स्लीप मोड) में डाल देता है। एक ही समय में, प्रत्येक 10 ms, SysTick ओवरफ्लो करता है और एक अवरोध उत्पन्न करता है, जिसके द्वारा isr_systick काउंटर को 1. से systick_10ms_ticks । ध्यान दें कि systick_10ms_ticks को अस्थिर के रूप systick_10ms_ticks घोषित किया गया है, यह कंपाइलर को यह समझने की अनुमति देता है कि इस चर का मान (और) वर्तमान संदर्भ के बाहर बदल जाएगा, और इसे प्रत्येक बार मुख्य मेमोरी (जहां इंटरप्ट हैंडलर इसे बदल देगा) से फिर से पढ़ना चाहिए।

libgcc

इस कोड में, हम पहली बार विभाजन ऑपरेशन का उपयोग करते हैं। ऐसा लगता है कि यह जटिल है, लेकिन कॉर्टेक्स- M0 :-) में विभाजन के लिए कोई हार्डवेयर निर्देश नहीं है। कंपाइलर यह जानता है, और डिवीजन इंस्ट्रक्शन के बजाय, __aeabi_uidiv फ़ंक्शन पर कॉल सम्मिलित करता है, जो प्रोग्राम को संख्याओं को विभाजित करता है। यह फ़ंक्शन (और कुछ और समान) कंपाइलर समर्थन लाइब्रेरी में कार्यान्वित किया जाता है: libgcc.a। दुर्भाग्य से, हमारे लिंकर को इसके बारे में कुछ भी पता नहीं है, और हम एक अप्रिय त्रुटि के साथ आते हैं:

 build/5a3e7023bbfde5552a4ea7cc57c4520e0e458a53_timer.o: In function `platform_delay': timer.c:(.text.platform_delay+0x4): undefined reference to `__aeabi_uidiv' 

सही समाधान यह है कि लिंकर कॉल को सीधे जीसीसी कॉल से बदल दिया जाए, जो पहले से ही यह पता लगा ले कि किससे लिंक करना है। सच है, जीसीसी इसे कुछ हद तक अधिक कर सकता है, इसलिए हम इसे -nostartfiles माध्यम से सूचित करते हैं कि हमारे पास हमारा इनिशियलाइज़ेशन कोड है, और -ffreestanding माध्यम से -ffreestanding कि हमारा एप्लिकेशन स्वतंत्र है और किसी भी ओएस पर निर्भर नहीं है।

अंत में, हैलो हबल!

यह संस्करण कुछ हद तक महत्वपूर्ण है, क्योंकि इसमें एक UART ड्राइवर है, जिसका अर्थ है कि हम अपने कोड का वास्तविक काम न केवल एक फ्लैश एलईडी द्वारा देखेंगे। लेकिन पहले, चालक:
platform/protoboard/uart.c

 extern uint32_t platform_clock; void platform_uart_setup(uint32_t baud_rate) { NVIC_DisableIRQ(UART_IRQn); 

सक्षम होने पर सबसे पहले, हम एनवीआईसी पर रोक को बंद कर देंगे।

  LPC_SYSCON->SYSAHBCLKCTRL |= (1<<16); LPC_IOCON->PIO1_6 &= ~0x07; LPC_IOCON->PIO1_6 |= 0x01; LPC_IOCON->PIO1_7 &= ~0x07; LPC_IOCON->PIO1_7 |= 0x01; 

अगला, हम माइक्रोकंट्रोलर ब्लॉक को चालू करते हैं, जो पिन को कॉन्फ़िगर करने के लिए जिम्मेदार है, और उन्हें TXD / RXD कार्ट मोड में कॉन्फ़िगर करता है। इस कोड ने मेरा बहुत खून बहाया जब मैंने यह समझने की कोशिश की कि UART एक रिबूट के बाद काम क्यों नहीं करता है। सावधान रहें, कभी-कभी स्पष्ट चीजें डिफ़ॉल्ट रूप से बंद हो जाती हैं!

  LPC_SYSCON->SYSAHBCLKCTRL |= (1<<12); LPC_SYSCON->UARTCLKDIV = 0x1; 

अब आप UART को स्वयं चालू कर सकते हैं, और उसी समय इनपुट आवृत्ति विभक्त सेट कर सकते हैं।

  LPC_UART->LCR = 0x83; uint32_t Fdiv = platform_clock //   / LPC_SYSCON->SYSAHBCLKDIV //      / LPC_SYSCON->UARTCLKDIV //    UART / 16 //   16,   / baud_rate; // , ,   LPC_UART->DLM = Fdiv / 256; LPC_UART->DLL = Fdiv % 256; LPC_UART->FDR = 0x00 | (1 << 4) | 0; LPC_UART->LCR = 0x03; 

क्लासिक 8 एन 1 मोड के अलावा, हम बिटरेट सेट करने वाले आउटपुट डिवाइडर तक पहुंच खोलते हैं। हम विभाजकों की गणना करते हैं और उन्हें रजिस्टरों में लिखते हैं। जिज्ञासु के लिए, सूत्र मैनुअल के खंड 13.5.15 में है। इसके अलावा, यह और भी सटीक शरीर दर के लिए एक अतिरिक्त विभक्त का वर्णन करता है। मेरे परीक्षणों में, 9580 ने काफी अच्छा काम किया :-)

  LPC_UART->FCR = 0x07; volatile uint32_t unused = LPC_UART->LSR; while(( LPC_UART->LSR & (0x20|0x40)) != (0x20|0x40) ) ; while( LPC_UART->LSR & 0x01 ) { unused = LPC_UART->RBR; } 

हम फीफो को चालू करते हैं, रीसेट करते हैं, सुनिश्चित करें कि कुछ अजीब डेटा रजिस्टरों में दफन नहीं है।

  // NVIC_EnableIRQ(UART_IRQn); // LPC_UART->IER = 0b101; 

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

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

एक महत्वपूर्ण बिंदु: mbed में तीन UARTs बाहर प्रदर्शित किए गए हैं, और प्रत्येक के लिए कई पिन विकल्प हैं। चूंकि USB संचार में काफी अधिक कोड होगा, इसलिए आपको UART को FTDI केबल को हुक करना होगा, उदाहरण में ये P13 / P14 हैं।

संक्षेप में कहना

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

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

PS हमेशा की तरह, टेक्स्ट को प्रूफ करने के लिए बहुत से धन्यवाद।

यह काम क्रिएटिव कॉमन्स एट्रिब्यूशन-नॉन-कॉमर्शियल-नोएर्डीव्स 3.0 अनपोर्टेड के तहत लाइसेंस प्राप्त है । उदाहरणों के लिए प्रोग्राम टेक्स्ट यूनीलेंस लाइसेंस के तहत उपलब्ध है (जब तक कि फ़ाइल हेडर में स्पष्ट रूप से इंगित नहीं किया गया है)। यह कार्य विशेष रूप से शैक्षिक उद्देश्यों के लिए लिखा गया है और यह किसी भी तरह से लेखक के वर्तमान या पिछले नियोक्ताओं से संबद्ध नहीं है।