🙌🏼 🏌️ 👨🏿 एसटीएम 32 पार्ट 2: इनिशियलाइज़ेशन 🌊 🥄 👷

प्रोग्रामिंग कुछ बड़े और असंभव को कुछ छोटे और बहुत वास्तविक में तोड़ रहा है।

सभी को नमस्कार, के साथ शुरू करने के लिए, मैं मेरी पहली (घृणित) पोस्ट को याद करने के लिए मध्यस्थों को धन्यवाद देना चाहूंगा, और माँ को नमस्ते कहना चाहूंगा! और साथ ही मैं उन सभी पाठकों और लोगों को भी धन्यवाद देना चाहूंगा जिन्होंने मेरी गलतियों को इंगित किया और उन्हें ठीक करने में मदद की। मैं तुरंत एक आरक्षण करता हूं कि रूसी में मैंने ग्रेड 6 से नहीं लिखा, सामान्य तौर पर, नाराज मत हो।

STM32 भाग 1: मूल बातें

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

extern void *_estack;

void Reset_Handler();

void *vectors[] __attribute__((section(".isr_vector"), used)) = {
    &_estack,
    &Reset_Handler
};

void __attribute__((naked, noreturn)) Reset_Handler()
{
    while(1);
}

यदि यह कोड किसी के लिए स्पष्ट नहीं है, तो आप इसके बारे में यहां पढ़ सकते हैं (लेख फव्वारा नहीं है, लेकिन समझाने की कोशिश की गई है)।

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

(उन लोगों के लिए जो अभी भी नहीं जानते हैं कि वेक्टर क्या है, यह पते के लिए एक संकेतक है, उर्फ "पॉइंटर")।

हम अपने कोड को पूरक करते हैं, और फिर मैं समझाऊंगा कि मैंने क्या किया।

extern void *_estack;

void Reset_Handler();
void Default_Handler();

void NMI_Handler()   __attribute__((weak, alias("Default_Handler")));
void HardFault_Handler()   __attribute__((weak, alias("Default_Handler")));
//     

void *vectors[] __attribute__((section(".isr_vector"), used)) = {
    &_estack,
    &Reset_Handler
    &NMI_Handler,
    &HardFault_Handler
};

void __attribute__((naked, noreturn)) Reset_Handler()
{
    while(1);
}

void __attribute__((naked, noreturn)) Default_Handler(){
    while(1);
}

यहां मैंने एक नया फ़ंक्शन Default_Handler () जोड़ा; जो सभी व्यवधानों को संभाल लेगा, बिल्कुल। लेकिन साथ ही, __attribute__((weak, alias("Default_Handler")));मैंने यह भी नोट किया कि यदि समान नाम वाला कोई फ़ंक्शन घोषित किया जाता है, तो यह इस रुकावट का संचालक होगा। दूसरे शब्दों में, अभी यह Default_Handler के लिए एक उपनाम है। इसलिए हम आपके संदर्भ मैनुअल से सूची में सभी वैक्टर जोड़ सकते हैं। ऐसा इसलिए किया जाता है कि यदि आपने अचानक एक रुकावट का उपयोग करने का फैसला किया, लेकिन फ़ंक्शन हैंडलर बनाना भूल गया, तो सामान्य Default_Handler कहा जाता है।

मुझे लगता है कि वैक्टर के साथ इस बिंदु पर आप समाप्त कर सकते हैं और सेक्टरों के लिंक पर और लिंकर पर जा सकते हैं। शुरू करने के लिए, चलिए डेटा और bss क्षेत्रों के आरंभ को Reset_Handler के शरीर के साथ-साथ कई बाहरी चर जोड़कर अपने स्टार्टअप.c को फिर से अपडेट करें।

extern void *_sidata, *_sdata, *_edata, *_sbss, *_ebss;

void __attribute__((naked, noreturn)) Reset_Handler()
{


	void **pSource, **pDest;
	for (pSource = &_sidata, pDest = &_sdata; pDest != &_edata; pSource++, pDest++)
		*pDest = *pSource;

	for (pDest = &_sbss; pDest != &_ebss; pDest++)
		*pDest = 0;

	while(1);
}

इसलिए, नए चर, और फिर से उन्हें हमारे लिंकर स्क्रिप्ट में घोषित किया गया। पिछली स्क्रिप्ट को याद करें । और एक नए के साथ भी तुलना करें।

MEMORY{
	ROM(rx) : ORIGIN = 0x08000000, LENGTH = 1M
	SRAM (rwx):     ORIGIN = 0x20010000, LENGTH = 240K
}

_estack = LENGTH(SRAM) + ORIGIN(SRAM);

SECTIONS{
	.isr_vector : {
	KEEP(*(.isr_vector))
	} >ROM
	
	.text : {
        . = ALIGN(4);
        *(.text)
    } >ROM
	
	_sidata = LOADADDR(.data);
        .data : {
		. = ALIGN(4);
		_sdata = .;
		*(.data)
		. = ALIGN(4);
		_edata = .;
	} >SRAM AT>ROM
	
	.bss : {
		. = ALIGN(4);
		_sbss = .;
		*(.bss)
		. = ALIGN(4);
		_ebss = .;
	} >SRAM
}

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


        _sidata = LOADADDR(.data);
        .data : {
		. = ALIGN(4);
		_sdata = .;
		*(.data)
		. = ALIGN(4);
		_edata = .;
	} >SRAM AT>ROM

यह _sidata की घोषणा और असाइनमेंट के साथ शुरू होता है, इस समय, एक ऐसे मूल्य के बारे में जिसे हम नहीं समझते हैं। अगला, स्वयं अनुभाग का विवरण शुरू होता है। मैं आपको यहां ALIGN फ़ंक्शन के बारे में पढ़ने की सलाह देता हूं , लेकिन संक्षेप में, हम अपने बिंदु (वर्तमान पते) को एक मान देते हैं जो हमारे प्रोसेसर द्वारा अधिक आसानी से स्वीकार किया जाता है जब यह डेटा या निर्देशों को वहां से लोड करने का प्रयास करता है।

इसके अलावा _sdata, _edata, और अनुभाग का अंत शामिल हैं। लेकिन अनुभाग के अंत में बस वही है जो हमें चाहिए।SRAM AT>ROM। यह पंक्ति हमारे लिंकर को बताती है कि अनुभाग SRAM में है लेकिन यह खंड ROM या फ़्लैश मेमोरी में लोड है। अब हमारे _sidata वेरिएबल और LOADADDR फ़ंक्शन पर वापस जाएं। यह फ़ंक्शन हमें एक मान लौटाएगा जो लोडिंग सेक्शन के पते के बराबर होगा। यही है, हमने संकेत दिया कि अनुभाग को फ्लैश मेमोरी में लोड किया गया था, लेकिन हम इसे रैम में उपयोग करते हैं, और इस अनुभाग को स्थानांतरित करने के लिए, हमें फ्लैश मेमोरी में इसके पते को जानना होगा, जो कि LOADADDR फ़ंक्शन रिटर्न है। इस बीच, वेरिएबल _sdata और _edata रैम में अनुभाग के स्थान को इंगित करते हैं, जिससे हमें डेटा अनुभाग को मेमोरी के सही टुकड़े में लोड करने का अवसर मिलता है। मैं आपको याद दिलाता हूं कि यह वह इनिशियलाइज़ेशन कोड है जिसे हमने उपरोक्त सौदों के साथ पूरक किया है।

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

.text (ORIGIN(ROM_ITCM) + SIZEOF(.isr_vector)): {
        . = ALIGN(4);
        *(.text)
    } AT>ROM_AXIM

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

इस स्तर पर, वर्गों को लोड किया जाता है जहां आवश्यक और आरंभिक होता है। आगे के कोड लेखन के लिए हमारे पास एक कार्यशील आधार है। अगले लेख में, हम अपने पहले ड्राइवर को लिखेंगे और एक एलईडी ब्लिंक करेंगे।

आप सभी का ध्यान, और आपके प्रयासों में सफलता के लिए धन्यवाद।

एसटीएम 32 पार्ट 2: इनिशियलाइज़ेशन

More articles: