韦东山老师 RTOS 入门课程

课程链接：韦东山直播公开课：RTOS实战项目之实现多任务系统第1节：裸机程序框架和缺陷_哔哩哔哩_bilibili

RTOS 介绍

裸机：固定顺序执行。

中断：可以一直专心做循环里的事情，直到触发中断。也可以中断里设立 flag 在循环里检测执行，防止中断超时。

定时器：太多个任务的时候不适合说都用中断。可以用定时器，设定不同任务的执行频率，比如 A 1ms 执行一次，B 2ms 执行一次…… 但是相互之间会有影响，比如 A 卡住了会影响 B。

还有一种解决办法是状态机。每个函数设定几个状态，每次执行一部分状态后保留当前状态退出，下次进入的时候继续执行。

韦东山老师 RTOS 入门课程（一）RTOS 介绍，熟悉裸机的汇编逻辑-LMLPHP

状态机忒麻烦而且也没有那么优。

RTOS 比如可以设定每个程序按一定时间片执行，到时间自己切换，不用自己写状态机那么复杂。而且现在 RTOS 生态比较好（特别是 rt-thread），而且大多数开发都需要 RTOS 。其实用了 RTOS 反而更简单。

ARM 基础

程序是什么？

运行程序时，先把程序烧录到 flash 文件中，数据放入 RAM 中（可变），CPU 读指令取数据写数据。RAM 中的数据是拿到了 CPU 的寄存器中。

这里我们重点关注6条 arm 指令即可。

读指令。LDR R0,[R1,#4]，指明了 rd, rs, length。LDR 是固定取 4B，从 R1+4 地址取。
写指令。STR R0,[R1,#4] 。
加减。ADD R0,R1,R2 ADD R0,R0,#1 SUB R0,R1,R2
比较。CMP R0,R1 结果存在 PSR 中。
跳转 B BL ，BL 是跳转后还保存返回地址。

分析C的汇编码，理解程序

韦东山老师 RTOS 入门课程（一）RTOS 介绍，熟悉裸机的汇编逻辑-LMLPHP

用一个很简单的程序来举例，Keil 进入调试模式后可以看到对应代码的汇编码。

首先通过 PUSH 指令自动压栈 r3 lr 并修改 sp 指针，保存 r3 寄存器和函数返回地址

第二句令 r0 = a 的地址。

第三句根据地址取出 a 的值存入 r0.

第四句 r0 的值存入栈0的位置，因为刚才压栈后，栈中从高到低分别存了 lr r3，也就是说r0 实际上是把数据存入栈中 r3 的位置，r3 入栈是在栈中占了一个栈中的位。

然后出栈，lr 赋值给 pc 以供函数返回，r3 获取到栈中写入的值。

再看第二个程序：

int add_val(int *pa, int *pb)
{
	volatile int tmp;
	tmp = *pa;
	tmp += *pb;
	return tmp;
}


int mymain()
{
	volatile int a = 1;
	volatile int b = 2;
	volatile int c;
	
	c = add_val(&a, &b);
	
	return 0;
}

汇编得到的代码（在 .dis 文件中）：

    i.mymain
    mymain
        0x08000372:    b50e        ..      PUSH     {r1-r3,lr}
        0x08000374:    2001        .       MOVS     r0,#1
        0x08000376:    9002        ..      STR      r0,[sp,#8]
        0x08000378:    2002        .       MOVS     r0,#2
        0x0800037a:    9001        ..      STR      r0,[sp,#4]
        0x0800037c:    a901        ..      ADD      r1,sp,#4
        0x0800037e:    a802        ..      ADD      r0,sp,#8 ;传参
        0x08000380:    f7ffffca    ....    BL       add_val ; 0x8000318
        0x08000384:    9000        ..      STR      r0,[sp,#0]
        0x08000386:    2000        .       MOVS     r0,#0
        0x08000388:    bd0e        ..      POP      {r1-r3,pc}
        0x0800038a:    0000        ..      MOVS     r0,r0
        
    i.add_val
    add_val
        0x08000318:    b508        ..      PUSH     {r3,lr}
        0x0800031a:    4602        .F      MOV      r2,r0
        0x0800031c:    6810        .h      LDR      r0,[r2,#0]
        0x0800031e:    9000        ..      STR      r0,[sp,#0]
        0x08000320:    6808        .h      LDR      r0,[r1,#0]
        0x08000322:    9b00        ..      LDR      r3,[sp,#0]
        0x08000324:    4418        .D      ADD      r0,r0,r3
        0x08000326:    9000        ..      STR      r0,[sp,#0]
        0x08000328:    9800        ..      LDR      r0,[sp,#0]
        0x0800032a:    bd08        ..      POP      {r3,pc}

可见几个函数参数 r0 r1… 来传入，超过 r3 的一般压栈，这是一个约定俗成的标准，直接传入的参数不超过4个。

参数问题，我们再尝试第二个代码：传入4个参数的 add。

程序：

int add_val(int a, int b, int c, int d)
{
	return a+b+c+d;
}


int mymain()
{
	volatile int a = 1;
	volatile int b = 2;
	volatile int c = 3;
	volatile int d = 4;
	volatile int sum;
	
	sum = add_val(a,b,c,d);
	
	return 0;
}

i.mymain
    mymain
        0x0800036a:    b500        ..      PUSH     {lr}
        0x0800036c:    b085        ..      SUB      sp,sp,#0x14
        0x0800036e:    2001        .       MOVS     r0,#1
        0x08000370:    9004        ..      STR      r0,[sp,#0x10]
        0x08000372:    2002        .       MOVS     r0,#2
        0x08000374:    9003        ..      STR      r0,[sp,#0xc]
        0x08000376:    2003        .       MOVS     r0,#3
        0x08000378:    9002        ..      STR      r0,[sp,#8]
        0x0800037a:    2004        .       MOVS     r0,#4
        0x0800037c:    9001        ..      STR      r0,[sp,#4]
        0x0800037e:    e9dd3201    ...2    LDRD     r3,r2,[sp,#4]
        0x08000382:    e9dd1003    ....    LDRD     r1,r0,[sp,#0xc]
        0x08000386:    f7ffffc7    ....    BL       add_val ; 0x8000318
        0x0800038a:    9000        ..      STR      r0,[sp,#0]
        0x0800038c:    2000        .       MOVS     r0,#0
        0x0800038e:    b005        ..      ADD      sp,sp,#0x14
        0x08000390:    bd00        ..      POP      {pc}
        0x08000392:    0000        ..      MOVS     r0,r0

存入 lr r3 r2 r1 r0 后，从低到高地址加载 r3 r2 r1 r0（大概是因为输入入栈顺序和函数参数顺序是反的），然后跳转。

i.add_val
    add_val
        0x08000318:    b510        ..      PUSH     {r4,lr}
        0x0800031a:    4604        .F      MOV      r4,r0
        0x0800031c:    1860        `.      ADDS     r0,r4,r1
        0x0800031e:    4410        .D      ADD      r0,r0,r2
        0x08000320:    4418        .D      ADD      r0,r0,r3
        0x08000322:    bd10        ..      POP      {r4,pc}

这里涉及到了函数中的寄存器保护。最近在看 MIPS 的体系结构，那里面是分了不同的寄存器（t，s，a……）arm 也是有不同作用之分。

r0-r3 传参。r13 sp，r14 lr，r15 pc。

传参的三个函数随意使用，无需保护，返回的时候值不同了也没关系。r4-r11 也可以用，但是得保存和恢复。上例中 add 函数就使用了 r4.

比如，如果代码改为：

int add_val(int a, int b, int c, int d)
{
	// 故意使用R4
	register int sum asm("r4");
	
	sum = a+b+c+d;
	
	return sum;
}

汇编：

    i.add_val
    add_val
        0x08000318:    b530        0.      PUSH     {r4,r5,lr}
        0x0800031a:    4604        .F      MOV      r4,r0
        0x0800031c:    1865        e.      ADDS     r5,r4,r1
        0x0800031e:    4415        .D      ADD      r5,r5,r2
        0x08000320:    18e8        ..      ADDS     r0,r5,r3
        0x08000322:    bd30        0.      POP      {r4,r5,pc}

r5 相当于中间计算结果，他和 r4 都要回复。

中断处理

保存现场-处理中断-还原现场，继续源程序执行。要保存哪些寄存器？

首先参数寄存器要存，不然函数还没处理参数呢来个中断参数丢了。
r4-r11 要保存，不然函数还没压栈保存呢这些丢了找不回来了，没法还原了。
lr 要保存，一样道理，没压栈的时候 lr 被修改了就没法跳转回原位置了。

实际上，发生中断的一瞬间所有寄存器都要存！

我们调用的 c 中断处理函数只能保证 r4-r11 不被破坏，所以如果想保证所有寄存器都能被保存，调用 c 函数之前就要保存。硬件自动保存其他寄存器.

恢复的时候也是硬件自动恢复其他寄存器，c 函数保证恢复 r4-r11.

硬件要保存的寄存器有 r0-r3，r12，lr，当前中断返回位置。一个典型的误区是，lr 不就是当前中断返回位置吗？ 并不是。比如 main 函数调用 A 函数，A 函数执行到一半发生了中断，这时 lr 里的值是 A 函数返回到 main 函数所需的位置地址，中断返回到 A 函数的地址需要再单独保存。

灰海宽松