单片机性能越来越强，很多Linux程序在单片机上也可以运行了：这需要RTOS。
我们要开发的单片机产品，功能也越来越丰富：这也需要RTOS。
就个人技术发展来说，单片机开发的技术提升方向之一就是RTOS。
RTOS已经无处不在：
开发板上电运行的第一个文件。必需的文件之一。
上述功能作为RTOS的基础，必须要实现的
/* 设置异常向量表 */
__Vectors DCD 0
DCD Reset_Handler ; Reset Handler
DCD 0 ; NMI Handler
DCD HardFault_Handler ; Hard Fault Handler
DCD 0 ; MPU Fault Handler
DCD 0 ; Bus Fault Handler
DCD UsageFault_Handler_asm ; Usage Fault Handler
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD SVC_Handler ; SVCall Handler
DCD 0 ; Debug Monitor Handler
DCD 0 ; Reserved
DCD 0 ; PendSV Handler
DCD SysTick_Handler_asm ; SysTick Handler
AREA |.text|, CODE, READONLY
/* 上电运行的第一个函数 */
; Reset handler
Reset_Handler PROC
EXPORT Reset_Handler [WEAK]
IMPORT mymain
IMPORT SystemInit
IMPORT uart_init
IMPORT UsageFaultInit
IMPORT SysTickInit
IMPORT LedInit
/* 由于会用到C函数，因此必须设置一个栈，在内存的顶部随便找了一个地方 */
LDR SP, =(0x20000000+0x10000)
/* 初始化内存，内存中的各个分区 */
BL SystemInit
/* 初始化串口 */
BL uart_init
/* 初始化中断控制器 */
BL UsageFaultInit
LDR R0, =0
LDR R1, =0x11111111
LDR R2, =0x22222222
LDR R3, =0x33333333
LDR R12, =0x44444444
LDR LR, =0x55555555
DCD 0xffffffff
SVC #1
/* 初始化系统时钟，并设置时钟中断1ms */
BL SysTickInit
/* 点灯指示 */
BL LedInit
/* 跳转到main函数执行，可以看到主函数的名字不一定非要设置为 "main" */
;BL mymain
LDR R0, =mymain
BLX R0
ENDP
在该文件中包含了任务创建、开始任务（开始调度）、获得当前任务栈、任务调度等，是RTOS中关键的主要文件。
所谓的任务环境，指的就是当该任务运行时，寄存器中的值
首先，我们能想到的
所以，创建任务的关键就是伪造任务的环境
void create_task(task_function f, void *param, char *stack, int stack_len)
{
int *top = (int *)(stack + stack_len);
/* 伪造现场 */
top -= 16;
/* 新创建任务的栈的结构如下图所示 */
/* r4~r11 */
top[0] = 0; /* r4 */
top[1] = 0; /* r5 */
top[2] = 0; /* r6 */
top[3] = 0; /* r7 */
top[4] = 0; /* r8 */
top[5] = 0; /* r9 */
top[6] = 0; /* r10 */
top[7] = 0; /* r11 */
/* r0~r3 */
top[8] = (int)param; /* r0 */
top[9] = 0; /* r1 */
top[10] = 0; /* r2 */
top[11] = 0; /* r3 */
/* r12,lr */
top[12] = 0; /* r12 */
top[13] = 0; /* lr */
/* 返回地址 */
top[14] = (int)f; /* 任务入口 */
/* PSR */
top[15] = (1<<24); /* psr 使用thumb指令集 */
/* 记录栈的位置 */
task_stacks[task_count++] = (int)top;
}
开始调度就相当于调度器的作用，当执行了start_task后，所有的任务开始运行，调度器是一个死循环，之后等待时钟中断的发生，对任务进行调度
void start_task(void)
{
/* 设置一个标志位 */
task_running = 1;
while (1);
}
在main函数中，创建了三个任务，用于模拟任务的调度。
为这三个任务分别分配了1024字节的空间，三个任务的栈并不会有交集，因此，三个任务各有自己的环境
void task_a(void *param)
{
char c = (char)param;
while (1)
{
putchar(c);
}
}
void task_c(void *param)
{
int i;
int sum = 0;
for (i = 0; i <= 100; i++)
sum += i;
while (1)
{
put_s_hex("sum = ", sum);
}
}
int mymain()
{
create_task(task_a, 'a', stack_a, 1024);
create_task(task_a, 'b', stack_b, 1024);
create_task(task_c, 0, stack_c, 1024);
start_task();
return 0;
}
任务a和任务b虽然使用的是同一个函数，但是传入的参数是不一样的，而且栈也是不同的，因此是属于不同的任务。
任务a：一直打印字符 ‘a’
任务b：一直打印字符 ‘b’
任务c：计算0-100的和
此时的栈分布如下图
在main函数中，我们已经创建了三个任务，并伪造了他们的环境，是时候启动任务了。
根据前面我们知道，在执行了start_task后，程序陷入了死循环中，此时只有中断能拯救，也就是时钟中断，即系统滴答。
在时钟设置时，设置了每1ms触发一次中断，当中断发生时，将会跳转到异常向量表的位置执行中断，
__Vectors DCD 0
DCD Reset_Handler ; Reset Handler
DCD 0 ; NMI Handler
DCD HardFault_Handler ; Hard Fault Handler
DCD 0 ; MPU Fault Handler
DCD 0 ; Bus Fault Handler
DCD UsageFault_Handler_asm ; Usage Fault Handler
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD SVC_Handler ; SVCall Handler
DCD 0 ; Debug Monitor Handler
DCD 0 ; Reserved
DCD 0 ; PendSV Handler
DCD SysTick_Handler_asm ; SysTick Handler
AREA |.text|, CODE, READONLY
就是SysTick_Handler_asm这个函数
SysTick_Handler_asm PROC
; 在这里保存R4~R11
STMDB sp!, { r4 - r11 }
STMDB sp!, { lr }
MOV R0, LR ; LR是一个特殊值
ADD R1, SP, #4
BL SysTick_Handler ; 这个C函数保证不破坏R4~R11
LDMIA sp!, { r0 }
LDMIA sp!, { r4 - r11 }
BX R0
ENDP
END
在这个函数中，上来先保存了R4~R11中的寄存器，此时要注意一个问题！
在硬件上，会自动帮我们先保存下面的寄存器即，R0~R3、R12、LR、返回地址、PSR，因此，在上面的函数中我们只保存了R4~R11，而且由于硬件帮我们自动保存了一部分东西，我们就要考虑怎么才能让他恢复呢？这时，就需要将LR设置为一个特殊值，当我们利用LR返回时，如果发现是一个特殊值，我们就需要恢复硬件保存的寄存器。
R0~R3、R12、LR、返回地址、PSR**因此，基于上面两点，我们在汇编程序中，只保存了R4~R11以及LR寄存器
; 在这里保存R4~R11
STMDB sp!, { r4 - r11 }
STMDB sp!, { lr }
MOV R0, LR ; LR是一个特殊值
ADD R1, SP, #4
BL SysTick_Handler ; 这个C函数保证不破坏R4~R11
仔细理解一下上面的指令，在保存完寄存器后，后面接着需要运行一个C函数，传入的C函数根据AAPCS规范，汇编语言向C语言传入参数时，第一个参数保存在R0，第二个参数保存在R1，第三个参数保存在R2，第四个参数保存在R3。当多于四个时，就需要用栈来传递参数了。
因此上面的指令中，将LR以及SP传给了C函数，栈的分布如下
跳转到C函数中继续执行，下面分析下C函数的作用
int is_task_running(void)
{
return task_running;
}
void SysTick_Handler(int lr_bak, int old_sp)
{
int stack;
int pre_task;
int new_task;
SCB_Type * SCB = (SCB_Type *)SCB_BASE_ADDR;
/* clear exception status */
SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk;
/* 如果还没有创建好任务, 直接返回 */
if (!is_task_running())
{
return; // 表示无需切换
}
/* 启动第1个任务或者切换任务 */
if (cur_task == -1)
{
/* 启动第1个任务 */
cur_task = 0;
/* 从栈里恢复寄存器 */
/* 写汇编 */
stack = get_stack(cur_task);
StartTask_asm(stack, lr_bak);
return ; /* 绝对不会运行到这里 */
}
······
}
cur_task = -1时，就意味着，因为刚刚创建好，还没有执行任务，因此接下来的事情就是将任务栈中的寄存器，全部恢复
#define TASK_COUNT 32
static int task_stacks[TASK_COUNT];
static int task_count;
int get_stack(int task_index)
{
return task_stacks[task_index];
}
可以看到，分配了一个数组，在这个数组中，我们在创建任务时，将任务栈顶保存在了这个数组中，因此，我们只需要获取到栈顶位置就行了
注意上面的StartTask_asm函数，需要传入两个参数，第一个参数是栈顶的位置，另一个参数是LR的值，此时的LR是一个特殊值
/* 从栈里恢复寄存器 */
/* 写汇编 */
stack = get_stack(cur_task);
StartTask_asm(stack, lr_bak);
在启动任务中，StartTask_asm是一个关键函数，下面按照流程看下这个函数
StartTask_asm PROC
; 从任务的栈里把R4~R11读出来写入寄存器
; r0 : 保存有任务的栈
; r1 : 保存有LR(特殊值)
LDMIA r0!, { r4 - r11 }
; 更新SP
MSR MSP, R0
;MOV SP, R0
; 触发硬件中断返回: 它会把栈里其他值读出来写入寄存器(R0,R1,R2,R3,R12,PSR)
BX R1
ENDP
程序中已经进行了注释，LDMIA指令，将栈中的寄存器一个个恢复。**R0~R3、R12、LR、返回地址、PSR**由硬件恢复，当执行完之后，该任务的环境就全部恢复了，此时的CPU就会运行这个任务
任务启动完毕！
由于没有切换任务，此时只有任务a在疯狂运行。
任务切换是重点了，但是并没有想象中的复杂
任务切换的流程与任务启动的流程很类似，任务启动是由于cur_task == -1才会启动任务，而任务切换cur_task已经设置了，因此走的是另外一个分支
void SysTick_Handler(int lr_bak, int old_sp)
{
int stack;
int pre_task;
int new_task;
SCB_Type * SCB = (SCB_Type *)SCB_BASE_ADDR;
/* clear exception status */
SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk;
/* 如果还没有创建好任务, 直接返回 */
if (!is_task_running())
{
return; // 表示无需切换
}
/* 启动第1个任务或者切换任务 */
if (cur_task == -1)
{
/* 启动第1个任务 */
cur_task = 0;
/* 从栈里恢复寄存器 */
/* 写汇编 */
stack = get_stack(cur_task);
StartTask_asm(stack, lr_bak);
return ; /* 绝对不会运行到这里 */
}
else
{
/* 切换任务 */
// 取出下一个任务
pre_task = cur_task;
new_task = get_next_task();
if (pre_task != new_task)
{
/* 保存 pre_task: 在汇编里已经保存了 */
/* 更新sp */
set_task_stack(pre_task, old_sp);
/* 切换 new_task */
stack = get_stack(new_task);
cur_task = new_task;
StartTask_asm(stack, lr_bak);
}
}
}
可以看到任务启动和任务切换走的是不同的分支，在任务切换分支，由于需要切换任务，因此需要找到下一个任务的栈是什么，我们才能恢复下一个任务的环境。
int get_next_task(void)
{
int index = cur_task;
index++;
if (index >= task_count)
index = 0;
return index;
}
为了简化过程，我们依次取出任务
if (pre_task != new_task)
{
····
}
判断一下，之前任务的栈与新任务栈是否一致，不一致就意味着需要切换任务了。切换任务的本质就是保存当前栈与恢复新任务栈而已
在切换之前，我们需要先保存一下当前栈的位置，下次切换到时可以直接获得
void set_task_stack(int task, int sp)
{
task_stacks[task] = sp;
}
前面讲过，在这个数组中我们保存的就是栈顶的位置。
栈保存完了，后面就是易主了
获取新任务的栈
int get_stack(int task_index)
{
return task_stacks[task_index];
}
仔细想一下，之前的栈已经保存起来了，新任务的栈也准备好了，这个状态是不是与任务启动时栈的状态一样了！
因此很巧妙，我们可以直接调用任务启动的函数了！
当再次切换到这个任务时，保持之前切换前的寄存器，程序继续向下运行，恢复时钟中断发生前寄存器的状态，此时一个时钟中断就处理完了，要知道这个整个过程1ms运行一次，因此在CPU运行时，1ms就反复进行任务切换了。
可以看到，三个任务在飞速切换中…