📛 🥞 🥊 RTOS के बारे में पूरी सच्चाई। अनुच्छेद # 30 न्यूक्लियस एसई इनिशियलाइजेशन एंड स्टार्टअप प्रोसीजर 🖖🏻 🦀 👩🏽‍🎨

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

एम्बेडेड सिस्टम के लिए ओएस को भी इसी तरह से इनिशियलाइज़ किया जा सकता है। और वास्तव में, डेस्कटॉप ऑपरेटिंग सिस्टम के आधार पर विकसित एम्बेडेड ऑपरेटिंग सिस्टम लोड किए गए हैं। लेकिन अधिकांश "क्लासिक" आरटीओएस में, एक बहुत सरल (और इसलिए तेज) विधि का उपयोग किया जाता है।

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

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

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

स्मृति आरंभीकरण

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

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

न्यूक्लियस एसई रैम में "निरंतर" डेटा संग्रहीत नहीं करता है, जो आमतौर पर छोटी प्रणालियों में कम आपूर्ति में होता है। कर्नेल ऑब्जेक्ट्स का वर्णन करने के लिए जटिल डेटा संरचनाओं का उपयोग करने के बजाय, तालिकाओं (सरणियों) के सेट का उपयोग किया जाता है, जो आसानी से रॉम या रैम में रखा जाता है, जो आवश्यकता पर निर्भर करता है।

मुख्य () फ़ंक्शन

निम्नलिखित न्यूक्लियस एसई के मुख्य () फ़ंक्शन के लिए पूर्ण कोड है:

void main(void) { NUSE_Init(); /* initialize kernel data */ /* user initialization code here */ NUSE_Scheduler(); /* start tasks */ }

संचालन का क्रम काफी सरल है:

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

NUSE_Init () फ़ंक्शन

यह फ़ंक्शन सभी न्यूक्लियस एसई कर्नेल चर और डेटा संरचनाओं को आरंभ करता है।

नीचे पूर्ण फ़ंक्शन कोड है:

 void NUSE_Init(void) { U8 index; /* global data */ NUSE_Task_Active = 0; NUSE_Task_State = NUSE_STARTUP_CONTEXT; #if NUSE_SYSTEM_TIME_SUPPORT NUSE_Tick_Clock = 0; #endif #if NUSE_SCHEDULER_TYPE == NUSE_TIME_SLICE_SCHEDULER NUSE_Time_Slice_Ticks = NUSE_TIME_SLICE_TICKS; #endif /* tasks */ #if ((NUSE_SCHEDULER_TYPE != NUSE_RUN_TO_COMPLETION_SCHEDULER) || NUSE_SIGNAL_SUPPORT || NUSE_TASK_SLEEP || NUSE_SUSPEND_ENABLE || NUSE_SCHEDULE_COUNT_SUPPORT) for (index=0; index<NUSE_TASK_NUMBER; index++) { NUSE_Init_Task(index); } #endif /* partition pools */ #if NUSE_PARTITION_POOL_NUMBER != 0 for (index=0; index<NUSE_PARTITION_POOL_NUMBER; index++) { NUSE_Init_Partition_Pool(index); } #endif /* mailboxes */ #if NUSE_MAILBOX_NUMBER != 0 for (index=0; index<NUSE_MAILBOX_NUMBER; index++) { NUSE_Init_Mailbox(index); } #endif /* queues */ #if NUSE_QUEUE_NUMBER != 0 for (index=0; index<NUSE_QUEUE_NUMBER; index++) { NUSE_Init_Queue(index); } #endif /* pipes */ #if NUSE_PIPE_NUMBER != 0 for (index=0; index<NUSE_PIPE_NUMBER; index++) { NUSE_Init_Pipe(index); } #endif /* semaphores */ #if NUSE_SEMAPHORE_NUMBER != 0 for (index=0; index<NUSE_SEMAPHORE_NUMBER; index++) { NUSE_Init_Semaphore(index); } #endif /* event groups */ #if NUSE_EVENT_GROUP_NUMBER != 0 for (index=0; index<NUSE_EVENT_GROUP_NUMBER; index++) { NUSE_Init_Event_Group(index); } #endif /* timers */ #if NUSE_TIMER_NUMBER != 0 for (index=0; index<NUSE_TIMER_NUMBER; index++) { NUSE_Init_Timer(index); } #endif }

सबसे पहले, वैश्विक चर आरंभिक होते हैं:

NUSE_Task_Active - सक्रिय कार्य का सूचकांक, शून्य से आरंभिक; बाद में यह शेड्यूलर बदल सकता है।
NUSE_Task_State - मान NUSE_STARTUP_CONTEXT , जो किसी भी बाद के अनुप्रयोग आरंभीकरण कोड के लिए एपीआई की कार्यक्षमता को सीमित करता है, के साथ आरंभिक।
यदि सिस्टम समय समर्थन सक्रिय है, तो NUSE_Tick_Clock शून्य पर सेट है।
यदि टाइम स्लाइस शेड्यूलर सक्रिय है, तो NUSE_Time_Slice_Ticks को कॉन्फ़िगर किया गया मान NUSE_TIME_SLICE_TICKS सौंपा गया है।

फिर कर्नेल ऑब्जेक्ट्स को इनिशियलाइज़ करने के लिए फ़ंक्शंस को कॉल किया जाता है:

NUSE_Init_Task () को प्रत्येक कार्य की डेटा संरचनाओं को आरंभ करने के लिए कहा जाता है। यह कॉल केवल तभी छोड़ दी जाती है जब रन टू कम्प्लीशन शेड्यूलर का उपयोग किया जाता है, और सिग्नल, टास्क पॉज़, और शेड्यूलिंग काउंटर कॉन्फ़िगर नहीं किए जाते हैं (क्योंकि फ़ंक्शन के इस संयोजन से रैम में इन कार्य संरचनाओं की अनुपस्थिति होगी, इसलिए, आरंभीकरण नहीं किया जाएगा)।
NUSE_Init_Partition_Pool () प्रत्येक विभाजन पूल ऑब्जेक्ट को इनिशियलाइज़ करने के लिए कहा जाता है। यदि कोई विभाजन पूल कॉन्फ़िगर नहीं किया गया है तो ये कॉल छोड़ दी जाती हैं।
प्रत्येक मेलबॉक्स ऑब्जेक्ट प्रारंभ करने के लिए NUSE_Init_Mailbox () को कहा जाता है। यदि कॉन्फ़िगर किए गए मेलबॉक्स नहीं हैं, तो ये कॉल छोड़ दी जाती हैं।
NUSE_Init_Queue () को प्रत्येक पंक्ति ऑब्जेक्ट को इनिशियलाइज़ करने के लिए कहा जाता है। यदि कोई कतार कॉन्फ़िगर नहीं हैं, तो ये कॉल छोड़ दी जाती हैं।
NUSE_Init_Pipe () प्रत्येक चैनल ऑब्जेक्ट को इनिशियलाइज़ करने के लिए कहा जाता है। यदि कोई चैनल कॉन्फ़िगर नहीं किया गया है तो ये कॉल छोड़ दी जाती हैं।
NUSE_Init_Semaphore () को प्रत्येक सेमाफ़ोर ऑब्जेक्ट को इनिशियलाइज़ करने के लिए कहा जाता है। यदि कोई सेमाफ़ोर कॉन्फ़िगर नहीं किया गया है तो ये कॉल छोड़ दी जाती हैं।
NUSE_Init_Event_Group () प्रत्येक ईवेंट समूह ऑब्जेक्ट को प्रारंभ करने के लिए कहा जाता है। यदि कॉन्फ़िगर किए गए ईवेंट समूह नहीं हैं, तो ये कॉल छोड़ दी जाती हैं।
NUSE_Init_Timer () को प्रत्येक टाइमर ऑब्जेक्ट को इनिशियलाइज़ करने के लिए कहा जाता है। यदि कोई टाइमर कॉन्फ़िगर नहीं हैं, तो ये कॉल छोड़ दी जाती हैं।

टास्क आरंभीकरण

निम्नलिखित NUSE_Init_Task () फ़ंक्शन के लिए पूर्ण कोड है:

 void NUSE_Init_Task(NUSE_TASK task) { #if NUSE_SCHEDULER_TYPE != NUSE_RUN_TO_COMPLETION_SCHEDULER NUSE_Task_Context[task][15] = /* SR */ NUSE_STATUS_REGISTER; NUSE_Task_Context[task][16] = /* PC */ NUSE_Task_Start_Address[task]; NUSE_Task_Context[task][17] = /* SP */ (U32 *)NUSE_Task_Stack_Base[task] + NUSE_Task_Stack_Size[task]; #endif #if NUSE_SIGNAL_SUPPORT || NUSE_INCLUDE_EVERYTHING NUSE_Task_Signal_Flags[task] = 0; #endif #if NUSE_TASK_SLEEP || NUSE_INCLUDE_EVERYTHING NUSE_Task_Timeout_Counter[task] = 0; #endif #if NUSE_SUSPEND_ENABLE || NUSE_INCLUDE_EVERYTHING #if NUSE_INITIAL_TASK_STATE_SUPPORT || NUSE_INCLUDE_EVERYTHING NUSE_Task_Status[task] = NUSE_Task_Initial_State[task]; #else NUSE_Task_Status[task] = NUSE_READY; #endif #endif #if NUSE_SCHEDULE_COUNT_SUPPORT || NUSE_INCLUDE_EVERYTHING NUSE_Task_Schedule_Count[task] = 0; #endif }

यदि रन टू कंप्लीशन शेड्यूलर को कॉन्फ़िगर नहीं किया गया है, तो NUSE_Task_Context [कार्य] [] कार्य के लिए संदर्भ ब्लॉक आरंभीकृत है। अधिकांश तत्वों को असाइन किए गए मान नहीं हैं, क्योंकि वे सामान्य मशीन रजिस्टर का प्रतिनिधित्व करते हैं, जिसका कार्य शुरू करते समय एक मध्यवर्ती मूल्य होना चाहिए। न्यूक्लियस एसई कार्यान्वयन के उदाहरण (फ़्रीस्केल कोल्डफ़ायर) में (लेकिन अन्य प्रोसेसर के लिए तंत्र समान होगा) अंतिम तीन प्रविष्टियाँ स्पष्ट रूप से सेट की गई हैं:

NUSE_Task_Context [कार्य] [15] में स्थिति रजिस्टर ( SR , स्थिति रजिस्टर) होता है और इसमें #define NUSE_STATUS_REGISTER निर्देश का मान होता है।
NUSE_Task_Context [कार्य] [16] में प्रोग्राम काउंटर ( पीसी , प्रोग्राम काउंटर) शामिल है और इसमें कार्य कोड के इनपुट बिंदु का पता मूल्य है: NUSE_Task_Start_Address [कार्य] ।
NUSE_Task_Context [कार्य] [17] में स्टैक पॉइंटर ( SP , स्टैक पॉइंटर) होता है और यह कार्य स्टैक ( NUSE_Task_Stack_Base (कार्य) ) के पते के योग और कार्य स्टैक के आकार ( NUSE_Task_Stack_Size [कार्य] ) के योग के रूप में गणना की जाती है।

यदि संकेत समर्थन सक्रिय है, तो कार्य संकेत झंडे ( NUSE_Task_Signal_Flags [कार्य] ) शून्य पर सेट हैं।

यदि कार्य निलंबन सक्रिय है (अर्थात, NUSE_Task_Sleep () API सेवा कॉल), कार्य समय-सीमा काउंटर ( NUSE_Task_Timeout_Counter [कार्य] ) शून्य पर सेट है।

यदि कार्य निलंबित अवस्था सक्रिय है, तो कार्य स्थिति ( NUSE_Task_Status [कार्य] ) को प्रारंभ किया जाता है। यह प्रारंभिक मान उपयोगकर्ता द्वारा निर्धारित किया जाता है ( NUSE_Task_Initial_State [कार्य] ) में यदि कार्य की प्रारंभिक अवस्था के लिए समर्थन सक्रिय है। अन्यथा, राज्य को NUSE_READY को सौंपा गया है।

यदि नियोजन काउंटर सक्रिय है, तो कार्य काउंटर ( NUSE_Task_Schedule_Count [कार्य] ) शून्य पर सेट है।

विभाजन पूल की शुरुआत

निम्नलिखित NUSE_Init_Partition_Pool () फ़ंक्शन के लिए पूर्ण कोड है:

 void NUSE_Init_Partition_Pool(NUSE_PARTITION_POOL pool) { NUSE_Partition_Pool_Partition_Used[pool] = 0; #if NUSE_BLOCKING_ENABLE NUSE_Partition_Pool_Blocking_Count[pool] = 0; #endif }

"प्रयुक्त" विभाजन पूल काउंटर ( NUSE_Partition_Pool__Partition_Used [पूल] ) शून्य पर सेट है।

यदि कार्य लॉक सक्रिय है, तो विभाजन पूल ( NUSE_Partition_Pool_Blocking_Count [पूल]) का अवरुद्ध कार्य काउंटर शून्य पर सेट है।

मेलबॉक्स को प्रारंभ करना

नीचे पूरा NUSE_Init_Mailbox () कोड है:

 void NUSE_Init_Mailbox(NUSE_MAILBOX mailbox) { NUSE_Mailbox_Data[mailbox] = 0; NUSE_Mailbox_Status[mailbox] = 0; #if NUSE_BLOCKING_ENABLE NUSE_Mailbox_Blocking_Count[mailbox] = 0; #endif }

मेलबॉक्स डेटा स्टोर ( NUSE_Mailbox_Data [मेलबॉक्स] ) शून्य पर सेट है, और राज्य ( NUSE_Mailbox_Status [मेलबॉक्स] ) "अप्रयुक्त" (यानी, शून्य) हो जाता है।

यदि कार्य लॉकिंग सक्रिय है, तो अवरुद्ध मेलबॉक्स कार्यों ( NUSE_Mailbox_Blocking_Count [मेलबॉक्स] ) का काउंटर शून्य पर सेट है।

कतार प्रारंभ

निम्नलिखित NUSE_Init_Queue () फ़ंक्शन के लिए पूर्ण कोड है:

 void NUSE_Init_Queue(NUSE_QUEUE queue) { NUSE_Queue_Head[queue] = 0; NUSE_Queue_Tail[queue] = 0; NUSE_Queue_Items[queue] = 0; #if NUSE_BLOCKING_ENABLE NUSE_Queue_Blocking_Count[queue] = 0; #endif }

कतार के आरंभ और अंत में स्थित बिंदु (वास्तव में, ये अनुक्रमणिकाएँ हैं NUSE_Queue_Head [कतार ] और NUSE_Queue_Tail [कतार] ) वे मान निर्दिष्ट किए जाते हैं जो कतारों के डेटा क्षेत्र की शुरुआत का संकेत देते हैं (अर्थात, वे एक शून्य मान लेते हैं)। कतार में काउंटर ( NUSE_Queue_Items [कतार] ) भी शून्य पर सेट है।

यदि कार्य लॉकिंग सक्रिय है, तो अवरुद्ध कतार कार्यों ( NUSE_Queue_Blocking_Count [कतार] ) का काउंटर शून्य पर सेट है।

चैनल इनिशियलाइज़ेशन

निम्नलिखित NUSE_Init_Pipe () फ़ंक्शन के लिए पूर्ण कोड है:

 void NUSE_Init_Pipe(NUSE_PIPE pipe) { NUSE_Pipe_Head[pipe] = 0; NUSE_Pipe_Tail[pipe] = 0; NUSE_Pipe_Items[pipe] = 0; #if NUSE_BLOCKING_ENABLE NUSE_Pipe_Blocking_Count[pipe] = 0; #endif }

चैनल की शुरुआत और अंत के लिए संकेत (वास्तव में, ये सूचकांक हैं - NUSE_Pipe_Head [पाइप] और NUSE_Pipe_Tail [पाइप] ) को एक मान दिया जाता है जो चैनल डेटा क्षेत्र की शुरुआत को इंगित करता है (अर्थात, वे एक शून्य मान लेते हैं)। चैनल काउंटर ( NUSE_Pipe_Items [पाइप] ) भी शून्य पर सेट है।

यदि कार्य लॉकिंग सक्रिय है, तो चैनल का अवरुद्ध कार्य काउंटर ( NUSE_Pipe_Blocking_Count [पाइप] ) शून्य पर सेट है।

सेमाफोर आरंभीकरण

निम्नलिखित NUSE_Init_Semaphore () फ़ंक्शन के लिए पूर्ण कोड है:

 void NUSE_Init_Semaphore(NUSE_SEMAPHORE semaphore) { NUSE_Semaphore_Counter[semaphore] = NUSE_Semaphore_Initial_Value[semaphore]; #if NUSE_BLOCKING_ENABLE NUSE_Semaphore_Blocking_Count[semaphore] = 0; #endif }

सेमीफोर काउंटर ( NUSE_Semaphore_Counter [सेमीफोर]] को उपयोगकर्ता द्वारा निर्धारित मूल्य ( NUSE_Semaphore_Initial_Value [सेमीफोर] ) के साथ आरम्भ किया गया है।

यदि कार्य लॉकिंग सक्रिय है, तो लॉक किए गए अर्ध- कार्य टास्क काउंटर ( NUSE_Semaphore_Blocking_Count [semaphore] ) को शून्य पर सेट किया गया है।

इवेंट समूहों को प्रारंभ करना

निम्नलिखित NUSE_Init_Event_Group () फ़ंक्शन के लिए पूर्ण कोड है:

 void NUSE_Init_Event_Group(NUSE_EVENT_GROUP group) { NUSE_Event_Group_Data[group] = 0; #if NUSE_BLOCKING_ENABLE NUSE_Event_Group_Blocking_Count[group] = 0; #endif }

ईवेंट समूह के झंडे रीसेट किए जाते हैं, अर्थात NUSE_Event_Group_Data [समूह] को एक शून्य मान सौंपा गया है।

यदि कार्य लॉकिंग सक्रिय है, तो ईवेंट ध्वज समूह ( NUSE_Event_Group_Blocking_Count [समूह] ) का अवरुद्ध कार्य काउंटर शून्य पर सेट है।

टाइमर प्रारंभिक

नीचे NUSE_Init_Timer () का पूर्ण कोड है;

 void NUSE_Init_Timer(NUSE_TIMER timer) { NUSE_Timer_Status[timer] = FALSE; NUSE_Timer_Value[timer] = NUSE_Timer_Initial_Time[timer]; NUSE_Timer_Expirations_Counter[timer] = 0; }

टाइमर की स्थिति ( NUSE_Timer_Status [टाइमर] ) "अप्रयुक्त", अर्थात् पर सेट है गलत।

उलटी गिनती मूल्य ( NUSE_Timer_Value [टाइमर ]) उपयोगकर्ता द्वारा निर्धारित मूल्य ( NUSE_Timer_Initial_Time [टाइमर ]) द्वारा आरंभीकृत किया गया है।

पूरा होने वाला काउंटर ( NUSE_Timer_Expirations_Counter [टाइमर] ) शून्य पर सेट है।

प्रारंभिक अनुप्रयोग कोड

न्यूक्लियस एसई डेटा संरचनाओं को शुरू करने के बाद, कार्य शुरू करने से पहले आवेदन को शुरू करने के लिए जिम्मेदार कोड को निष्पादित करना संभव हो जाता है। यह कार्य निम्नलिखित कार्यों के लिए उपयोगी हो सकता है:

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

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

एपीआई कॉल में एक प्रतिबंध है: सभी क्रियाएं जो आमतौर पर अनुसूचक की सक्रियता की ओर ले जाती हैं, निषिद्ध हैं (उदाहरण के लिए, कार्यों को रोकना / रोकना)। वैश्विक चर NUSE_Task_State को इस सीमा को इंगित करने के लिए NUSE_STARTUP_CONTEXT पर सेट किया गया है।

शेड्यूलर लॉन्च करें

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

वैश्विक चर NUSE_Task_State को NUSE_TASK_CONTEXT पर सेट करना ।
चलाने के लिए पहले कार्य के सूचकांक का चयन करें। यदि प्रारंभिक कार्य के लिए समर्थन सक्रिय है, तो पहले समाप्त कार्य की खोज की जाती है, अन्यथा, एक शून्य मान का उपयोग किया जाता है।
अनुसूचक को कहा जाता है - NUSE_Scheduler () ।

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

निम्नलिखित लेख निदान और त्रुटि जाँच पर चर्चा करेगा।

लेखक के बारे में: कॉलिन वाल्स तीस वर्षों से इलेक्ट्रॉनिक्स उद्योग में काम कर रहे हैं, अपने अधिकांश समय को फर्मवेयर के लिए समर्पित करते हैं। वह अब मेंटर एंबेडेड (मेंटर ग्राफिक्स का एक प्रभाग) में एक फर्मवेयर इंजीनियर है। कॉलिन वाल्स अक्सर सम्मेलनों और सेमिनारों में बोलते हैं, कई तकनीकी लेखों के लेखक और फर्मवेयर पर दो किताबें हैं। ब्रिटेन में रहता है। कॉलिन का पेशेवर ब्लॉग , ई-मेल: colin_walls@mentor.com।

RTOS के बारे में पूरी सच्चाई। अनुच्छेद # 30 न्यूक्लियस एसई इनिशियलाइजेशन एंड स्टार्टअप प्रोसीजर