🎓 👊🏻 🗾 हम माइक्रोकंट्रोलर के लिए भारी सॉफ्टवेयर विकसित करने की प्रक्रिया को और अधिक सुविधाजनक बनाते हैं (नहीं) 💫 💰 🚇

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

लेख का उद्देश्य सी और / या सी ++ में एक परियोजना के निर्माण की विधि के बारे में बात करना है, जिसमें, कोड अनुभाग को बदलने के मामले में, जिसे सबसे अधिक बार डिबग किया जाता है, अधिकांश परियोजना को फिर से लिखने की आवश्यकता नहीं थी। और यह भी बताएं कि यह विधि हमेशा एक प्रभावी समाधान क्यों नहीं है।

रीडर आवश्यकताएँ

कथा के दौरान, मैं मानूंगा कि पाठक:

वह C और C ++ में धाराप्रवाह है;
कोर्टेक्स-एम 3 / कोर्टेक्स-एम 4 कोर (उदाहरण के लिए, stm32f4 श्रृंखला) पर आधारित माइक्रोकंट्रोलर्स के साथ काम करने का अनुभव है;
परियोजना के स्रोतों से अंतिम सिलाई फ़ाइल (योगिनी / बिन) का निर्माण करना जानता है;
कल्पना करता है कि लिंकर स्क्रिप्ट फाइलें किस लिए हैं;
पाठ, bss, डेटा और अन्य अनुभागों का एक विचार है;
किसी भी लिनक्स वितरण के साथ काम किया;
न्यूनतम मालिकानाश;
कोर्टेक्स-एम 3 / कॉर्टेक्स-एम 4 प्रोसेसर (टूलचेन आर्म-नो-ईबीबी) की वास्तुकला के लिए जीसीसी के साथ अनुभव है;
cmake के साथ प्रारंभिक कौशल है।

विधि का सार

माइक्रोकंट्रोलर्स के लिए एक "क्लासिक" परियोजना में, सभी अपरिवर्तनीय डेटा (पाठ, कृंतक अनुभाग, प्रारंभिक डेटा मान और अन्य) आमतौर पर "एक पंक्ति में" स्थित होते हैं, जो गैर-वाष्पशील मेमोरी के प्रारंभ पते से शुरू होते हैं (कोर्टेक्स-एम 3 / कोर्टेक्स-एम 4 कोर पर आधारित एक माइक्रोकंट्रोलर के मामले में - c) पता 0x08000000)। एक सरलीकृत रूप में, कॉर्टेक्स-एम 3 / कॉर्टेक्स-एम 4 कोर पर आधारित एक माइक्रोकंट्रोलर प्रोग्राम के गैर-वाष्पशील मेमोरी उपयोग मानचित्र, सी ++ का उपयोग करके लिखा गया है, कुछ इस तरह दिखता है:

इस तरह की परियोजना के लिए मेम फ़ाइल सबसे अधिक बार कुछ इस तरह दिखती है:

MEMORY { FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 768K RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 112K }

यहां, सभी गैर-वाष्पशील मेमोरी एक एकल विभाजन है जिसका नाम "FLASH" है, और सभी RAM "RAM" नाम का एक विभाजन है। इस रूप में, जब कोई कोड खंड बदलता है, तो बाकी सभी "शिफ्ट" होने लगते हैं। इससे बचने के लिए, आप फर्मवेयर फाइल को कुछ लॉजिकल ब्लॉक में "स्प्लिट" कर सकते हैं। उदाहरण के लिए, निम्नानुसार है:

बाधित वैक्टर की तालिका;
खुद के पुस्तकालय;
तीसरे पक्ष के पुस्तकालय (जिन्हें बदलने की योजना नहीं है);
अक्सर संशोधित कोड।

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

अनिवार्य रूप से बोलते हुए, स्थिर पुस्तकालयों को परियोजना में जोड़ा जाता है।

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

अगला, मैं विस्तार से वर्णन करूंगा कि इसे वास्तविक परियोजना पर कैसे लागू किया जाए। इस तरह के निर्णय के पेशेवरों और विपक्ष को लेख के अंत में दिया जाएगा।

प्रयोग के लिए क्षेत्र

इससे पहले कि मैं काम पर किसी भी तरह के इनोवेशन का सुझाव दूं, मैं अपने होम प्रोजेक्ट पर यह कोशिश करता हूं। चूंकि इसका आकार काम पर नियमित परियोजनाओं के आकार के करीब है, यह समझना संभव है कि नवाचार व्यवहार्य है या नहीं और यह किस बारीकियों को वहन करता है।

परियोजना विवरण

परियोजना में शामिल हैं:

C ++ 14 में मुख्य प्रोजेक्ट का कोड वर्चुअल टेबल्स, नए / डिलीट (फ्रीआरटीओएस के एक गुच्छा के माध्यम से काम करना), शेयर्ड_प्ट्र (और अन्य स्मार्ट पॉइंटर्स) और मानक सी ++ 14 लाइब्रेरी के अन्य प्रसन्नता का उपयोग करता है;
हार्डवेयर परिधीय बुनियादी ढाँचे को बनाए रखने के लिए 6 के बारे में और व्यावसायिक तर्क ( MakiseGUI ग्राफिक्स पुस्तकालय , प्रसंस्करण पर क्लिक करें, वसा ( FatFS ), आदि) के साथ काम करने के लिए FreeRTOS का उपयोग करना ;
बोर्ड पर हार्डवेयर बाह्य उपकरणों के साथ बातचीत के लिए अपने स्वयं के पुस्तकालयों के साथ 16 रिपॉजिटरी, सिस्टम कॉल के लिए स्टब्स, और बहुत कुछ;

असेंबली पैरामीटर -O0 -g3 के साथ, यूनिकोड, सिरिलिक और अन्य चीजों के समर्थन के साथ एक पूर्ण कार्यान्वयन में कोड लगभग 700 KB लेता है। हालांकि, वर्तमान चरण में, जब हार्डवेयर बाह्य उपकरणों स्थिर होते हैं, और केवल व्यावसायिक तर्क को डीबग करना पड़ता है, तो कोड को बदलने की मात्रा लगभग 20 KB है। इस कारण से, पहली नज़र में, ऐसा लगता है कि वर्तमान दृष्टिकोण समस्या का एक आदर्श समाधान है (कंप्यूटर पर सिमुलेशन के साथ विकल्प किसी कारण से नहीं माना जाता है)।

कार्रवाई की सूची

वर्णित विधि को लागू करने के लिए, आपको निम्न की आवश्यकता होगी:

सभी सबमॉड्यूल्स को स्थिर पुस्तकालयों के रूप में इकट्ठा करें (इस आइटम का विवरण इस लेख की पार्स की गई वस्तुओं की सूची में शामिल नहीं है);
पुनः लिखना mem.ld;
rewrite section.ld;
अंतिम बिन फ़ाइल से अनुभाग निकालने के लिए मुख्य परियोजना में एक उपयोगिता जोड़ें;
फ़र्मवेयर फ़ाइल को अपडेट करते समय माइक्रोकंट्रोलर की गैर-वाष्पशील मेमोरी को अपडेट करने के लिए स्क्रिप्ट पर कॉल करने के लिए प्रोजेक्ट में जोड़ें।

मेमोरियल को पुरस्कृत करना

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

यह भी ध्यान में रखा जाना चाहिए कि यदि कोई पुस्तकालय वैश्विक चर का उपयोग करता है, तो इस पुस्तकालय के लिए आपको लिंकिंग स्टेज पर रैम में जगह आरक्षित करने की आवश्यकता है। अन्यथा, आप अप्रिय कीड़े से सामना कर सकते हैं जो कि पकड़ना बेहद मुश्किल होगा। उदाहरण के लिए, FatFS लाइब्रेरी का कोड ROM_EXTERNAL_LIBRARIES अनुभाग में होगा, लेकिन इसके लिए बिल्ड स्टेज पर RAM में 4 बाइट्स की आवश्यकता होती है। इसलिए आपको यह सुनिश्चित करने की आवश्यकता है कि उन क्षेत्रों के लिए RAM में एक खंड है जो ROM_EXTERNAL_LIBRARIES के कोड का उपयोग करेगा। इस उदाहरण में, यह RAM_EXTERNAL_LIBRARIES है।

गैर-वाष्पशील मेमोरी में अंतिम खंड विशेष ध्यान देने योग्य है। सब कुछ जो पहले खंडों में विघटित नहीं हुआ था, सेक्शन.ल्ड (इसके बारे में बाद में) के अनुसार, इसमें जाएगा।

वर्तमान परियोजना के संदर्भ में, mem.ld ऐसा दिखेगा।

 /*    stm32f405rgt6   ChiptunePlayer-2.22-MainBoard-v2-Firmware. */ MEMORY { /*-----------------------------FLASH-------------------------------*/ /*  0-1  . */ ROM_BOOTLOADER (RX) : ORIGIN = 0x08000000, LENGTH = 32K /*  2     . */ ROM_SYSCFG_PAGE_1 (R) : ORIGIN = 0x08008000, LENGTH = 16K /*  3      . */ ROM_SYSCFG_PAGE_2 (R) : ORIGIN = 0x0800C000, LENGTH = 16K /*  4 . */ ROM_RESERVE (R) : ORIGIN = 0x08010000, LENGTH = 16K /*  5, 6, 7      (FATFS, FREERTOS...). */ ROM_EXTERNAL_LIBRARIES (RX) : ORIGIN = 0x08020000, LENGTH = 384K /*  8, 9      ( ,  ...). */ ROM_USER_LIBRARIES (RX) : ORIGIN = 0x08080000, LENGTH = 384K /*  5, 6      . */ ROM_MAIN_PROGRAMM (RX) : ORIGIN = 0x080E0000, LENGTH = 128K /*-----------------------------RAM---------------------------------*/ /*      RAM    . */ RAM_PAGE_1 (RW) : ORIGIN = 0x20000000, LENGTH = 112K RAM_PAGE_2 (RW) : ORIGIN = 0x2001C000, LENGTH = 16K /*           FATFS  FreeRTOS. */ RAM_EXTERNAL_LIBRARIES (RW) : ORIGIN = 0x20000000, LENGTH = 10K /*        . */ RAM_USER_LIBRARIES (RW) : ORIGIN = 0x20002800, LENGTH = 90K /*    RAM    . */ RAM_MAIN_PROGRAMM (RW) : ORIGIN = 0x20019000, LENGTH = 27K /*   RAM    .    FreeRTOS. */ RAM_MAIN_PROGRAMM_STACK (RW) : ORIGIN = 0x2001FC00, LENGTH = 1K }

खंड खंड

मौजूदा मेमोरी कार्ड को अनुभागों में विभाजित करने के बाद, यह वर्णित किया जाना चाहिए कि विभाजन क्या रखा जाएगा। प्रत्येक पुस्तकालय के लिए (यदि पुस्तकालय में एक संबंधित खंड है), तो .text, .rodata, .data, .bs और अन्य अनुभाग कहाँ स्थित हैं, यह इंगित करें। पुस्तकालय में उपलब्ध अनुभागों की सूची को objdump का उपयोग करके देखा जा सकता है। उदाहरण के लिए, libstdc ++ _ nano.a लाइब्रेरी के लिए, आपको यह निर्दिष्ट करने की आवश्यकता है कि टेक्स्ट, ARM.attributes, rodata, data, bss, COMMON सेक्शन कहां रखें।

वर्तमान परियोजना के संदर्भ में, अनुभाग.ल्ड इस तरह दिखेगा।

 /*             RAM. */ __estack = ORIGIN(RAM_MAIN_PROGRAMM_STACK) + LENGTH(RAM_MAIN_PROGRAMM_STACK); /*   . */ __stack_size = LENGTH(RAM_MAIN_PROGRAMM_STACK); /*     Reset_Handler. */ ENTRY(Reset_Handler) /*  . */ SECTIONS { /*---------------------ROM  ------------------------*/ .section_bootloader : ALIGN(4) { /*     .             .          .o ,     .*/ . = ALIGN(4); KEEP(*(.user_code_isr_vector .user_code_isr_vector*)) . = ALIGN(4); } >ROM_BOOTLOADER /*----------------ROM    -----------------*/ /* . */ .section_external_libraries_text : ALIGN(4) { /*  . */ . = ALIGN(4); *libstdc++_nano.a:*(.text .text*); . = ALIGN(4); *libgcc.a:*(.text .text*); . = ALIGN(4); *libg_nano.a:*(.text .text*); /*   */ . = ALIGN(4); *libSTM32F4_LOW_LEVEL_BY_ST.a:*(.text .text*); . = ALIGN(4); *libFATFS.a:*(.text .text*); . = ALIGN(4); *libFREERTOS.a:*(.text .text*); . = ALIGN(4); *libMAKISE_GUI.a:*(.text .text*); . = ALIGN(4); } >ROM_EXTERNAL_LIBRARIES /* ,   */ .section_external_libraries_required_by_the_compiler : ALIGN(4) { /*  . */ . = ALIGN(4); *libgcc.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libstdc++_nano.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libg_nano.a:*(.ARM.attributes .ARM.attributes*); /*   */ . = ALIGN(4); *libSTM32F4_LOW_LEVEL_BY_ST.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libFATFS.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libFREERTOS.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libMAKISE_GUI.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); } >ROM_EXTERNAL_LIBRARIES /*    . */ .section_external_libraries_rodata : ALIGN(4) { /*  . */ . = ALIGN(4); *libgcc.a:*(.rodata .rodata*); . = ALIGN(4); *libstdc++_nano.a:*(.rodata .rodata*); . = ALIGN(4); *libg_nano.a:*(.rodata .rodata*); /*   */ . = ALIGN(4); *libSTM32F4_LOW_LEVEL_BY_ST.a:*(.rodata .rodata*); . = ALIGN(4); *libFATFS.a:*(.rodata .rodata*); . = ALIGN(4); *libFREERTOS.a:*(.rodata .rodata*); . = ALIGN(4); *libMAKISE_GUI.a:*(.rodata .rodata*); . = ALIGN(4); } >ROM_EXTERNAL_LIBRARIES /*----------------------- ---------------------*/ /* . */ .section_user_libraries_text : ALIGN(4) { . = ALIGN(4); *libUSER_FREERTOS_LEVEL.a:*(.text .text*); . = ALIGN(4); *libUSER_BSP_LEVEL.a:*(.text .text*); . = ALIGN(4); *libMC_INTERRUPT.a:*(.text .text*); . = ALIGN(4); *libMC_HARDWARE.a:*(.text .text*); . = ALIGN(4); *libPCB_HARDWARE.a:*(.text .text*); . = ALIGN(4); *libUSER_STARTUP.a:*(.text .text*); . = ALIGN(4); *libBUTTONS.a:*(.text .text*); . = ALIGN(4); *libCHIPTUNE.a:*(.text .text*); . = ALIGN(4); *libDIGITAL_POTENTIOMETER.a:*(.text .text*); . = ALIGN(4); *libLCD_DRIVER.a:*(.text .text*); . = ALIGN(4); *libMAKISE_GUI_ELEMENTS_BY_VADIMATORIK_ELEMENTS_BY_VADIMATORIK.a:*(.text .text*); . = ALIGN(4); *libMC_HARDWARE_INTERFACES_IMPLEMENTATION_FOR_STM32.a:*(.text .text*); . = ALIGN(4); *libMICROSD_LOW_LEVEL_DRIVER.a:*(.text .text*); . = ALIGN(4); *libSHIFT_REGISTER.a:*(.text .text*); . = ALIGN(4); *libWAVE_GENERATORS.a:*(.text .text*); . = ALIGN(4); *libRUN_TIME_LOGGER.a:*(.text .text*); . = ALIGN(4); } >ROM_USER_LIBRARIES /* ,   */ .section_user_libraries_required_by_the_compiler : ALIGN(4) { . = ALIGN(4); *libUSER_FREERTOS_LEVEL.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libUSER_BSP_LEVEL.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libMC_INTERRUPT.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libMC_HARDWARE.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libPCB_HARDWARE.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libUSER_STARTUP.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libUSER_CODE.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libBUTTONS.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libCHIPTUNE.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libDIGITAL_POTENTIOMETER.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libLCD_DRIVER.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libMAKISE_GUI_ELEMENTS_BY_VADIMATORIK_ELEMENTS_BY_VADIMATORIK.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libMC_HARDWARE_INTERFACES_IMPLEMENTATION_FOR_STM32.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libMICROSD_LOW_LEVEL_DRIVER.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libSHIFT_REGISTER.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libWAVE_GENERATORS.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); *libRUN_TIME_LOGGER.a:*(.ARM.attributes .ARM.attributes*); . = ALIGN(4); } >ROM_EXTERNAL_LIBRARIES /*    . */ .section_user_libraries_rodata : ALIGN(4) { . = ALIGN(4); *libUSER_FREERTOS_LEVEL.a:*(.rodata .rodata*); . = ALIGN(4); *libUSER_BSP_LEVEL.a:*(.rodata .rodata*); . = ALIGN(4); *libMC_INTERRUPT.a:*(.rodata .rodata*); . = ALIGN(4); *libMC_HARDWARE.a:*(.rodata .rodata*); . = ALIGN(4); *libPCB_HARDWARE.a:*(.rodata .rodata*); . = ALIGN(4); *libUSER_STARTUP.a:*(.rodata .rodata*); . = ALIGN(4); *libBUTTONS.a:*(.rodata .rodata*); . = ALIGN(4); *libCHIPTUNE.a:*(.rodata .rodata*); . = ALIGN(4); *libDIGITAL_POTENTIOMETER.a:*(.rodata .rodata*); . = ALIGN(4); *libLCD_DRIVER.a:*(.rodata .rodata*); . = ALIGN(4); *libMAKISE_GUI_ELEMENTS_BY_VADIMATORIK_ELEMENTS_BY_VADIMATORIK.a:*(.rodata .rodata*); . = ALIGN(4); *libMC_HARDWARE_INTERFACES_IMPLEMENTATION_FOR_STM32.a:*(.rodata .rodata*); . = ALIGN(4); *libMICROSD_LOW_LEVEL_DRIVER.a:*(.rodata .rodata*); . = ALIGN(4); *libSHIFT_REGISTER.a:*(.rodata .rodata*); . = ALIGN(4); *libWAVE_GENERATORS.a:*(.rodata .rodata*); . = ALIGN(4); *libRUN_TIME_LOGGER.a:*(.rodata .rodata*); . = ALIGN(4); } >ROM_USER_LIBRARIES /*------------------------- ------------------------*/ /* . */ .section_user_code_text : ALIGN(4) { . = ALIGN(4); *(.text .text.*) . = ALIGN(4); } >ROM_MAIN_PROGRAMM /* ,   */ .sections_user_code_required_by_the_compiler : ALIGN(4) { . = ALIGN(4); *(.glue_7 .glue_7*) /*  -  ARMv7 */ . = ALIGN(4); *(.glue_7t .glue_7t*) . = ALIGN(4); *(.vfp11_veneer .vfp11_veneer*) /*   . */ . = ALIGN(4); *(.v4_bx .v4_bx*) . = ALIGN(4); *(.iplt .iplt*) . = ALIGN(4); *(.rel.dyn .rel.dyn*) . = ALIGN(4); KEEP(*(.eh_frame .eh_frame*)) /*     CPP. */ . = ALIGN(4); *(.eh_framehdr .eh_framehdr*) . = ALIGN(4); *(.ARM.attributes .ARM.attributes.*) /*    ,  . */ . = ALIGN(4); *(vtable) /* C++ virtual tables */ PROVIDE_HIDDEN (__preinit_array_start = .); /*  ,   . */ . = ALIGN(4); KEEP(*(.preinit_array_sysinit .preinit_array_sysinit*)) . = ALIGN(4); KEEP(*(.preinit_array_platform .preinit_array_platform.*)) . = ALIGN(4); KEEP(*(.preinit_array .preinit_array.*)) PROVIDE_HIDDEN (__preinit_array_end = .); PROVIDE_HIDDEN (__init_array_start = .); /*    . */ . = ALIGN(4); KEEP(*(SORT(.init_array.*))) . = ALIGN(4); KEEP(*(.init_array)) . = ALIGN(4); PROVIDE_HIDDEN (__init_array_end = .); PROVIDE_HIDDEN (__fini_array_start = .); /*    . */ . = ALIGN(4); KEEP(*(SORT(.fini_array.*))) . = ALIGN(4); KEEP(*(.fini_array)) . = ALIGN(4); PROVIDE_HIDDEN (__fini_array_end = .); . = ALIGN(4); KEEP(*(.cfmconfig)) . = ALIGN(4); *(.after_vectors .after_vectors.*) . = ALIGN(4); } >ROM_MAIN_PROGRAMM /*    . */ .section_user_code_rodata : ALIGN(4) { . = ALIGN(4); *(.rodata .rodata.*) . = ALIGN(4); } >ROM_MAIN_PROGRAMM /*  stack trace. */ .ARM.exidx : { . = ALIGN(4); *(.ARM.extab* .gnu.linkonce.armextab.*) . = ALIGN(4); *(.ARM.exidx* .gnu.linkonce.armexidx.*) . = ALIGN(4); } > ROM_MAIN_PROGRAMM /*-------------------------------RAM-----------------------------*/ /*    . */ .section_external_libraries_data : ALIGN(4) { . = ALIGN(4); __external_lib_data_start = . ; /*  . */ . = ALIGN(4); *libgcc.a:*(.data .data*); . = ALIGN(4); *libstdc++_nano.a:*(.data .data*); . = ALIGN(4); *libg_nano.a:*(.data .data*); /*   */ . = ALIGN(4); *libSTM32F4_LOW_LEVEL_BY_ST.a:*(.data .data*); . = ALIGN(4); *libFATFS.a:*(.data .data*); . = ALIGN(4); *libFREERTOS.a:*(.data .data*); . = ALIGN(4); *libMAKISE_GUI.a:*(.data .data*); . = ALIGN(4); __external_lib_data_end = . ; } >RAM_EXTERNAL_LIBRARIES AT> ROM_EXTERNAL_LIBRARIES /*       RAM */ .section_external_libraries_bss : ALIGN(4) { . = ALIGN(4); __external_lib_bss_start = .; /*  . */ . = ALIGN(4); *libgcc.a:*(.bss .bss*); . = ALIGN(4); *libstdc++_nano.a:*(.bss .bss*); . = ALIGN(4); *libg_nano.a:*(*COMMON); . = ALIGN(4); *libgcc.a:*(*COMMON); . = ALIGN(4); *libstdc++_nano.a:*(*COMMON); . = ALIGN(4); *libg_nano.a:*(*COMMON); /*   */ . = ALIGN(4); *libSTM32F4_LOW_LEVEL_BY_ST.a:*(.bss .bss*); . = ALIGN(4); *libFATFS.a:*(.bss .bss*); . = ALIGN(4); *libFREERTOS.a:*(.bss .bss*); . = ALIGN(4); *libMAKISE_GUI.a:*(.bss .bss*); . = ALIGN(4); *libSTM32F4_LOW_LEVEL_BY_ST.a:*(*COMMON); . = ALIGN(4); *libFATFS.a:*(*COMMON); . = ALIGN(4); *libFREERTOS.a:*(*COMMON); . = ALIGN(4); *libMAKISE_GUI.a:*(*COMMON); . = ALIGN(4); __external_lib_bss_end = .; } >RAM_EXTERNAL_LIBRARIES /*    . */ .section_user_libraries_data : ALIGN(4) { . = ALIGN(4); __user_lib_data_start = . ; . = ALIGN(4); *libUSER_FREERTOS_LEVEL.a:*(.data .data*); . = ALIGN(4); *libUSER_BSP_LEVEL.a:*(.data .data*); . = ALIGN(4); *libMC_INTERRUPT.a:*(.data .data*); . = ALIGN(4); *libMC_HARDWARE.a:*(.data .data*); . = ALIGN(4); *libPCB_HARDWARE.a:*(.data .data*); . = ALIGN(4); *libUSER_STARTUP.a:*(.data .data*); . = ALIGN(4); *libBUTTONS.a:*(.data .data*); . = ALIGN(4); *libCHIPTUNE.a:*(.data .data*); . = ALIGN(4); *libDIGITAL_POTENTIOMETER.a:*(.data .data*); . = ALIGN(4); *libLCD_DRIVER.a:*(.data .data*); . = ALIGN(4); *libMAKISE_GUI_ELEMENTS_BY_VADIMATORIK_ELEMENTS_BY_VADIMATORIK.a:*(.data .data*); . = ALIGN(4); *libMC_HARDWARE_INTERFACES_IMPLEMENTATION_FOR_STM32.a:*(.data .data*); . = ALIGN(4); *libMICROSD_LOW_LEVEL_DRIVER.a:*(.data .data*); . = ALIGN(4); *libSHIFT_REGISTER.a:*(.data .data*); . = ALIGN(4); *libWAVE_GENERATORS.a:*(.data .data*); . = ALIGN(4); *libRUN_TIME_LOGGER.a:*(.data .data*); . = ALIGN(4); __user_lib_data_end = . ; } >RAM_USER_LIBRARIES AT> ROM_USER_LIBRARIES .section_user_libraries_bss : ALIGN(4) { . = ALIGN(4); __user_lib_bss_start = .; . = ALIGN(4); *libUSER_FREERTOS_LEVEL.a:*(.bss .bss*); . = ALIGN(4); *libUSER_BSP_LEVEL.a:*(.bss .bss*); . = ALIGN(4); *libMC_INTERRUPT.a:*(.bss .bss*); . = ALIGN(4); *libMC_HARDWARE.a:*(.bss .bss*); . = ALIGN(4); *libPCB_HARDWARE.a:*(.bss .bss*); . = ALIGN(4); *libUSER_CODE.a:*(.bss .bss*); . = ALIGN(4); *libBUTTONS.a:*(.bss .bss*); . = ALIGN(4); *libCHIPTUNE.a:*(.bss .bss*); . = ALIGN(4); *libDIGITAL_POTENTIOMETER.a:*(.bss .bss*); . = ALIGN(4); *libLCD_DRIVER.a:*(.bss .bss*); . = ALIGN(4); *libMAKISE_GUI_ELEMENTS_BY_VADIMATORIK_ELEMENTS_BY_VADIMATORIK.a:*(.bss .bss*); . = ALIGN(4); *libMC_HARDWARE_INTERFACES_IMPLEMENTATION_FOR_STM32.a:*(.bss .bss*); . = ALIGN(4); *libMICROSD_LOW_LEVEL_DRIVER.a:*(.bss .bss*); . = ALIGN(4); *libSHIFT_REGISTER.a:*(.bss .bss*); . = ALIGN(4); *libWAVE_GENERATORS.a:*(.bss .bss*); . = ALIGN(4); *libUSER_FREERTOS_LEVEL.a:*(.bss .bss*); . = ALIGN(4); *libRUN_TIME_LOGGER.a:*(.bss .bss*); . = ALIGN(4); *libUSER_BSP_LEVEL.a:*(*COMMON); . = ALIGN(4); *libMC_INTERRUPT.a:*(*COMMON); . = ALIGN(4); *libMC_HARDWARE.a:*(*COMMON); . = ALIGN(4); *libPCB_HARDWARE.a:*(*COMMON); . = ALIGN(4); *libUSER_CODE.a:*(*COMMON); . = ALIGN(4); *libBUTTONS.a:*(*COMMON); . = ALIGN(4); *libCHIPTUNE.a:*(*COMMON); . = ALIGN(4); *libDIGITAL_POTENTIOMETER.a:*(*COMMON); . = ALIGN(4); *libLCD_DRIVER.a:*(*COMMON); . = ALIGN(4); *libMAKISE_GUI_ELEMENTS_BY_VADIMATORIK_ELEMENTS_BY_VADIMATORIK.a:*(*COMMON); . = ALIGN(4); *libMC_HARDWARE_INTERFACES_IMPLEMENTATION_FOR_STM32.a:*(*COMMON); . = ALIGN(4); *libMICROSD_LOW_LEVEL_DRIVER.a:*(*COMMON); . = ALIGN(4); *libSHIFT_REGISTER.a:*(*COMMON); . = ALIGN(4); *libWAVE_GENERATORS.a:*(*COMMON); . = ALIGN(4); *libRUN_TIME_LOGGER.a:*(.COMMON*); . = ALIGN(4); __user_lib_bss_end = .; } >RAM_USER_LIBRARIES /*    . */ .section_user_code_data : ALIGN(4) { . = ALIGN(4); __user_code_data_start = . ; . = ALIGN(4); *(.data .data.*) . = ALIGN(4); __user_code_data_end = . ; } >RAM_MAIN_PROGRAMM AT> ROM_MAIN_PROGRAMM .section_user_code_bss : ALIGN(4) { . = ALIGN(4); __bss_start__ = .; __user_code_bss_start = .; *(.bss .bss.*) *(COMMON) . = ALIGN(4); __bss_end__ = .; __user_code_bss_end = .; } >RAM_MAIN_PROGRAMM __external_lib_data_in_rom_start = LOADADDR(.section_external_libraries_data); __user_lib_data_in_rom_start = LOADADDR(.section_user_libraries_data); __user_code_data_in_rom_start = LOADADDR(.section_user_code_data); /*------------------------- -----------------*/ /* Stabs debugging sections. */ .stab 0 : { *(.stab) } .stabstr 0 : { *(.stabstr) } .stab.excl 0 : { *(.stab.excl) } .stab.exclstr 0 : { *(.stab.exclstr) } .stab.index 0 : { *(.stab.index) } .stab.indexstr 0 : { *(.stab.indexstr) } .comment 0 : { *(.comment) } /* * DWARF debug sections. * Symbols in the DWARF debugging sections are relative to the beginning * of the section so we begin them at 0. */ /* DWARF 1 */ .debug 0 : { *(.debug) } .line 0 : { *(.line) } /* GNU DWARF 1 extensions */ .debug_srcinfo 0 : { *(.debug_srcinfo) } .debug_sfnames 0 : { *(.debug_sfnames) } /* DWARF 1.1 and DWARF 2 */ .debug_aranges 0 : { *(.debug_aranges) } .debug_pubnames 0 : { *(.debug_pubnames) } /* DWARF 2 */ .debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) } .debug_abbrev 0 : { *(.debug_abbrev) } .debug_line 0 : { *(.debug_line) } .debug_frame 0 : { *(.debug_frame) } .debug_str 0 : { *(.debug_str) } .debug_loc 0 : { *(.debug_loc) } .debug_macinfo 0 : { *(.debug_macinfo) } /* SGI/MIPS DWARF 2 extensions */ .debug_weaknames 0 : { *(.debug_weaknames) } .debug_funcnames 0 : { *(.debug_funcnames) } .debug_typenames 0 : { *(.debug_typenames) } .debug_varnames 0 : { *(.debug_varnames) } .debug_macro 0 : { *(.debug_macro) } .debug_ranges 0 : { *(.debug_ranges) } }

अंतिम बिन फ़ाइल से अनुभाग निकालने के लिए मुख्य परियोजना में एक उपयोगिता जोड़ें

दुर्भाग्य से, एल्फ फाइल से विशिष्ट पतों के बीच कोड निकालने के लिए objcopy या objdump में झंडे ढूंढना संभव नहीं था। एक ध्वज है - अकेला-खंड , हालांकि, यह इस तथ्य को ध्यान में नहीं रखता है कि अनुभाग में सभी अनुभागों के सूचीबद्ध होने के बाद, डिबगिंग जानकारी अभी भी गैर-वाष्पशील मेमोरी में रखी गई है। इसके बिना, टुकड़ों से इकट्ठा किया गया अंतिम फर्मवेयर, (स्पष्ट कारणों के लिए) काम नहीं करेगा। इसलिए, मुझे एक साधारण उपयोगिता लिखनी थी जो एक सामान्य बिन फ़ाइल लेती है और निर्दिष्ट पते सीमा के लिए एक अलग फ़ाइल में आवश्यक अनुभाग निकालती है। हालांकि, निम्नलिखित बारीकियां यहां उठती हैं। डिफ़ॉल्ट रूप से, objcopy 0s के साथ वर्गों के बीच की जगह को भरता है। हालाँकि, फ़्लैश मेमोरी में खाली जगह 0xFF है। इस समस्या को हल करने के लिए, आपको आउटपुट बिन फ़ाइल को फ्लैग --gap-fill = 0xff के साथ लिखना होगा।

फर्मवेयर फ़ाइल को अपडेट करते समय माइक्रोकंट्रोलर की गैर-वाष्पशील मेमोरी को अपडेट करने के लिए स्क्रिप्ट पर कॉल करने के लिए प्रोजेक्ट में जोड़ें

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

तुलना स्क्रिप्ट कोड

 #!/bin/bash # # $1 -  .   ,    . # $2 -     elf . # $3 -      STM32. # echo "Old file name: $1" echo "New file name: $2" # ,     . flag_rewrite=0 #    ,         #  ,      (   #     ). #    ,   ,   -    #  ,     .  ,   . if [ -e $1 ] then #         . echo "Both files exist." #  md5   ,     . buf=$(md5sum $1 --binary) md5_old=${buf:0:32} #      md5   . #   32 . buf=$(md5sum $2 --binary) md5_new=${buf:0:32} echo "Started file comparison." if [ $md5_old == $md5_new ] then #     ,  . echo "The file has not been updated." echo "The new file will be deleted." rm $2 echo "Removed." else #   ,    . echo "The file has been modified." echo "Old will be replaced by new." mv $2 $1 echo "Replaced." flag_rewrite=1 #    . fi else #    . echo "Old file does not exist." echo "New will be renamed to old." mv $2 $1 #    . flag_rewrite=1 #    . echo "Renamed." fi #       ,     . if [ $flag_rewrite -eq 1 ] then echo "Started flashing." echo "CMD params: $3" $3 fi

प्रोजेक्ट में ही, आप cmake फंक्शन को कॉल कर सकते हैं, जो हर जरूरी काम करेगा:

Cmake अद्यतन समारोह

 function(write_sector SECTOR ADDR_BASE ADDR_START ADDR_END) add_custom_command(TARGET ${PROJECT_NAME}.elf POST_BUILD COMMAND ${ARM_OBJCOPY} --output-target=binary --gap-fill=0xff ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.elf ${PROJECT_BINARY_DIR}/${PROJECT_NAME}_all.bin COMMENT "Creating a binary file of the <<${SECTOR}>> sector" COMMAND ${BIN_EXTRACTOR} -p ${PROJECT_BINARY_DIR}/${PROJECT_NAME}_all.bin -o ${PROJECT_BINARY_DIR}/${PROJECT_NAME}_section_${SECTOR}_new.bin -b ${ADDR_BASE} -s ${ADDR_START} -e ${ADDR_END} COMMAND cd ${CMAKE_SOURCE_DIR} && ./cmp.sh ${PROJECT_BINARY_DIR}/${PROJECT_NAME}_section_${SECTOR}.bin ${PROJECT_BINARY_DIR}/${PROJECT_NAME}_section_${SECTOR}_new.bin "${STM32PROG} -c port=${STM32PROG_PORT} freq=${STM32PROG_FREQ} -w ${PROJECT_BINARY_DIR}/${PROJECT_NAME}_section_${SECTOR}.bin ${ADDR_START}") endfunction(write_sector)

लेखन के लिए फ़ंक्शन stm32programmer का उपयोग करता है।

प्रोजेक्ट कोड से फ़ंक्शन का उपयोग करने का एक उदाहरण

 if (STM32PROG_USE STREQUAL "ON") write_sector("bootloader" ${SECTION_BOOTLOADER_ADDRESS} ${SECTION_BOOTLOADER_ADDRESS} ${SECTION_SYSCFG_PAGE_1_ADDRESS}) write_sector("external_libraries" ${SECTION_BOOTLOADER_ADDRESS} ${SECTION_EXTERNAL_LIB_ADDRESS} ${SECTION_USER_LIBRARIES_ADDRESS}) write_sector("user_libraries" ${SECTION_BOOTLOADER_ADDRESS} ${SECTION_USER_LIBRARIES_ADDRESS} ${SECTION_USER_CODE_ADDRESS}) write_sector("main_programm" ${SECTION_BOOTLOADER_ADDRESS} ${SECTION_USER_CODE_ADDRESS} ${ADDR_END_FLASH}) endif ()

निष्कर्ष

इस दृष्टिकोण के लाभ:

95% मामलों में, वास्तव में जो आवश्यक है वह अपडेट किया गया है;

इस दृष्टिकोण के विपक्ष:

गति में कोई लाभ नहीं है, क्योंकि प्रत्येक फर्मवेयर से पहले गैर-वाष्पशील मेमोरी को चमकाने के लिए माइक्रोकंट्रोलर में बूटलोडर को लोड करना आवश्यक होता है (यह स्वचालित रूप से stm32programmer द्वारा किया जाता है)। इसके विपरीत, जब परियोजना पूरी तरह से आश्वस्त हो जाती है, तो आपको अक्सर सभी वर्गों को फिर से सीवे करना पड़ता है;
section.ld का आकार इसमें कुछ भी जोड़ने या बदलने की किसी भी इच्छा को हतोत्साहित करता है। यदि आपको इस पद्धति को एक वास्तविक परियोजना में लागू करने की आवश्यकता है, तो आपको इस फ़ाइल को संपादित करने के लिए एक सुविधाजनक GUI लिखना होगा;
, , , ( , ) :).

. CLion-, bin .

हम माइक्रोकंट्रोलर के लिए भारी सॉफ्टवेयर विकसित करने की प्रक्रिया को और अधिक सुविधाजनक बनाते हैं (नहीं)