माइक्रोकंट्रोलर्स के लिए फर्मवेयर लिखना बंद करना और रहना शुरू करना

हैलो, मेरा नाम यूजीन है, और मैं माइक्रोकंट्रोलर के लिए फर्मवेयर लिखने से थक गया हूं। यह कैसे हुआ और इसके साथ क्या करना है, आइए इसका पता लगाते हैं।

जब आप बड़ी प्रोग्रामिंग C ++, जावा, पायथन आदि में काम करते हैं, तो आप ऐसा महसूस नहीं करते हैं कि छोटे और पॉट-बेलिड माइक्रोकंट्रोलर वापस जा रहे हैं। उनके अल्प औजारों और पुस्तकालयों के लिए। लेकिन कभी-कभी करने के लिए कुछ भी नहीं होता है, वास्तविक समय और स्वायत्तता के कार्य एक विकल्प नहीं छोड़ते हैं। लेकिन कुछ प्रकार के कार्य हैं जो इस क्षेत्र में हल करने के लिए जंगली हैं।

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

यह भी निराशाजनक है कि हमारे छोटे माइक्रोकंट्रोलर के लिए कोई वाद्य परीक्षण नहीं हैं। केवल फर्मवेयर के माध्यम से और परीक्षण करने के लिए डिबगर के माध्यम से।

और नए उपकरणों और बाह्य उपकरणों के साथ काम करने के अध्ययन के लिए बहुत प्रयास और समय की आवश्यकता होती है। एक त्रुटि और कार्यक्रम को हर बार फिर से चलाया और चलाया जाना चाहिए।

ऐसे प्रयोगों के लिए, REPL जैसी कोई चीज़ अधिक उपयुक्त होती है, ताकि आप बस और दर्द रहित तरीके से ये कर सकें, कम से कम तुच्छ बातें,

\

इस पर कैसे आना है, लेखों की यह श्रृंखला समर्पित है।

और इस बार मैं एक ऐसी परियोजना में आया था जहाँ पहले से ही सभी प्रकार के सेंसरों और अन्य चिप्स के साथ बहुत जटिल डिवाइस का परीक्षण करना आवश्यक था, जो कि बहुत सारे एमके बाह्य उपकरणों और विभिन्न इंटरफेस के एक गुच्छा का उपयोग करता था। विशेष मज़ा यह था कि मेरे पास बोर्ड के लिए फर्मवेयर स्रोत कोड नहीं थे, इसलिए सभी परीक्षणों को स्रोत कोड से ऑपरेटिंग समय का उपयोग किए बिना, स्क्रैच से लिखना होगा।

परियोजना ने दो महीने या तो (और सबसे अधिक संभावना है) के लिए एक अच्छे टोस्टमास्टर और दिलचस्प प्रतियोगिताओं का वादा किया।

ठीक है, यहाँ हम रोने वाले नहीं हैं। एक को फिर से सी और अंतहीन फर्मवेयर के wilds में डुबकी लगानी चाहिए, या इस पाठ को सुविधाजनक बनाने के लिए किसी चीज के साथ मना या आना चाहिए। अंत में, आलस्य और जिज्ञासा प्रगति का इंजन है।

पिछली बार, जब मैंने ओपनओसीडी को समझा था, तो मैं प्रलेखन में इस तरह के एक दिलचस्प बिंदु पर आया था

http://openocd.org/doc/html/General-Commands.html 15.4 Memory access commands mdw, mdh, mdb —         mww, mwh, mwb —        

दिलचस्प ... और उनके साथ परिधीय रजिस्टरों को पढ़ना और लिखना संभव है? .. यह संभव हो जाता है, और इसके अलावा, इन आदेशों को टीसीएल सर्वर के माध्यम से दूरस्थ रूप से निष्पादित किया जा सकता है, जो ओपनओसीडी शुरू होने पर शुरू होता है।

यहाँ stm32f103C8T6 के लिए एक निमिष एलईडी का एक उदाहरण है

 // Step 1: Enable the clock to PORT B RCC->APB2ENR |= RCC_APB2ENR_IOPCEN; // Step 2: Change PB0's mode to 0x3 (output) and cfg to 0x0 (push-pull) GPIOC->CRH = GPIO_CRH_MODE13_0 | GPIO_CRH_MODE13_1; // Step 3: Set PB0 high GPIOC->BSRR = GPIO_BSRR_BS13; // Step 4: Reset PB0 low GPIOC->BSRR = GPIO_BSRR_BR13; 

और OpenOCD कमांड का एक समान क्रम

 mww 0x40021018 0x10 mww 0x40011004 0x300000 mww 0x40011010 0x2000 mww 0x40011010 0x20000000 

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

कई को इंटरप्ट के साथ काम करने के बारे में अधिक याद होगा। लेकिन उन्हें हमेशा आवश्यकता नहीं होती है, और मेरे मामले में, आप उनके बिना कर सकते हैं।

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

अजगर पर बहुत अच्छा खाली।

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

पुस्तकालयों को अजगर तक पहुँचाना ... किसी दुःस्वप्न में हम ऐसा नहीं करेंगे। तो आपको इन पुस्तकालयों को C या ... C ++ में उपयोग करने की आवश्यकता है। और पेशेवरों में, आप लगभग सभी ऑपरेटरों को उनकी कक्षाओं के लिए ओवरराइड कर सकते हैं।

और हेडर फ़ाइलों में आधार पते, उनकी कक्षाओं की वस्तुओं के साथ बदल देते हैं।

उदाहरण के लिए, stm32f10x.h फ़ाइल में

 #define PERIPH_BB_BASE ((uint32_t)0x42000000) /*!< Peripheral base address in the bit-band region */ 

से बदलें

 class InterceptAddr; InterceptAddr addr; #define PERIPH_BB_BASE (addr) /*!< Peripheral base address in the bit-band region */ 

लेकिन पुस्तकालय में संकेत के साथ खेल कली में इस विचार काट ...

यहाँ एक उदाहरण stm32f10x_i2c.c फ़ाइल है:

 FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG) { __IO uint32_t i2creg = 0, i2cxbase = 0; …. /* Get the I2Cx peripheral base address */ i2cxbase = (uint32_t)I2Cx; …. 

इसलिए किसी भी तरह से अलग-अलग पते के पते को रोकना आवश्यक है। यह कैसे करना है शायद Valgrind पर एक नज़र के लायक है, कुछ भी नहीं है कि उसके पास एक ज्ञापन है। खैर, उसे वास्तव में पता होना चाहिए कि पते को कैसे रोकना है।

आगे देखते हुए, मैं कहूंगा कि वहाँ नहीं दिखना बेहतर है ... मैं लगभग पते के लिए कॉल को इंटरसेप्ट करने में कामयाब रहा। इसके अलावा लगभग सभी मामलों के लिए

 Int * p = ... *p = 0x123; 

पते को इंटरसेप्ट करना संभव है, लेकिन रिकॉर्ड किए गए डेटा को इंटरसेप्ट करना संभव नहीं था। केवल आंतरिक रजिस्टर का नाम जिसमें यह मूल्य निहित है, लेकिन जिसे मेमचेक से नहीं पहुँचा जा सकता है।

वास्तव में, Valgrind ने मुझे आश्चर्यचकित किया, प्राचीन राक्षस के अंदर libVEX का उपयोग किया जाता है, जिसके बारे में मुझे इंटरनेट पर कोई जानकारी नहीं मिली। यह अच्छा है कि हेडर फ़ाइलों में थोड़ा प्रलेखन पाया गया।

तब अन्य डीबीआई उपकरण थे।

फ्रीडा, डायनेमिक RIO, कुछ और, और अंत में पिंटूल मिला।

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

इसलिए, हमें विशिष्ट पतों पर लिखने और पढ़ने को रोकने की आवश्यकता है। आइए देखें कि इस https://godbolt.org/z/nJS9ci के लिए क्या निर्देश जिम्मेदार हैं।

X64 के लिए, यह दोनों कार्यों के लिए एक MOV होगा।

और x86 के लिए यह लिखने के लिए MOV और पढ़ने के लिए MOVZ होगा।

नोट: अनुकूलन को सक्षम नहीं करना सबसे अच्छा है, अन्यथा अन्य निर्देश सामने आ सकते हैं।

 INS_AddInstrumentFunction(EmulateLoad, 0); INS_AddInstrumentFunction(EmulateStore, 0); ..... static VOID EmulateLoad(INS ins, VOID *v) { // Find the instructions that move a value from memory to a register if ((INS_Opcode(ins) == XED_ICLASS_MOV || INS_Opcode(ins) == XED_ICLASS_MOVZX) && INS_IsMemoryRead(ins) && INS_OperandIsReg(ins, 0) && INS_OperandIsMemory(ins, 1)) { INS_InsertCall(ins, IPOINT_BEFORE, AFUNPTR(loadAddr2Reg), IARG_MEMORYREAD_EA, IARG_MEMORYREAD_SIZE, IARG_RETURN_REGS, INS_OperandReg(ins, 0), IARG_END); // Delete the instruction INS_Delete(ins); } } static VOID EmulateStore(INS ins, VOID *v) { if (INS_Opcode(ins) == XED_ICLASS_MOV && INS_IsMemoryWrite(ins) && INS_OperandIsMemory(ins, 0)) { if (INS_hasKnownMemorySize(ins)) { if (INS_OperandIsReg(ins, 1)) { INS_InsertCall(ins, IPOINT_BEFORE, AFUNPTR(multiMemAccessStore), IARG_MULTI_MEMORYACCESS_EA, IARG_REG_VALUE, INS_OperandReg(ins, 1), IARG_END); } else if (INS_OperandIsImmediate(ins, 1)) { INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)multiMemAccessStore, IARG_MULTI_MEMORYACCESS_EA, IARG_UINT64, INS_OperandImmediate(ins, 1), IARG_END); } } else { if (INS_OperandIsReg(ins, 1)) { INS_InsertCall(ins, IPOINT_BEFORE, AFUNPTR(storeReg2Addr), IARG_MEMORYWRITE_EA, IARG_REG_VALUE, INS_OperandReg(ins, 1), IARG_MEMORYWRITE_SIZE, IARG_END); } else if (INS_OperandIsImmediate(ins, 1)) { INS_InsertCall(ins, IPOINT_BEFORE, AFUNPTR(storeReg2Addr), IARG_MEMORYWRITE_EA, IARG_UINT64, INS_OperandImmediate(ins, 1), IARG_UINT32, IARG_MEMORYWRITE_SIZE, IARG_END); } } } } 

पते से पढ़ने के मामले में, हम loadAddr2Reg फ़ंक्शन को कॉल करते हैं और मूल निर्देश को हटाते हैं। इसके आधार पर, loadAddr2Reg को हमारे लिए आवश्यक मान वापस करना चाहिए।

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

आगे हमें यह देखने की जरूरत है कि हमें किन पतों को इंटरसेप्ट करना है, हमारे stm32f103C8T6 चिप के लिए मेमोरी मैप देखें:

हम SRAM और PERIPH_BASE के पते पर रुचि रखते हैं, अर्थात् 0x20000000 से 0x20000000 + 128 * 1024 और 0x40000000 से 0x40030000 तक। ठीक है, या बल्कि, काफी नहीं, जैसा कि हम रिकॉर्डिंग निर्देश को याद करते हैं, हम हटा नहीं सकते थे। इसलिए, इन पतों पर रिकॉर्ड sigfault में गिर जाएगा। इसके अलावा, इस संभावना की संभावना नहीं है कि इन पतों में हमारे प्रोग्राम का डेटा होगा, न कि इस चिप का दूसरा। इसलिए, हमें निश्चित रूप से उन्हें कहीं न कहीं ठीक करने की आवश्यकता है। चलो किसी प्रकार की सरणी पर कहते हैं।

हम आवश्यक आकार के सरणियों का निर्माण करते हैं, और फिर आधार पते परिभाषित में उनके संकेत स्थान देते हैं।

हमारे कार्यक्रम में, बजाय सुर्खियों में

 #define SRAM_BASE ((uint32_t)0x20000000) /*!< SRAM base address in the alias region */ #define PERIPH_BASE ((uint32_t)0x40000000) /*!< Peripheral base address in the alias region */ 

करना

  #define SRAM_BASE ((AddrType)pAddrSRAM) #define PERIPH_BASE ((AddrType)pAddrPERIPH) 

और जहां pAddrSRAM और pAddrPERIPH पूर्व-आवंटित सरणियों के संकेत हैं।

अब, हमारे PinTool क्लाइंट को किसी तरह यह बताने की जरूरत है कि हमने आवश्यक पतों की मरम्मत कैसे की।
सबसे आसान काम जो मुझे लग रहा था कि यह कैसे करना है एक फ़ंक्शन को रोकना है जो इस प्रारूप से एक सरणी संरचना लौटाता है:

 typedef struct { addr_t start_addr; //      addr_t end_addr; //   addr_t reference_addr; //   } memoryTranslate; 

उदाहरण के लिए, हमारी चिप के लिए यह इतना भरा होगा

 map->start_addr = (addr_t)pAddrSRAM; map->end_addr = 96*1024; map->reference_addr = (addr_t)0x20000000U; 

फ़ंक्शन को रोकना और उससे आवश्यक मान लेना मुश्किल नहीं है:

 IMG_AddInstrumentFunction(ImageReplace, 0); .... static memoryTranslate *replaceMemoryMapFun(CONTEXT *context, AFUNPTR orgFuncptr, sizeMemoryTranslate_t *size) { PIN_CallApplicationFunction(context, PIN_ThreadId(), CALLINGSTD_DEFAULT, orgFuncptr, NULL, PIN_PARG(memoryTranslate *), &addrMap, PIN_PARG(sizeMemoryTranslate_t *), size, PIN_PARG_END()); sizeMap = *size; return addrMap; } static VOID ImageReplace(IMG img, VOID *v) { RTN freeRtn = RTN_FindByName(img, NAME_MEMORY_MAP_FUNCTION); if (RTN_Valid(freeRtn)) { PROTO proto_free = PROTO_Allocate(PIN_PARG(memoryTranslate *), CALLINGSTD_DEFAULT, NAME_MEMORY_MAP_FUNCTION, PIN_PARG(sizeMemoryTranslate_t *), PIN_PARG_END()); RTN_ReplaceSignature(freeRtn, AFUNPTR(replaceMemoryMapFun), IARG_PROTOTYPE, proto_free, IARG_CONTEXT, IARG_ORIG_FUNCPTR, IARG_FUNCARG_ENTRYPOINT_VALUE, 0, IARG_END); } } 

और हमारे इंटरसेप्टेड फंक्शन को इस तरह बनाएं:

 memoryTranslate * getMemoryMap(sizeMemoryTranslate_t * size){ ... return memoryMap; } 

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

इस प्रकार, इंटरफेस और संचार की योजना इस प्रकार है:

0x123 पते को इंटरसेप्ट करने के उदाहरण पर एक सरलीकृत वर्कफ़्लो:

आइए एक नजर डालते हैं कि यहां क्या होता है:

पिनटूल क्लाइंट लॉन्च किया गया है, यह हमारे इंटरसेप्टर्स को इनिशियलाइज़ करता है, प्रोग्राम शुरू करता है
कार्यक्रम शुरू होता है, इसे कुछ थ्रेड सरणी पर रजिस्टरों के पते को संबोधित करने की आवश्यकता होती है, गेटमेरीपॉपर फ़ंक्शन को कहा जाता है, जिसे हमारा पिनटूल इंटरसेप्ट करता है। एक उदाहरण के लिए, रजिस्टरों में से एक 0x123 पते पर फ़्लिप किया गया है, हम इसे ट्रैक करेंगे
PinTool क्लाइंट डिस्सैगेटेड एड्रेस के मूल्यों को बचाता है
नियंत्रण वापस हमारे कार्यक्रम में स्थानांतरित करें
इसके अलावा, कहीं न कहीं हमारे ट्रैक किए गए पते पर एक रिकॉर्डिंग है 0x123। StoreReg2Addr फ़ंक्शन इसका ट्रैक रखता है
और OpenOCD क्लाइंट को लिखित अनुरोध भेजता है
क्लाइंट उत्तर देता है, जिसे पार्स किया गया है। यदि सब कुछ ठीक है, तो प्रोग्राम नियंत्रण रिटर्न देता है
इसके अलावा, कार्यक्रम में कहीं-कहीं पठन पता 0x123 पर होता है।
loadAddr2Reg इसे ट्रैक करता है और क्लाइंट को एक OpenOCD अनुरोध भेजता है।
OpenOCD क्लाइंट इसे प्रोसेस करता है और एक प्रतिक्रिया देता है
यदि सब कुछ ठीक है, लेकिन एमके रजिस्टर से मूल्य कार्यक्रम में वापस आ गया है
कार्यक्रम जारी है।
यह सब अभी के लिए है, पूर्ण स्रोत कोड और उदाहरण निम्नलिखित भागों में होंगे।