該篇為“啰里啰嗦版”，另有相應的“精簡版”供參考

?

“不到長城非好漢；不做OS，枉為程序員”

OS之于程序員，如同梵蒂岡之于天主教徒，那永遠都是塊神圣的領土。若今生不能親歷之，實乃憾事！

但是，圣域不是想進就能進的呀……

OS融合了大量的計算機的基礎知識，各個知識領域之間交織緊密，初來乍到者一不小心就會繞出個死結。

我的方法是：死結就死結，不管三七二十一，直接剪斷，先走下去再說，回頭我們再把這個剪斷的死結再接上。

?

我們知道，“多任務”一般在介紹OS的書籍中，是屬于中間或者靠后的部分，又或者分散在各個章節中。而我決定上手就說它。

?

一、整體縱覽：

1、硬件：

STM32F103RC

2、IDE：

MDK5

3、文件架構：

（1）標準文件：

startup_stm32f10x_hd.s：STM32官方啟動文件（注意：這是針對stm32硬件配置的文件，型號要是不同，你的可能和我不一樣哦）

（2）自編文件——這才是我們的重頭戲哦（共5個文件：1x".asm"+2x".c"+2x".h"）：

main.c：主函數和任務定義；

os_cpu_a.asm：中斷與任務切換；

myos.c：硬件初始化與任務切換時的堆棧保存；

include.h和myos.h：兩個頭文件。

?

二、逐文解析：

1、main.c

順著main函數這條主線，我們看到最終的OS其實就是執行了7行代碼，共5個函數：

1、OSInit(); 2、OSTaskCreate(Task1, (void*)0, (OS_STK*)&Task1Stk[TASK_STACK_SIZE-1]); 3、OSTaskCreate(Task2, (void*)0, (OS_STK*)&Task2Stk[TASK_STACK_SIZE-1]); 4、OSTaskCreate(Task3, (void*)0, (OS_STK*)&Task3Stk[TASK_STACK_SIZE-1]); 5、SysTickInit(5); 6、LedInit(); 7、OSStart();

簡單說說main函數功能：
當OSStart()執行之后，Task1、Task2、Task3輪流執行，即Task1()、Task2()、Task3()三個函數輪流執行：
Task1()->Task2()->Task3()->Task1()->Task2()->Task3()->Task1()->......
每個任務（或函數）執行相等的時間片，并有SysTick中斷來觸發PendSV中斷，從而實現任務切換。
OSStart()執行之后，永不返回。

各個函數基本做了些什么，代碼后面都附加了注解。
其中需要注意的地方是：OSStart()。
這個函數一旦執行了就不會返還，有點像死循環（但不是死循環哦，后來會明白的）。
仔細想想后，確實也應當如此，如果main函數return掉了的話，程序也就結束啦！
“main函數結束”就意味著CPU現在只會喝喝茶、看看報了，什么搶劫、著火它都裝作沒看見。

main函數就這么短，那么上面七個函數的實現在哪里呢？
這時你肯定想到"#include"了吧！
“太好了！#include只有一行！”
那我們去include.h那里看看吧。 1 #include "include.h" 2 extern OS_TCB OSTCBTbl[OS_MAX_TASKS]; // (OS Task Control Block Table) 3 extern OS_STK TASK_IDLE_STK[TASK_STACK_SIZE]; //("TaskIdle" Stack) 4 extern OS_TCB *OSTCBCur; // Pointer to the current running task(OS Task Control Block Current) 5 extern OS_TCB *OSTCBNext; // Pointer to the next running task(OS Task Control Block Next) 6 extern INT8U OSTaskNext; // Index of the next task 7 extern INT32U TaskTickLeft; // Refer to the time ticks left for the current task 8 extern INT32U TimeMS; // For system time record 9 extern INT32U TaskTimeSlice; // For system time record 10 11 OS_STK Task1Stk[TASK_STACK_SIZE]; // initialize stack for task1 12 OS_STK Task2Stk[TASK_STACK_SIZE]; // initialize stack for task2 13 OS_STK Task3Stk[TASK_STACK_SIZE]; // initialize stack for task3 14 15 void Task1(void *p_arg); // flip the led1 every 0.5s 16 void Task2(void *p_arg); // flip the led2 every 1.0s 17 void Task3(void *p_arg); // do nothing 18 19 int main(void) 20 { 21 22 23 OSInit(); // OS initialization 24 OSTaskCreate(Task1, (void*)0, (OS_STK*)&Task1Stk[TASK_STACK_SIZE-1]); // create task 1 25 OSTaskCreate(Task2, (void*)0, (OS_STK*)&Task2Stk[TASK_STACK_SIZE-1]); // create task 2 26 OSTaskCreate(Task3, (void*)0, (OS_STK*)&Task3Stk[TASK_STACK_SIZE-1]); // create task 3 27 SysTickInit(5); // configure the SysTick as 5ms 28 LedInit(); // leds initialization 29 OSStart(); // start os! 30 31 return 0; // never come here 32 } 33 34 void Task1(void *p_arg) 35 { 36 while(1) { 37 delayMs(100); // delay 100 * 5ms = 0.5s 38 LED1TURN(); // flip the switch of led1 39 } 40 } 41 void Task2(void *p_arg) 42 { 43 while(1) { 44 delayMs(200); // delay 200 * 5ms = 1.0s 45 LED2TURN(); // flip the switch of led2 46 } 47 } 48 49 void Task3(void *p_arg) 50 { 51 while(1) { 52 } 53 }

小白兔筆記：

（1）“啥是extern變量啊？”

"快去復習復習c語言教程吧。"

（2）"OS_TCB、OS_MAX_TASKS什么的都是些啥？“

"myos.h"里都有它們的定義。

（3）”'OSTCBCur'都是些啥怪名字?"

“針對詞義復雜的變量，注意看定義那行注釋，后面的括號會有對變量的簡短說明，如：

extern OS_TCB *OSTCBCur; // Pointer to the current running task(OS Task Control Block Current)

?

?

?2、include.h

“我去！這不是欺騙我感情嗎？main函數倒是1個#include，怎么到了這里卻又來了三個！”

等等！先別灰心嘛，容我慢慢道來。

我們知道，main里的

#include "include.h"

其實就等于：

#include <stdlib.h>

#include "myos.h"

#include "stm32f10x.h"

但是我們為什么要那么費勁再弄一個"inlcude.h"文件呢？

假設我們想給這個OS再加個內存管理的功能，于是要添加幾個".c"文件，而這些文件也要包含上面那幾個"#include"，那么我們不是要再把那幾個“#include”都寫一遍嗎？?

不過，有了這個include.h之后，這些".c"文件只要

#include "include.h"就可以了。

多加了1個"include.h"，但卻清爽了n個”xxxxx.c"文件。

當然，這只是好處之一，其他的就不多說了，畢竟我們的主題是OS嘛。

1 #ifndef INCLUDE_H 2 #define INCLUDE_H 3 4 #include <stdlib.h> 5 #include "myos.h" 6 #include "stm32f10x.h" //stm32官方頭文件 7 8 #endif

小白兔筆記：

（1）“#ifndef INCLUDE_H之類的東西是什么意思？”

這是為了防止多重包含頭文件。

既然你問了這個問題，估計你也聽不懂啥是”多重包含頭文件“。

這是和編譯器有關的約定，簡單點說，不這么寫，編譯器”可能“——我說”可能“——找你茬。

（2）”stm32f10x.h“是官方根據stm32的各種硬件配置編寫的頭文件，可要找準著你的你自己的硬件配置使用哦！

?

3、myos.h

1 #ifndef MYOS_H 2 #define MYOS_H 3 #include "stm32f10x.h" 4 5 /**********CPU DEPENDENT************/ 6 #define TASK_TIME_SLICE 5 // 5ms for every task to run every time 7 8 typedef unsigned char INT8U; // Unsigned 8 bit quantity 9 typedef unsigned short INT16U; // Unsigned 16 bit quantity 10 typedef unsigned int INT32U; // Unsigned 32 bit quantity 11 12 typedef unsigned int OS_STK; // Each stack entry is 32-bit wide(OS Stack) 13 14 // assembling functions 15 void OS_ENTER_CRITICAL(void); // Enter Critical area, that is to disable interruptions 16 void OS_EXIT_CRITICAL(void); // Exit Critical area, that is to enable interruptions 17 void OSCtxSw(void); // Task Switching Function(OS Context Switch) 18 void OSStart(void); 19 20 OS_STK* OSTaskStkInit(void (*task)(void *p_arg), // task function 21 void *p_arg, // (pointer of arguments) 22 OS_STK *p_tos); // (pointer to the top of stack) 23 /**********CPU INDEPENDENT************/ 24 25 #define OS_MAX_TASKS 16 26 27 #define TASK_STATE_CREATING 0 28 #define TASK_STATE_RUNNING 1 29 #define TASK_STATE_PAUSING 2 30 31 #define TASK_STACK_SIZE 64 32 33 #define LED1TURN() (GPIOA->ODR ^= 1<<8) // reverse the voltage of LED1 !!!HARDWARE RELATED 34 #define LED2TURN() (GPIOD->ODR ^= 1<<2) // reverse the voltage of LED2 !!!HARDWARE RELATED 35 36 37 typedef struct os_tcb { 38 OS_STK *OSTCBStkPtr; // (OS Task Control Block Stack Pointer) 39 INT8U OSTCBStat; // (OS Task Control Block Status) 40 } OS_TCB; // (OS Task Control Block) 41 42 void OSInit(void); // (OS Initialization) 43 void LedInit(void); 44 45 void OS_TaskIdle(void *p_arg); 46 void OSInitTaskIdle(void); // (OS Initialization of "TaskIdle") 47 void OSTaskCreate(void (*task)(void *p_arg), // task function 48 　　　　 void *p_arg, 　　　　　　 // (pointer of arguments) 49 OS_STK *p_tos); 　　　　　　　　// (pointer to the top of stack) 50 void OSTCBSet(OS_TCB *p_tcb, OS_STK *p_tos, INT8U task_state); 51 52 53 void SysTickInit(INT8U Nms); // (System Tick Initialization) 54 void SysTick_Handler(void); 　　　　　　　　　　 // The interrupt function 55 56 INT32U GetTime(void); 57 void delayMs(volatile INT32U ms); 　　　　　　　　// The argument can't be too large 58 59 #endif

這是最后一個頭文件了，也是一個簡單易懂的文件。同時也是最后的平原，過了這個平原，我們可就要翻雪山啦！

（1）簡單說說2個函數：

void OS_ENTER_CRITICAL(void);

void OS_EXIT_CRITICAL(void);

有一種東西叫“臨界區”（CRITICAL)，這些所謂“臨界區”指的是一些變量所在的內存，可以直接理解成“就是些特殊變量”。
要訪問這些變量必須得關掉“中斷”，訪問結束后再開啟“中斷”，開關“中斷”就是這兩個函數的任務了。
猜猜看哪個是開“中斷”，哪個是關“中斷”呢？

（2）系統時鐘中斷void SysTick_Handler(void)的由來：

來自官方啟動文件startup_stm32f10x_hd.s。

?

小白兔筆記：

小白兔表示“感覺不會再愛了……”

?

4、os_cpu_a.asm和myos.c：

上文說過，這兩個文件關系曖昧，扯開來只講其中一個很沒味道，這里先把它們都貼出來：

os_cpu_a.asm（“;”后的注釋是對應"C"語言的解釋）:

1 IMPORT OSTCBCur 2 IMPORT OSTCBNext 3 4 EXPORT OS_ENTER_CRITICAL 5 EXPORT OS_EXIT_CRITICAL 6 EXPORT OSStart 7 EXPORT PendSV_Handler 8 EXPORT OSCtxSw 9 10 NVIC_INT_CTRL EQU 0xE000ED04 ; Address of NVIC Interruptions Control Register 11 NVIC_PENDSVSET EQU 0x10000000 ; Enable PendSV 12 NVIC_SYSPRI14 EQU 0xE000ED22 ; System priority register (priority 14). 13 NVIC_PENDSV_PRI EQU 0xFF ; PendSV priority value (lowest). 14 15 PRESERVE8 ; align 8 16 17 AREA |.text|, CODE, READONLY 18 THUMB 19 20 ;/******************OS_ENTER_CRITICAL************/ 21 OS_ENTER_CRITICAL 22 CPSID I ; Enable interruptions(Change Processor States: Interrupts Disable) 23 BX LR ; Return 24 25 ;/******************OS_EXIT_CRITICAL************/ 26 OS_EXIT_CRITICAL 27 CPSIE I ; Disable interruptions 28 BX LR ; Return 29 30 ;/******************OSStart************/ 31 OSStart 32 ; disable interruptions 33 CPSID I ; OS_ENTER_CRITICAL(); 34 ; initialize PendSV 35 ; Set the PendSV exception priority 36 LDR R0, =NVIC_SYSPRI14 ; R0 = NVIC_SYSPRI14; 37 LDR R1, =NVIC_PENDSV_PRI ; R1 = NVIC_PENDSV_PRI; 38 STRB R1, [R0] ; *R0 = R1; 39 40 ; initialize PSP as 0 41 ; MOV R4, #0 42 LDR R4, =0x0 ; R4 = 0; 43 MSR PSP, R4 ; PSP = R4; 44 45 ; trigger PendSV 46 LDR R4, =NVIC_INT_CTRL ; R4 = NVIC_INT_CTRL; 47 LDR R5, =NVIC_PENDSVSET ; R5 = NVIC_PENDSVSET; 48 STR R5, [R4] ; *R4 = R5; 49 50 ; enable interruptions 51 CPSIE I ; OS_EXIT_CRITICAL(); 52 53 ; should never get here 54 ; a endless loop 55 OSStartHang 56 B OSStartHang 57 58 ;/******************PendSV_Handler************/ 59 PendSV_Handler 60 CPSID I ; OS_ENTER_CRITICAL(); 61 ; judge if PSP is 0 which means the task is first invoked 62 MRS R0, PSP ; R0 = PSP; 63 CBZ R0, PendSV_Handler_NoSave ; if(R0 == 0) goto PendSV_Handler_NoSave; 64 65 ; R12, R3, R2, R1 66 SUB R0, R0, #0x20 ; R0 = R0 - 0x20; 67 68 ; store R4 69 STR R4 , [R0] ; *R0 = R4; 70 ADD R0, R0, #0x4 ; R0 = R0 + 0x4; 71 ; store R5 72 STR R5 , [R0] ; *R0 = R5; 73 ADD R0, R0, #0x4 ; R0 = R0 + 0x4; 74 ; store R6 75 STR R6 , [R0] ; *R0 = R6; 76 ADD R0, R0, #0x4 ; R0 = R0 + 0x4; 77 ; store R7 78 STR R7 , [R0] ; *R0 = R7; 79 ADD R0, R0, #0x4 ; R0 = R0 + 0x4; 80 ; store R8 81 STR R8 , [R0] ; *R0 = R8; 82 ADD R0, R0, #0x4 ; R0 = R0 + 0x4; 83 ; store R9 84 STR R9, [R0] ; *R0 = R4; 85 ADD R0, R0, #0x4 ; R0 = R0 + 0x4; 86 ; store R10 87 STR R10, [R0] ; *R0 = R10; 88 ADD R0, R0, #0x4 ; R0 = R0 + 0x4; 89 ; store R11 90 STR R11, [R0] ; *R0 = R11; 91 ADD R0, R0, #0x4 ; R0 = R0 + 0x4; 92 93 SUB R0, R0, #0x20 ; R0 = R0 - 0x20; 94 95 ; easy method 96 ;SUB R0, R0, #0x20 97 ;STM R0, {R4-R11} 98 99 LDR R1, =OSTCBCur ; R1 = OSTCBCur; 100 LDR R1, [R1] ; R1 = *R1;(R1 = OSTCBCur->OSTCBStkPtr) 101 STR R0, [R1] ; *R1 = R0;(*(OSTCBCur->OSTCBStkPrt) = R0) 102 103 PendSV_Handler_NoSave 104 LDR R0, =OSTCBCur ; R0 = OSTCBCur; 105 LDR R1, =OSTCBNext ; R1 = OSTCBNext; 106 LDR R2, [R1] ; R2 = OSTCBNext->OSTCBStkPtr; 107 STR R2, [R0] ; *R0 = R2;(OSTCBCur->OSTCBStkPtr = OSTCBNext->OSTCBStkPtr) 108 109 LDR R0, [R2] ; R0 = *R2;(R0 = OSTCBNext->OSTCBStkPtr) 110 ; LDM R0, {R4-R11} 111 ; load R4 112 LDR R4, [R0] ; R4 = *R0;(R4 = *(OSTCBNext->OSTCBStkPtr)) 113 ADD R0, R0, #0x4 ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++) 114 ; load R5 115 LDR R5, [R0] ; R5 = *R0;(R5 = *(OSTCBNext->OSTCBStkPtr)) 116 ADD R0, R0, #0x4 ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++) 117 ; load R6 118 LDR R6, [R0] ; R6 = *R0;(R6 = *(OSTCBNext->OSTCBStkPtr)) 119 ADD R0, R0, #0x4 ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++) 120 ; load R7 121 LDR R7 , [R0] ; R7 = *R0;(R7 = *(OSTCBNext->OSTCBStkPtr)) 122 ADD R0, R0, #0x4 ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++) 123 ; load R8 124 LDR R8 , [R0] ; R8 = *R0;(R8 = *(OSTCBNext->OSTCBStkPtr)) 125 ADD R0, R0, #0x4 ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++) 126 ; load R9 127 LDR R9 , [R0] ; R9 = *R0;(R9 = *(OSTCBNext->OSTCBStkPtr)) 128 ADD R0, R0, #0x4 ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++) 129 ; load R10 130 LDR R10 , [R0] ; R10 = *R0;(R10 = *(OSTCBNext->OSTCBStkPtr)) 131 ADD R0, R0, #0x4 ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++) 132 ; load R11 133 LDR R11 , [R0] ; R11 = *R0;(R11 = *(OSTCBNext->OSTCBStkPtr)) 134 ADD R0, R0, #0x4 ; R0 = R0 + 0x4;(OSTCBNext->OSTCBStkPtr++) 135 136 MSR PSP, R0 ; PSP = R0;(PSP = OSTCBNext->OSTCBStkPtr) 137 ; P42 138 ; P139 (key word: EXC_RETURN) 139 ; use PSP 140 ORR LR, LR, #0x04 ; LR = LR | 0x04; 141 CPSIE I ; OS_EXIT_CRITICAL(); 142 BX LR ; return; 143 144 OSCtxSw ;OS context switch 145 PUSH {R4, R5} 146 LDR R4, =NVIC_INT_CTRL ; R4 = NVIC_INT_CTRL 147 LDR R5, =NVIC_PENDSVSET ; R5 = NVIC_PENDSVSET 148 STR R5, [R4] ; *R4 = R5 149 POP {R4, R5} 150 BX LR ; return; 151 152 align 4 153 end

myos.c：

1 #include "myos.h" 2 #include "stm32f10x.h" 3 4 5 OS_TCB OSTCBTbl[OS_MAX_TASKS]; // (OS Task Control Block Table) 6 OS_STK TASK_IDLE_STK[TASK_STACK_SIZE]; //("TaskIdle" Stack) 7 OS_TCB *OSTCBCur; // Pointer to the current running task(OS Task Control Block Current) 8 OS_TCB *OSTCBNext; // Pointer to the next running task(OS Task Control Block Next) 9 INT8U OSTaskNext; // Index of the next task 10 INT32U TaskTickLeft; // Refer to the time ticks left for the current task 11 INT32U TimeMS; 12 INT32U TaskTimeSlice; 13 char * Systick_priority = (char *)0xe000ed23; 14 // Initialize the stack of a task, it is of much relationship with the specific CPU 15 OS_STK* OSTaskStkInit(void (*task)(void *p_arg), 16 void *p_arg, 17 OS_STK *p_tos) 18 { 19 OS_STK *stk; 20 stk = p_tos; 21 22 *(stk) = (INT32U)0x01000000L; // xPSR 23 *(--stk) = (INT32U)task; // Entry Point 24 25 // Don't be serious with the value below. They are of random 26 *(--stk) = (INT32U)0xFFFFFFFEL; // R14 (LR) 27 *(--stk) = (INT32U)0x12121212L; // R12 28 *(--stk) = (INT32U)0x03030303L; // R3 29 *(--stk) = (INT32U)0x02020202L; // R2 30 *(--stk) = (INT32U)0x01010101L; // R1 31 32 // pointer of the argument 33 *(--stk) = (INT32U)p_arg; // R0 34 35 // Don't be serious with the value below. They are of random 36 *(--stk) = (INT32U)0x11111111L; // R11 37 *(--stk) = (INT32U)0x10101010L; // R10 38 *(--stk) = (INT32U)0x09090909L; // R9 39 *(--stk) = (INT32U)0x08080808L; // R8 40 *(--stk) = (INT32U)0x07070707L; // R7 41 *(--stk) = (INT32U)0x06060606L; // R6 42 *(--stk) = (INT32U)0x05050505L; // R5 43 *(--stk) = (INT32U)0x04040404L; // R4 44 return stk; 45 } 46 47 // Only to initialize the Task Control Block Table 48 void OSInit(void) 49 { 50 INT8U i; 51 OS_ENTER_CRITICAL(); 52 for(i = 0; i < OS_MAX_TASKS; i++) { 53 OSTCBTbl[i].OSTCBStkPtr = (OS_STK*)0; 54 OSTCBTbl[i].OSTCBStat = TASK_STATE_CREATING; 55 } 56 OSInitTaskIdle(); 57 OSTCBCur = &OSTCBTbl[0]; 58 OSTCBNext = &OSTCBTbl[0]; 59 OS_EXIT_CRITICAL(); 60 } 61 62 void OSInitTaskIdle(void) 63 { 64 OS_ENTER_CRITICAL(); 65 OSTCBTbl[0].OSTCBStkPtr = OSTaskStkInit(OS_TaskIdle, (void *)0, (OS_STK*)&TASK_IDLE_STK[TASK_STACK_SIZE - 1]); 66 OSTCBTbl[0].OSTCBStat = TASK_STATE_RUNNING; 67 OS_EXIT_CRITICAL(); 68 } 69 70 void OSTaskCreate(void (*task)(void *p_arg), 71 void *p_arg, 72 OS_STK *p_tos) 73 { 74 OS_STK * tmp; 75 INT8U i = 1; 76 OS_ENTER_CRITICAL(); 77 while(OSTCBTbl[i].OSTCBStkPtr != (OS_STK*)0) { 78 i++; 79 } 80 tmp = OSTaskStkInit(task, p_arg, p_tos); 81 OSTCBSet(&OSTCBTbl[i], tmp, TASK_STATE_CREATING); 82 OS_EXIT_CRITICAL(); 83 } 84 85 void OSTCBSet(OS_TCB *p_tcb, OS_STK *p_tos, INT8U task_state) 86 { 87 p_tcb->OSTCBStkPtr = p_tos; 88 p_tcb->OSTCBStat = task_state; 89 } 90 91 void OS_TaskIdle(void *p_arg) 92 { 93 p_arg = p_arg; // No use of p_arg, only for avoiding "warning" here. 94 for(;;) { 95 // OS_ENTER_CRITICAL(); 96 // Nothing to do 97 // OS_EXIT_CRITICAL(); 98 } 99 } 100 101 // void SysTick_Handler(void) 102 // { 103 // // OS_ENTER_CRITICAL(); 104 // // OS_EXIT_CRITICAL(); 105 // } 106 void SysTick_Handler(void) 107 { 108 OS_ENTER_CRITICAL(); 109 if((--TaskTimeSlice) == 0){ 110 TaskTimeSlice = TASK_TIME_SLICE; 111 OSTCBCur = OSTCBNext; 112 OSCtxSw(); 113 OSTaskNext++; 114 while(OSTCBTbl[OSTaskNext].OSTCBStkPtr == (OS_STK*)0) { 115 OSTaskNext++; 116 if(OSTaskNext >= OS_MAX_TASKS) { 117 OSTaskNext = 0; 118 } 119 } 120 OSTCBNext = &OSTCBTbl[OSTaskNext]; 121 TaskTimeSlice = TASK_TIME_SLICE; 122 } 123 TimeMS++; 124 OS_EXIT_CRITICAL(); 125 } 126 127 void SysTickInit(INT8U Nms) 128 { 129 130 OS_ENTER_CRITICAL(); 131 132 TimeMS = 0; 133 TaskTimeSlice = TASK_TIME_SLICE; 134 135 SysTick->LOAD = 1000 * Nms - 1; 136 *Systick_priority = 0x00; 137 SysTick->VAL = 0; 138 SysTick->CTRL = 0x3; 139 OS_EXIT_CRITICAL(); 140 } 141 142 INT32U GetTime(void) 143 { 144 return TimeMS; 145 } 146 147 void delayMs(volatile INT32U ms) 148 { 149 INT32U tmp; 150 tmp = GetTime() + ms; 151 while(1){ 152 if(tmp < GetTime()) break; 153 } 154 } 155 156 void LedInit(void) 157 { 158 RCC->APB2ENR |= 1<<2; 159 RCC->APB2ENR |= 1<<5; 160 //GPIOE->CRH&=0X0000FFFF; 161 //GPIOE->CRH|=0X33330000; 162 163 GPIOA->CRH &= 0xfffffff0; 164 GPIOA->CRH |= 0x00000003; 165 //GPIOA->ODR &= 0xfffffeff; 166 GPIOA->ODR |= 1<<8; 167 168 GPIOD->CRL &= 0xfffff0ff; 169 GPIOD->CRL |= 0x00000300; 170 //GPIOD->ODR &= 0xfffffffd; 171 GPIOD->ODR |= 1<<2; 172 173 //LED1TURN(); 174 LED2TURN(); 175 176 }

現在我們將按照下列過程展開敘述：

初始化OS--》創建任務--》初始化OS時間單位--》初始化LED燈--》啟動OS；

“咦？怎么感覺這些步驟似曾相識呢？”

當然“相識”啦，這個就是main函數的那幾行代碼的意義啊！快看快看，第一行是OSInit()，這個函數到底做了些什么呢？

?

（1）初始化OS：

OSInit將完成以下工作：

I. ?初始化全局變量OSTCBTbl結構體數組；

II. 創建一個“Idle task”；

III.初始化OSTCBCur和OSTCBNext。

1 void OSInit(void) 2 { 3 INT8U i; 4 OS_ENTER_CRITICAL(); 5 for(i = 0; i < OS_MAX_TASKS; i++) { 6 OSTCBTbl[i].OSTCBStkPtr = (OS_STK*)0; 7 OSTCBTbl[i].OSTCBStat = TASK_STATE_CREATING; 8 } 9 OSInitTaskIdle(); 10 OSTCBCur = &OSTCBTbl[0]; 11 OSTCBNext = &OSTCBTbl[0]; 12 OS_EXIT_CRITICAL(); 13 }

?

首先是第4行，就是進入“臨界區”啦，也就是關中斷。

接著是第5~8行的循環，其實就是初始化全局變量OSTCBTbl這個結構體數組，關鍵是這個結構體的指針OSTCBStkPtr，它之后會指向每個任務對應的堆棧，

此處全部初始化為“0”。當任務被創建時，它就會指向實際的內存地址，作為任務的堆棧：

第9行，創建一個“Idle Task”。此處不繼續深挖它，我們后面會深講創建一個任務的具體過程，之后就自然能看懂該函數的具體內容了。

此處要有一個概念，也就是我們在這里已經創建了一個”Task“了，即便我們后來一個“task”也不創建，CPU也會執行“Idle task”的。

然后是第10~11行，使OSTCBCur和OSTCBNext都指向“Idle task”，OSTCBCur指“OS Task Control Block Current”，

OSTCBNext當然是指“OS Task Control Block Next”咯，這兩個指針是后來用于進行“任務切換”的，不知你可否體會呢^_^？

最后是第12行，離開臨界區，也就是開中斷。

?

（2）創建任務：

OSTaskCreate會完成以下工作：

I. ? 找到一個“空閑的”OSTCBTbl;

II. ?初始化參數“p_tos”所指向的內存，并將其作為任務堆棧，最重要的是，使堆棧記錄參數task所指向的函數的入口地址；

III. 設置新的OSTCBTbl的狀態為TASK_STATE_CREATING

（這個狀態變量在本OS中算是個bug，但好在沒有用到這個變量，所以就暫且沒管，所以你也可以暫且不管）

1 void OSTaskCreate(void (*task)(void *p_arg), 2 void *p_arg, 3 OS_STK *p_tos) 4 { 5 OS_STK * tmp; 6 INT8U i = 1; 7 OS_ENTER_CRITICAL(); 8 while(OSTCBTbl[i].OSTCBStkPtr != (OS_STK*)0) { 9 i++; 10 } 11 tmp = OSTaskStkInit(task, p_arg, p_tos); 12 OSTCBSet(&OSTCBTbl[i], tmp, TASK_STATE_CREATING); 13 OS_EXIT_CRITICAL(); 14 }

不得不提醒“小白兔們”，現在我們已經來到了這座OS之山最險峻的地方了！！！

如果實在堅持不下去了，就先休息休息。有時候，就差那么點“心領神會”，施主若是與OS有緣，那么緣分總會來的。

首先講第8~9行的循環是什么意思：

在“OS初始化”中，我們把OSTCBTbl這個結構體數組的OSTCBStkPtr指針都初始化成了“0”，當然這些被初始化的“OSTCBTbl”都是“空閑的”，也就是沒有被分配給具體任務，所以它指向堆棧地址的指針肯定是“0”，如果不是空閑的，它就應當指向具體的堆棧地址。此處循環的跳出條件就是找到某個OSTCBTbl的堆棧指針為“0”，也就是找到空閑的OSTCBTbl，此時的“i”為其偏移量。記住，“我們要創建一個新task，所以我們就需要一個空閑的OSTCBTbl來記錄這個task的堆棧信息。”這樣就能明白這個循環的目的了。

接著是第11行，也就是最難的地方了。

“OSTaskStkInit”，就是這個函數，它會完成以下工作：

I. ? 因為參數p_tos指向堆棧棧頂（Pointer Top Of Stack），所以我們要將其依次遞減，并初始化其下的一段內存中的內容。

OSTaskCreate(Task1, (void*)0, (OS_STK*)&Task1Stk[TASK_STACK_SIZE-1]);

這是main函數調用的部分，這個參數指向的正是棧頂！

1 OS_STK* OSTaskStkInit(void (*task)(void *p_arg), 2 void *p_arg, 3 OS_STK *p_tos) 4 { 5 OS_STK *stk; 6 stk = p_tos; 7 8 *(stk) = (INT32U)0x01000000L; // xPSR 9 *(--stk) = (INT32U)task; // Entry Point 10 11 // Don't be serious with the value below. They are of random 12 *(--stk) = (INT32U)0xFFFFFFFEL; // R14 (LR) 13 *(--stk) = (INT32U)0x12121212L; // R12 14 *(--stk) = (INT32U)0x03030303L; // R3 15 *(--stk) = (INT32U)0x02020202L; // R2 16 *(--stk) = (INT32U)0x01010101L; // R1 17 18 // pointer of the argument 19 *(--stk) = (INT32U)p_arg; // R0 20 21 // Don't be serious with the value below. They are of random 22 *(--stk) = (INT32U)0x11111111L; // R11 23 *(--stk) = (INT32U)0x10101010L; // R10 24 *(--stk) = (INT32U)0x09090909L; // R9 25 *(--stk) = (INT32U)0x08080808L; // R8 26 *(--stk) = (INT32U)0x07070707L; // R7 27 *(--stk) = (INT32U)0x06060606L; // R6 28 *(--stk) = (INT32U)0x05050505L; // R5 29 *(--stk) = (INT32U)0x04040404L; // R4 30 return stk; 31 }

?關鍵是為何要這樣初始化呢？第一次看的話，先從下文找點感覺，看完全部后，還需回來體味體味。

首先，參照《Cortex-M3權威指南（中文版）》P135，表9.1

?

?

中斷發生時，CPU會將以上寄存器按上述順序壓入PSP中，當我們只有一個main任務需要執行時，PSP就足夠幫我們保留現場的了，以至于在中斷返回時，從PSP去取出先前的main任務的寄存器內容就可以了（你是不是能看出上表與我們的函數內容的對應關系呢？）。

但是“多任務”當然就不止一個main任務了，假設我們有3個任務，task1，task2，task3：

task1--》task2；PSP會保留task1的寄存器信息；

task2--》task3；PSP會再保留task2的寄存器信息，但是task1的寄存器信息就被覆蓋掉了！

task3-----????-----task1

那么接下來就悲劇了。

當然，這個函數只是先給以后會用到的堆棧初始化，至于具體值并不重要，除了第8、9、19行：

第8行指定的是一個程序正常運行時，狀態寄存器PSR該有的值；

第9行指定的是任務的入口地址。這個當然重要啦！因為我們的任務就是這個地址所指向的函數。

第19行指定的是任務函數參數的所在地址，因為我們一直賦值為“0”，所以暫且沒有太多意義。

至于其他初始化的值，比如

(INT32U)0x08080808L;
這都無關緊要，隨你怎么設置都行。

?最后第30行，函數返回堆棧指針，該指針現在指向地址的內容為0x04040404L，依照注釋，就是以后存儲R4寄存器內容的地址。

?回到 OSTaskCreate函數第12行，它使得先前找到的OSTCBTbl不再“空閑了”。

?

（3）初始化SysTick中斷和LED：

在main函數中

SysTickInit(5);
LedInit();

都是與硬件相關的，唯一需要說明的是“SysTickInit(5)”當中的“5”沒有太多含義，只是越大，中斷發生的時間間隔就越大，具體依照硬件時鐘而定。

?

（4）main函數最后一行：

OSStart()

該函數一旦執行，將永不返回。注意，接下來我們要和匯編交手了，從匯編部分（os_cpu_a.asm）第31行開始。

這里要請大家注意，每行匯編語言后都有對應的C語言注釋，對照著看更容易理解。

第32行：

CPSID I

參照《Cortex-M3權威指南（中文版）》P42，該命令即為關中斷，相當于給PRIMASK寫“1”。

（注：CPSID指的是屬于CPS（Control Processor State）指令的Interrupt Disable指令）

第36~38行：

LDR R0, =NVIC_SYSPRI14

LDR R1, =NVIC_PENDSV_PRI

STRB R1, [R0]

設置PendSV中斷優先級。

第42~43行：

LDR R4, ?=0x0

MSR PSP, R4

初始PSP寄存器，使之為0。這個“0”表示的是我們的OS才啟動，還沒有任務被運行，后面很快就有說明。

第46~48行：

LDR R4, =NVIC_INT_CTRL

LDR R5, =NVIC_PENDSVSET

STR R5, [R4]

觸發PendSV中斷。

“什么！觸發中斷了！哎呀哎呀，怎么辦？中斷函數在哪兒？”

小白兔請先別著急，由于先前我們已經關掉中斷了，所以程序還會繼續往下執行，直到我們再開啟中斷。

由于我們真正的目的就是要開啟PendSV中斷，所以下一步我們要開中斷啦！

第51行：

CPSIE I

開中斷。由于PendSV被觸發了，所以接下來CPU跳到PendSV的中斷處理函數處執行。也就是os_cpu_a.asm的第59行。

第60行是關中斷。

第62~63行：

MRS R0, PSP

CBZ R0, PendSV_Handler_NoSave

比較PSP是否為0，若是0就跳轉到PendSV_Handler_NoSave處執行，由于OSStart先前將PSP初始化為0，所以就直接調到PendSV_Handler_NoSave處執行咯。

第104~107行

LDR R0, =OSTCBCur

LDR R1, =OSTCBNext

LDR R2, [R1]

STR R2, [R0]

將OSTCBNext所指向地址的前4個字節，賦給OSTCBCur所指向地址的前4個字節，而這4個字節正是兩個指針所指向結構體的OSTCBStkPtr變量！

這段代碼做的就是將下個任務的堆棧指針（OSTCBNext）賦給當前任務的堆棧指針(OSTCBCur），因為PendSV中斷所做的事情就是進行任務切換。

我們知道，一開始OSTCBCur和OSTCBNext一開始都是指向“Idle Task”的，所以下一個要運行的任務就是“Idle Task”。

第109行：

LDR R0, [R2]

將所要切換的堆棧指針地址賦給R0。

第112~134行：

LDR R4, [R0]

ADD R0, R0, #0x4

LDR R5, [R0]

ADD R0, R0, #0x4?

……

LDR R11 , [R0]

ADD R0, R0, #0x4

將堆棧指針R0所指向的堆棧內容賦給R4~R11。問個問題，“這些值都是多少你知道嗎？”

“好了，這時候你是不是想問個問題，R0~R3怎么不給它們也賦值呢？”

回到先前那個要大家需要體味的地方

參照《Cortex-M3權威MSR PSP, R0指南（中文版）》P135，表9.1

還有接下來第136行：

MSR PSP, R0

我只說一句：CPU會自動從PSP保存和加載8個量至R0~R3,R12,LR,程序入口（這個是理解的關鍵）和xPSR，我們無需動手。

第140行：

ORR LR, LR, #0x04

參照《Cortex-M3權威MSR?PSP, R0指南（中文版）》P139，這行是為了在回到任務后，確保繼續使用PSP堆棧。

第141行開中斷，此時一般還不會有中斷介入，但我們要記住，現在我們還處在PendSV中斷中，第142從PendSV中斷返回，返回后CPU則去新的任務處執行了。

?

?

讓我們再回到OS_cpu_a.asm的第62~63行，當PSP不為零，也就是已經有任務運行了，那么我們就需要先保存這個將被切換出去的任務的寄存器信息。

現在PSP指向的堆棧地址如圖所示：

?

完成第62~66行命令之后，我們得到：

該圖中有兩個”R0"，并不是很得體，我還是解釋一下，左邊的R0指的是PendSV中斷下正在使用的R0寄存器，右邊的R0指的是被中斷的任務的R0寄存機所存儲的值。

保護現場，保護現場啦！將R4~R11全部存儲起來。

“為什么R0~R3不用保護呢？”

因為……你看啊，其實CPU自己已經在PendSV中斷發生時，“擅自”把它們存儲了，就在上圖啊！

完成第69~91行命令之后，再將R0減去0x20，堆棧就變成這樣啦：

然后是第99~101行：

把R0的值賦給OSTCBCur的OSTCBStkPtr指針，這下我們就放心了，所有有關任務的信息都被存放在了相應的OSTCBTbl中了。

接下來就是該切換進入新任務了。

?

（5）誰來觸發PendSV，實現切換任務

如果到此為止，那么CPU只會一直沒完沒了的執行第一個任務：Idle Task。OSStart確實完成了一次任務切換，但也僅僅就“一次”。

main函數已經沒得指望了，它早就撒手不管了，那么誰來再次觸發PendSV，從而執行Task1、Task2呢？

別忘了，我們還有一個關鍵角色沒有登場呢：SysTick中斷。

讓我們回到myos.c的106行的SysTick的中斷服務函數：SysTick_Handler。

這個函數邏輯很簡單：每發生一次SysTick中斷，就將TimeTaskSlice遞減，當TimeTaskSlice為0時，就進行切換任務的工作，并將TimeTaskSlice的值還原。

每一次中斷發生，TimeMS都會加1，從而記錄整個系統的時間。

第111行：

OSTCBCur = OSTCBNext;

將當前任務指針指向下一個任務。

第112行：

OSCtxSw();

這是個匯編實現的函數，在os_cpu_a.asm的第144~150行。

非常簡單，它就是在觸發PendSV中斷！！！

當然，這個觸發不會立即發生，因為現在還處于關中斷狀態。

第113行：

OSTaskNext++;

之前忘記介紹了，這是個全局整型變量，用來記錄下一個任務的偏移量的。由于我們的任務沒有優先級，只是輪換執行，所以將OSTaskNext向后偏移一個就行了。

但是，如果我們偏移到了最后一個任務怎么辦呢？我們得從第一個任務重新開始才是，所以就有了第144~149的循環部分。

第120行：

OSTCBNext = &OSTCBTbl[OSTaskNext];

設置新的下一個要運行的任務的任務指針。

第121行有點多余，不要也行。

第124行開中斷，這行命令執行完之后，PendSV就會被觸發，接著就是去執行新的任務咯。

?

至此，關于本OS的關鍵代碼部分就解析完畢了。

真心希望大家多提意見，鄙人將感激涕零！

ansersion@sina.com

轉載于:https://www.cnblogs.com/ansersion/p/4328800.html

總結

以上是生活随笔為你收集整理的一步步学习操作系统（1）——参照ucos，在STM32上实现一个简单的多任务（“啰里啰嗦版”)...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。