🚢 🤴🏽 🚍 वीकेंड ऑपरेटिंग सिस्टम 🧢 🌜 🔅

अस्वीकरण। लेखक माइक्रोकंट्रोलर्स के लिए मल्टीटास्किंग ऑपरेटिंग सिस्टम के उपयोग की वकालत नहीं करता है।

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

मेरी परियोजनाओं के लिए ओएस की पसंद के साथ पीड़ा नहीं होने के लिए, साथ ही साथ किसी और के उत्पाद के अध्ययन के साथ मेरे दिमाग को बादलने के लिए नहीं, साथ ही ऑपरेटिंग सिस्टम के लिए एम्बेडेड अनुप्रयोगों को लिखने की तकनीक में महारत हासिल करने के लिए, और यह भी पता लगाने के लिए कि यह सब क्या है, मैंने अपना ओएस लिखने का फैसला किया। इसकी गंध नहीं।

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

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

स्रोत कोड

फ़ाइल IntorOS.h

#ifndef __INTOROS_H #define __INTOROS_H //  IntorOS // #define IntorOSMaxKolvoZadach (2) //   ( ) #define IntorOSRazmerSteka (1024) //     [] ( ) #define IntorOSError (0) //  0- !0-   // //  // TaskPointer -   ,   // Stek -      void InitTask(void (*TaskPointer)(void), unsigned long Stek); //   //    void StartOS(unsigned long Num); //   ,   // ms -    void Sleep(unsigned long ms); //  static inline void EndTask(void){while(1)Sleep(0xFFFFFFFF);} //  // -   void StopTask(unsigned long Num); //    // -   void StartTask(unsigned long Num); #endif

IntorOS.c फ़ाइल

 #define _INTOROS_C #include "stm32l0xx.h" #include "IntorOS.h" //    typedef struct { unsigned long TaskSleep;//      unsigned long* SP; //   } Task_t; unsigned long KolvoTask;//  unsigned long KolvoTaskStek;//  unsigned long TaskNum;//    Task_t TaskList[IntorOSMaxKolvoZadach];//  unsigned long TaskStek[IntorOSRazmerSteka/4];//     //  // TaskPointer -   ,   // Stek -    void InitTask(void (*TaskPointer)(void), unsigned long Stek) { //   TaskList[KolvoTask].TaskSleep=0;//        TaskList[KolvoTask].SP=&(TaskStek[IntorOSRazmerSteka/4-1-KolvoTaskStek]);//   //   //       ( LR) TaskList[KolvoTask].SP--; (*(TaskList[KolvoTask].SP))=(unsigned long)(TaskPointer); TaskList[KolvoTask].SP--;//   R4 TaskList[KolvoTask].SP--;//   R5 TaskList[KolvoTask].SP--;//   R6 TaskList[KolvoTask].SP--;//   R7 TaskList[KolvoTask].SP--;//   R8 TaskList[KolvoTask].SP--;//   R9 TaskList[KolvoTask].SP--;//   R10 TaskList[KolvoTask].SP--;//   R11 TaskList[KolvoTask].SP--;//   R12 KolvoTask++;//   (  ) KolvoTaskStek=KolvoTaskStek+Stek/4;//   //   if(KolvoTaskStek>(IntorOSRazmerSteka/4)) #if IntorOSError==0 while(1);//      -  #else NVIC_SystemReset();//      -   #endif return; } //   //    void StartOS(unsigned long Num) { SysTick_Config(SystemCoreClock/1000);//      1 TaskNum=Num;//   //    TaskList[TaskNum].SP++;//   R12 TaskList[TaskNum].SP++;//   R11 TaskList[TaskNum].SP++;//   R10 TaskList[TaskNum].SP++;//   R9 TaskList[TaskNum].SP++;//   R8 TaskList[TaskNum].SP++;//   R7 TaskList[TaskNum].SP++;//   R6 TaskList[TaskNum].SP++;//   R5 TaskList[TaskNum].SP++;//   R4 TaskList[TaskNum].SP++;//   LR __set_SP((unsigned long)TaskList[TaskNum].SP);//     (*((void (*)(void))(*(TaskList[TaskNum].SP-1))))();//    //    #if IntorOSError==0 while(1);// #else NVIC_SystemReset();//  #endif } //  // -   void StopTask(unsigned long Num) { TaskList[Num].TaskSleep=0xFFFFFFFF; return; } //    // -   void StartTask(unsigned long Num) { if((~(TaskList[Num].TaskSleep))==0) {//   ,  TaskList[Num].TaskSleep=0x00000000; } return; } //   void SysTick_Handler(void); void SysTick_Handler(void) { TimingDelay++;//    for(int i=0;i<KolvoTask;i++) {//  if(((TaskList[i].TaskSleep)!=0) && ((~(TaskList[i].TaskSleep))!=0)) {//     0   0xFFFFFFFF (TaskList[i].TaskSleep)--;//    } } return; }

फ़ाइल IntorOSSleepIAR.s

 #define SHT_PROGBITS 0x1 EXTERN KolvoTask EXTERN TaskList EXTERN TaskNum PUBLIC Sleep SECTION `.text`:CODE:NOROOT(2) THUMB // 8 //    // 9 //    // 10 void Sleep(unsigned long ms) Sleep: // 11 { // 12 //  // 13 __asm("PUSH {R4-R7,LR}"); PUSH {R4-R7,LR} // 14 __asm("MOV R4,R8"); MOV R4,R8 // 15 __asm("MOV R5,R9"); MOV R5,R9 // 16 __asm("MOV R6,R10"); MOV R6,R10 // 17 __asm("MOV R7,R11"); MOV R7,R11 // 18 __asm("PUSH {R4-R7}"); PUSH {R4-R7} // 19 __asm("MOV R4,R12"); MOV R4,R12 // 20 __asm("PUSH {R4}"); PUSH {R4} // 21 TaskList[TaskNum].TaskSleep=ms;//       LDR R1,Sleep_0 LDR R2,Sleep_0+0x4 LDR R3,[R1, #+0] LSLS R3,R3,#+3 STR R0,[R2, R3] // 22 TaskList[TaskNum].SP =__get_SP();// SP MOV R0,SP LDR R3,[R1, #+0] LSLS R3,R3,#+3 ADDS R3,R2,R3 STR R0,[R3, #+4] // 23 //    // 24 while(1) // 25 { // 26 TaskNum++;if(TaskNum==KolvoTask)TaskNum=0;//    Sleep_1: LDR R0,[R1, #+0] ADDS R0,R0,#+1 LDR R3,Sleep_0+0x8 LDR R3,[R3, #+0] CMP R0,R3 BNE Sleep_2 MOVS R0,#+0 Sleep_2: STR R0,[R1, #+0] LSLS R0,R0,#+3 ADDS R0,R2,R0 LDR R3,[R0, #+0] CMP R3,#+0 BNE Sleep_1 // 27 //     // 28 if(TaskList[TaskNum].TaskSleep==0) // 29 {//    // 30 //  // 31 __set_SP(TaskList[TaskNum].SP);// SP LDR R0,[R0, #+4] MOV SP,R0 // 32 __asm("POP {R4}"); POP {R4} // 33 __asm("MOV R12,R4"); MOV R12,R4 // 34 __asm("POP {R4-R7}"); POP {R4-R7} // 35 __asm("MOV R11,R7"); MOV R11,R7 // 36 __asm("MOV R10,R6"); MOV R10,R6 // 37 __asm("MOV R9,R5"); MOV R9,R5 // 38 __asm("MOV R8,R4"); MOV R8,R4 // 39 __asm("POP {R4-R7,PC}"); POP {R4-R7,PC} // 40 // 41 //The End // 42 return; NOP // 43 } // 44 } // 45 } DATA Sleep_0: // extern unsigned long TaskNum;//   DC32 TaskNum // extern Task_t TaskList[IntorOSMaxKolvoZadach];//  DC32 TaskList // extern unsigned long KolvoTask;//  DC32 KolvoTask SECTION `.iar_vfe_header`:DATA:NOALLOC:NOROOT(2) SECTION_TYPE SHT_PROGBITS, 0 DATA DC32 0 SECTION __DLIB_PERTHREAD:DATA:REORDER:NOROOT(0) SECTION_TYPE SHT_PROGBITS, 0 SECTION __DLIB_PERTHREAD_init:DATA:REORDER:NOROOT(0) SECTION_TYPE SHT_PROGBITS, 0 END

फ़ाइल IntorOSSleepGCC.s

 .cpu cortex-m0 .text .cfi_sections .debug_frame .section .text.Sleep,"ax",%progbits .align 1 .global Sleep .syntax unified .thumb .thumb_func .type Sleep, %function .extern KolvoTask .extern TaskList .extern TaskNum .cfi_startproc // 8 //    // 9 //    // 10 void Sleep(unsigned long ms) Sleep: // 11 { // 12 //  // 13 __asm("PUSH {R4-R7,LR}"); PUSH {R4-R7,LR} // 14 __asm("MOV R4,R8"); MOV R4,R8 // 15 __asm("MOV R5,R9"); MOV R5,R9 // 16 __asm("MOV R6,R10"); MOV R6,R10 // 17 __asm("MOV R7,R11"); MOV R7,R11 // 18 __asm("PUSH {R4-R7}"); PUSH {R4-R7} // 19 __asm("MOV R4,R12"); MOV R4,R12 // 20 __asm("PUSH {R4}"); PUSH {R4} // 21 TaskList[TaskNum].TaskSleep=ms;//       LDR R1,Sleep_0 LDR R2,Sleep_0+0x4 LDR R3,[R1, #+0] LSLS R3,R3,#+3 STR R0,[R2, R3] // 22 TaskList[TaskNum].SP =__get_SP();// SP MOV R0,SP LDR R3,[R1, #+0] LSLS R3,R3,#+3 ADDS R3,R2,R3 STR R0,[R3, #+4] // 23 //    // 24 while(1) // 25 { // 26 TaskNum++;if(TaskNum==KolvoTask)TaskNum=0;//    Sleep_1: LDR R0,[R1, #+0] ADDS R0,R0,#+1 LDR R3,Sleep_0+0x8 LDR R3,[R3, #+0] CMP R0,R3 BNE Sleep_2 MOVS R0,#+0 Sleep_2: STR R0,[R1, #+0] LSLS R0,R0,#+3 ADDS R0,R2,R0 LDR R3,[R0, #+0] CMP R3,#+0 BNE Sleep_1 // 27 //     // 28 if(TaskList[TaskNum].TaskSleep==0) // 29 {//    // 30 //  // 31 __set_SP(TaskList[TaskNum].SP);// SP LDR R0,[R0, #+4] MOV SP,R0 // 32 __asm("POP {R4}"); POP {R4} // 33 __asm("MOV R12,R4"); MOV R12,R4 // 34 __asm("POP {R4-R7}"); POP {R4-R7} // 35 __asm("MOV R11,R7"); MOV R11,R7 // 36 __asm("MOV R10,R6"); MOV R10,R6 // 37 __asm("MOV R9,R5"); MOV R9,R5 // 38 __asm("MOV R8,R4"); MOV R8,R4 // 39 __asm("POP {R4-R7,PC}"); POP {R4-R7,PC} // 40 // 41 //The End // 42 return; NOP // 43 } // 44 } // 45 } .align 2 Sleep_0: // extern unsigned long TaskNum;//   .word TaskNum // extern Task_t TaskList[IntorOSMaxKolvoZadach];//  .word TaskList // extern unsigned long KolvoTask;//  .word KolvoTask .cfi_endproc

OS संकलन स्थिरांक

 #define IntorOSMaxKolvoZadach (2) //   ( ) #define IntorOSRazmerSteka (1024) //     [] ( )

धार्मिक कारणों से, मैं गतिशील मेमोरी आवंटन का उपयोग नहीं कर सकता हूं, इसलिए संकलन चरण में आवश्यक मेमोरी की मात्रा निर्दिष्ट की जानी चाहिए।

OS OS सेवाएँ

 void InitTask(void (*TaskPointer)(void), unsigned long Stek);

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

 void StartOS(unsigned long Num);

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

 void Sleep(unsigned long ms);

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

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

फ़ाइल Sleep.c

 extern Task_t TaskList[IntorOSMaxKolvoZadach];//  extern unsigned long TaskNum;//   extern unsigned long KolvoTask;//  //    //    #pragma optimize=medium void Sleep(unsigned long ms) { //  __asm("PUSH {R4-R7,LR}"); __asm("MOV R4,R8"); __asm("MOV R5,R9"); __asm("MOV R6,R10"); __asm("MOV R7,R11"); __asm("PUSH {R4-R7}"); __asm("MOV R4,R12"); __asm("PUSH {R4}"); TaskList[TaskNum].TaskSleep=ms;//       TaskList[TaskNum].SP =(unsigned long*)__get_SP();// SP //    while(1) { TaskNum++;if(TaskNum==KolvoTask)TaskNum=0;//    //     if(TaskList[TaskNum].TaskSleep==0) {//    //  __set_SP((unsigned long)TaskList[TaskNum].SP);// SP __asm("POP {R4}"); __asm("MOV R12,R4"); __asm("POP {R4-R7}"); __asm("MOV R11,R7"); __asm("MOV R10,R6"); __asm("MOV R9,R5"); __asm("MOV R8,R4"); __asm("POP {R4-R7,PC}"); //return } } }

 void EndTask(void);

कार्य पूरा करना। जैसा कि ऊपर उल्लेख किया गया है, कार्य स्थिर हैं, कार्यों को उतारना असंभव है। यदि आपको कार्य पूरा करने की आवश्यकता है, तो आप इस फ़ंक्शन का उपयोग कर सकते हैं। कार्य सूची में रहता है, लेकिन नियंत्रण इसे स्थानांतरित नहीं किया जाता है।

 void StopTask(unsigned long Num); void StartTask(unsigned long Num);

किसी कार्य को रोकना या शुरू करना। तर्क कार्य का पहचानकर्ता है। ये फ़ंक्शन आपको कार्य प्रबंधक को कार्यान्वित करने की अनुमति देते हैं। यह ध्यान दिया जाना चाहिए कि आप केवल पहले से बंद किए गए कार्य को शुरू कर सकते हैं, जिस समय तक यह शुरू होता है 0xFFFFFFFF।

OS का उपयोग करना

उदाहरण के लिए, विकसित ऑपरेटिंग सिस्टम के लिए एक पारंपरिक माइक्रोकंट्रोलर "हेलवर्ड"।

 #include "stm32l0xx.h" #include "stm32l0xx_ll_gpio.h" #include "IntorOS.h" // 0 void Task0(void) { LL_GPIO_InitTypeDef GPIO_InitStruct; LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOB); GPIO_InitStruct.Pin = LL_GPIO_PIN_0; GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT; GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; LL_GPIO_Init(GPIOB, &GPIO_InitStruct); while(1) { GPIOB->BRR=LL_GPIO_PIN_0; Sleep(1000); GPIOB->BSRR=LL_GPIO_PIN_0; Sleep(1000); } } // 1 void Task1(void) { LL_GPIO_InitTypeDef GPIO_InitStruct; LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOB); GPIO_InitStruct.Pin = LL_GPIO_PIN_1; GPIO_InitStruct.Mode = LL_GPIO_MODE_OUTPUT; GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; GPIO_InitStruct.Pull = LL_GPIO_PULL_NO; LL_GPIO_Init(GPIOB, &GPIO_InitStruct); while(1) { GPIOB->BRR=LL_GPIO_PIN_1; Sleep(500); GPIOB->BSRR=LL_GPIO_PIN_1; Sleep(500); } } void main(void) { // MCU Configuration SystemClock_Config(); //  InitTask(Task0, 512); InitTask(Task1, 256); //  StartOS(0); }

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

वीकेंड ऑपरेटिंग सिस्टम

स्रोत कोड

OS संकलन स्थिरांक

OS OS सेवाएँ

OS का उपयोग करना

More articles: