UCOSIII 专栏 03：常用 API 速记

OS初始化

OSInit()

OSInit() 必须在调用 OSStart()之前使用。
OSInit() 一旦检测到调用的任何子函数出现错误，程序就会立即返回。例如，如果 OSInit() 初始化任务管理器时遇到问题，程序将返回相应的错误代码，并且 OSInit() 不会继续执行。因此，用户在开始多任务处理之前检查错误代码非常重要。

1
void main (void)
2
{
3
    OS_ERR  err;
4
    OSInit(&err);                   /* Initialize µC/OS-III              */
5
    /* Check "err" */
6

7
    OSStart(&err);                  /* Start Multitasking                */
8
    /* Check "err" */               /* Code not supposed to end up here! */
9

10
}

1.初始化全局变量：

包括但不限于

OSIntNestingCtr：中断嵌套计数清零
OSRunning：OS 先标记为“未启动”
OSSchedLockNestingCtr：调度器锁嵌套计数清零
OSTCBCurPtr：当前任务指针置空
OSTCBHighRdyPtr：最高优先级就绪任务指针置空
OSPrioCur：当前优先级清零
OSPrioHighRdy：最高就绪优先级清零
…
OSInitialized = OS_TRUE; Final：内核已初始化

2.初始化各种链表 / 表

中断栈初始化：从OSCfg_ISRStkBasePtr开始，初始化中断栈，这个栈与后续创建任务的任务栈不一样
优先级位图表初始化：OS_PrioInit(); 就是一个变量为32bits的一个数组，如果数组大小为2，就有64位，表示uC/OS-III 任务优先级有64。注意**“NVIC 中断优先级”** 和 “uC/OS-III 任务优先级”
就绪链表初始化：OS_RdyListInit();

栈类型	指针	数量	用途
ISR栈	`OSCfg_ISRStkBasePtr`	1个	所有中断使用
任务栈	`p_stk_base`	每个任务1个	任务运行

[!NOTE]
Cortex-M 有两个栈指针： MSP Main Stack Pointer → ISR栈 PSP Process Stack Pointer → 任务栈任务运行使用 PSP (任务栈)
↓ 中断发生
切换 MSP (ISR栈)
↓ 中断结束
恢复 PSP (任务栈)

还有这些，就不一一列举了

OS_MemInit()：内存管理结构
OS_MsgPoolInit()：消息池 / 空闲消息链表
OS_TLS_Init()：TLS 表
OS_TaskInit()：任务管理结构
OS_TickInit()：tick/延时管理结构
OS_TmrInit()：软件定时器结构
OS_Dbg_Init()：调试结构
OSCfg_Init()：配置结构

3.创建系统任务

OS_IdleTaskInit()：空闲任务优先级：63
OS_StatTaskInit()：统计任务（条件创建）非必须优先级：62
OS_TmrInit()：软件定时器模块初始化，通常对应定时器任务/机制优先级：61

任务创建与删除

OSTaskCreat↗

A task cannot be created by an ISR. 不能中断中调用

A task must either be written as an infinite loop, or delete itself once completed. 任务要写成无线循环或者调用后删除

1
void  OSTaskCreate (OS_TCB        *p_tcb,
2
                    CPU_CHAR      *p_name,
3
                    OS_TASK_PTR    p_task,
4
                    void          *p_arg,
5
                    OS_PRIO        prio,//任务优先级
6

7
    /*是指向任务栈基地址的指针。任务栈用于存储本地变量、函数参数、返回地址，以及中断期间可能的 CPU 寄存器。*/
8
                    CPU_STK       *p_stk_base,
9
                    CPU_STK_SIZE   stk_limit,//监控并确保栈不会溢出
10
                    CPU_STK_SIZE   stk_size,
11
                    OS_MSG_QTY     q_size, //任务消息队列大小，不用就写0
12
                    OS_TICK        time_quanta,//时间片长度，不用就写0
13
                    void          *p_ext, //用户扩展数据指针
14
                    OS_OPT         opt,//选项 一般就用OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR,
15
                    OS_ERR        *p_err)

选项	作用
`OS_OPT_TASK_NONE`	无选项
`OS_OPT_TASK_STK_CHK`	任务栈检查
`OS_OPT_TASK_STK_CLR`	清空任务栈
`OS_OPT_TASK_SAVE_FP`	保存浮点寄存器
`OS_OPT_TASK_NO_TLS`	不使用 TLS

小tips：

Note that you can allocate stack space for a task from the heap but, in this case, we don’t recommend to ever delete the task and free the stack space as this can cause the heap to fragment, which is not desirable in embedded systems. 注意，你可以从堆中分配任务栈空间，但在这种情况下，我们不建议删除任务并释放栈空间，因为这可能导致堆碎片化，而这在嵌入式系统中是不理想的。

OSTaskDEL

1
void  OSTaskDel (OS_TCB  *p_tcb,
2
                 OS_ERR  *p_err)

使用：

1
/*删除自己*/
2
OSTaskDel（（（OS_TCB *）0， &err）
3
/*删除其他任务的TCB*/
4
OSTaskDel（&my_task， &err）

OS启动

OSStart()

启动 µC/OS-III 下的多任务处理。此函数通常在启动代码中调用，前提是已调用OSInit()并创建了至少一个应用程序任务。此函数OSStart()不会返回给调用者。µC/OS-III 运行后，OSStart()再次调用此函数将无效。

SInit()必须在调用之前调用OSStart()。OSStart()应用程序代码只能调用一次。但是，如果调用OSStart()多次，第二次及后续调用将不会产生任何效果

首先获取就绪任务中的最高优先级OS_PrioGetHighest，然后取出该任务控制块的头指针OSRdyList[OSPrioHighRdy].HeadPtr;

之后就调用OSStartHighRdy(); 【 See OS_CPU_A.ASM 】

1
.thumb_func
2
OSStartHighRdy:
3
    CPSID   I                                                   @ Prevent interruption during context switch
4
    MOVW    R0, #:lower16:NVIC_SYSPRI14                         @ Set the PendSV exception priority
5
    MOVT    R0, #:upper16:NVIC_SYSPRI14
6

7
    MOVW    R1, #:lower16:NVIC_PENDSV_PRI
8
    MOVT    R1, #:upper16:NVIC_PENDSV_PRI
9
    STRB    R1, [R0]
10

11
 @这个代码的翻译就是  R0=NVIC_SYSPRI14（地址），R1=NVIC_PENDSV_PRI（值），*R0=R1，即把PendSV设定为最低优先级
12

13

14
    MOVS    R0, #0                                              @ Set the PSP to 0 for initial context switch call
15
    MSR     PSP, R0
16

17
    MOVW    R0, #:lower16:OS_CPU_ExceptStkBase                  @ Initialize the MSP to the OS_CPU_ExceptStkBase
18
    MOVT    R0, #:upper16:OS_CPU_ExceptStkBase
19
    LDR     R1, [R0]
20
    MSR     MSP, R1
21

22
    BL      OSTaskSwHook                                        @ Call OSTaskSwHook() for FPU Push & Pop
23

24
@解释，PSP=0，R0 =&OS_CPU_ExceptStkBase，R1=*(R0)，MSP = OS_CPU_ExceptStkBase
25
@将MSP置于异常栈底
26

27
    MOVW    R0, #:lower16:OSPrioCur                             @ OSPrioCur   = OSPrioHighRdy;
28
    MOVT    R0, #:upper16:OSPrioCur
29
    MOVW    R1, #:lower16:OSPrioHighRdy
30
    MOVT    R1, #:upper16:OSPrioHighRdy
31
    LDRB    R2, [R1]
32
    STRB    R2, [R0]
33

34
@解释OSPrioCur = OSPrioHighRdy;确定当前最优先任务的优先级
35

36
    MOVW    R0, #:lower16:OSTCBCurPtr                           @ OSTCBCurPtr = OSTCBHighRdyPtr;
37
    MOVT    R0, #:upper16:OSTCBCurPtr
38
    MOVW    R1, #:lower16:OSTCBHighRdyPtr
39
    MOVT    R1, #:upper16:OSTCBHighRdyPtr
40
    LDR     R2, [R1]
41
    STR     R2, [R0]
42

43
@解释R2=OSTCBCurPtr = OSTCBHighRdyPtr;把任务指针指向已知的最高优先级的任务
44

45
    LDR     R0, [R2]                                            @ R0 is new process SP; SP = OSTCBHighRdyPtr->StkPtr;
46
    MSR     PSP, R0                                             @ Load PSP with new process SP
47

48
    MRS     R0, CONTROL
49
    ORR     R0, R0, #2
50
    BIC     R0, R0, #4                                          @ Clear FPCA bit to indicate FPU is not in use
51
    MSR     CONTROL, R0
52
    ISB                                                         @ Sync instruction stream
53

54
    LDMFD    SP!, {R4-R11, LR}                                  @ Restore r4-11, lr from new process stack
55
    LDMFD    SP!, {R0-R3}                                       @ Restore r0, r3
56
    LDMFD    SP!, {R12, LR}                                     @ Load R12 and LR
57
    LDMFD    SP!, {R1, R2}                                      @ Load PC and discard xPSR
58
    CPSIE    I
59
    BX       R1
60
@解释R0 = OSTCBHighRdyPtr->StkPtr;  PSP = R0;
61
@ CONTROL |= 0x2; 线程模式以后使用 PSP
62
@CONTROL &= ~0x4; 清除 FPCA，表示当前先按“不使用 FPU”处理

1
高地址
2
│
3
│ xPSR
4
│ PC
5
│ LR
6
│ R12
7
│ R3
8
│ R2
9
│ R1
10
│ R0
11
│ R11
12
│ R10
13
│ R9
14
│ R8
15
│ R7
16
│ R6
17
│ R5
18
│ R4
19
↓
20
低地址
21

22
SP 现在是 OSTCBHighRdyPtr->StkPtr，然后往上弹赋值给寄存器

上面提到MSP=OS_CPU_ExceptStkBase，将MSP置于异常栈底，让所有中断/异常使用专门的异常栈，避免破坏任务栈。

1
          MSP
2
     ┌────────────┐
3
     │ 异常栈      │
4
     │ 中断使用    │
5
     └────────────┘
6

7
          PSP
8
     ┌────────────┐
9
     │ 任务A栈     │
10
     ├────────────┤
11
     │ 任务B栈     │
12
     ├────────────┤
13
     │ 任务C栈     │
14
     └────────────┘

当然有恢复现场也有保存现场。

保存现场的流程为，比如当需要调度的时候，触发pendsv中断，PendSV_Handler()->OS_CPU_PendSVHandler

1
.thumb_func
2
OS_CPU_PendSVHandler:
3
    CPSID   I                                                   @ Cortex-M7 errata notice. See Note #5
4
    MOVW    R2, #:lower16:OS_KA_BASEPRI_Boundary                @ Set BASEPRI priority level required for exception preemption
5
    MOVT    R2, #:upper16:OS_KA_BASEPRI_Boundary
6
    LDR     R1, [R2]
7
    MSR     BASEPRI, R1
8
    DSB
9
    ISB
10
    CPSIE   I
11

12
    MRS     R0, PSP                                             @ PSP is process stack pointer
13
#if (defined(__VFP_FP__) && !defined(__SOFTFP__))
14
                                                                @ Push high vfp registers if the task is using the FPU context
15
    TST       R14, #0x10
16
    IT        EQ
17
    VSTMDBEQ  R0!, {S16-S31}
18
#endif
19

20
    STMFD   R0!, {R4-R11, R14}                                  @ Save remaining regs r4-11, R14 on process stack
21

22
    MOVW    R5, #:lower16:OSTCBCurPtr                           @ OSTCBCurPtr->StkPtr = SP;
23
    MOVT    R5, #:upper16:OSTCBCurPtr
24
    LDR     R1, [R5]
25
    STR     R0, [R1]                                            @ R0 is SP of process being switched out
26

27
                                                                @ At this point, entire context of process has been saved
28
    MOV     R4, LR                                              @ Save LR exc_return value
29
    BL      OSTaskSwHook                                        @ Call OSTaskSwHook() for FPU Push & Pop
30

31
    MOVW    R0, #:lower16:OSPrioCur                             @ OSPrioCur   = OSPrioHighRdy;
32
    MOVT    R0, #:upper16:OSPrioCur
33
    MOVW    R1, #:lower16:OSPrioHighRdy
34
    MOVT    R1, #:upper16:OSPrioHighRdy
35
    LDRB    R2, [R1]
36
    STRB    R2, [R0]
37

38
    MOVW    R1, #:lower16:OSTCBHighRdyPtr                       @ OSTCBCurPtr = OSTCBHighRdyPtr;
39
    MOVT    R1, #:upper16:OSTCBHighRdyPtr
40
    LDR     R2, [R1]
41
    STR     R2, [R5]
42

43
    ORR     LR,  R4, #0x04                                      @ Ensure exception return uses process stack
44
    LDR     R0, [R2]                                            @ R0 is new process SP; SP = OSTCBHighRdyPtr->StkPtr;
45
    LDMFD   R0!, {R4-R11, R14}                                  @ Restore r4-11, R14 from new process stack
46

47
#if (defined(__VFP_FP__) && !defined(__SOFTFP__))
48
                                                                @ Pop the high vfp registers if the next task is using the FPU context
49
    TST       R14, #0x10
50
    IT        EQ
51
    VLDMIAEQ  R0!, {S16-S31}
52
#endif
53

54
    MSR     PSP, R0                                             @ Load PSP with new process SP
55

56
    MOV     R2, #0                                              @ Restore BASEPRI priority level to 0
57
    CPSID   I                                                   @ Cortex-M7 errata notice. See Note #5
58
    MSR     BASEPRI, R2
59
    DSB
60
    ISB
61
    CPSIE   I
62
    BX      LR                                                  @ Exception return will restore remaining context
63

64
.end

PendSV中断发生时，硬件自动将 xPSR、PC(R15)、LR(R14)、R12、R3-R0 压入当前任务栈（PSP），而 R4-R11 需要在 PendSV_Handler 中由软件手动压栈保存。
PendSV_Handler 先保存当前任务的 R4-R11、LR 以及 PSP 到当前任务的 TCB（OSTCBCurPtr->StkPtr），完成旧任务上下文保护，PSP变了，此时任务栈已经变了，如果原本是保存的A的任务栈，现在就是该恢复B的任务栈了。
调度器更新当前任务信息：OSPrioCur = OSPrioHighRdy，OSTCBCurPtr = OSTCBHighRdyPtr，确定要运行的新任务。
从新任务 TCB 中取出保存的栈指针（StkPtr），恢复该任务栈中的 R4-R11、LR，并将 PSP 更新为新任务的栈顶。先手动
执行 BX LR（EXC_RETURN）触发异常返回，CPU 自动从新任务栈恢复 R0-R3、R12、LR、PC、xPSR，新任务开始运行。再自动

[!IMPORTANT]
PendSV_Handler 在 MSP 上运行，但任务上下文始终存储在 PSP 上。

临界区

通过 BASEPRI / PRIMASK 屏蔽中断。

必须 成对使用， 不支持嵌套， 临界区必须尽量短。

原因：关闭中断时间过长，会影响系统实时性

使用场景：保护共享变量，修改OS核心数据结构

1
CPU_SR_ALLOC();        // 定义中断状态变量
2

3
CPU_CRITICAL_ENTER();  // 进入临界区（关中断）
4

5
// 关键代码
6
//.....
7

8
CPU_CRITICAL_EXIT();   // 退出临界区（开中断）

挂起与恢复

OS_CFG_TASK_SUSPEND_EN 必须在 os_cfg.h 中启用

1
void   OSTaskSuspend (OS_TCB  *p_tcb,
2
                      OS_ERR  *p_err)
3

4
 p_tcb->SuspendCtr++;//内部计数器加加

无条件暂停（或阻止）任务的执行。调用任务可以通过 NULL 或者指针 p_tcb 来暂停在这种情况下，另一个任务需要恢复被暂停的任务。如果当前任务被暂停，则重新调度，μC/OS-III 会立即运行下一个优先级更高的任务。恢复暂停任务的唯一方法是调用 OSTaskResume（）。

OSTaskSuspend() 会无条件挂起指定任务，使其从调度中移除、不再参与运行；若挂起的是当前任务，则会立即触发任务调度切换到其他就绪任务，并且无论优先级多高，该任务都不会再执行，直到被 OSTaskResume() 恢复。

1
void  OSTaskResume (OS_TCB  *p_tcb,
2
                    OS_ERR  *p_err)

挂起可叠加次数，需要相同次数才能恢复。

注：恢复不等于直接插入就绪列表里面，也是要分情况的。

1
        case OS_TASK_STATE_SUSPENDED:   /*纯挂起态*/
2
             p_tcb->SuspendCtr--;
3
             if (p_tcb->SuspendCtr == 0u) {
4
                 p_tcb->TaskState = OS_TASK_STATE_RDY;
5
                 OS_RdyListInsert(p_tcb);                       /* Insert the task in the ready list                    */
6
                 OS_TRACE_TASK_RESUME(p_tcb);
7
             }
8
             CPU_CRITICAL_EXIT();
9
             break;
10

11
        case OS_TASK_STATE_DLY_SUSPENDED:  /*挂起+延时*/
12
             p_tcb->SuspendCtr--;
13
             if (p_tcb->SuspendCtr == 0u) {
14
                 p_tcb->TaskState = OS_TASK_STATE_DLY;
15
             }
16
             CPU_CRITICAL_EXIT();
17
             break;
18

19
        case OS_TASK_STATE_PEND_SUSPENDED: /*等待事件 + 挂起，比如在等信号量，消息队列*/
20
             p_tcb->SuspendCtr--;
21
             if (p_tcb->SuspendCtr == 0u) {
22
                 p_tcb->TaskState = OS_TASK_STATE_PEND;
23
             }
24
             CPU_CRITICAL_EXIT();
25
             break;
26

27
        case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:  /*带超时的等待 + 挂起*/
28
             p_tcb->SuspendCtr--;
29
             if (p_tcb->SuspendCtr == 0u) {
30
                 p_tcb->TaskState = OS_TASK_STATE_PEND_TIMEOUT;
31
             }
32
             CPU_CRITICAL_EXIT();
33
             break;
34

35
        default:
36
             CPU_CRITICAL_EXIT();
37
            *p_err = OS_ERR_STATE_INVALID;
38
             OS_TRACE_TASK_RESUME_EXIT(OS_ERR_STATE_INVALID);
39
             break;

上锁与解锁

当前任务不会被其他任务抢占，但中断可以执行。适用于：任务与任务之间的资源保护。

当调用 OSSchedLock() 锁住调度器后，当前任务不能再调用任何会“阻塞自己”的OS函数，否则系统会卡死。

OSSchedLock() 嵌套深度最多达到 250 层。当 OSSchedUnlock() 调用次数达到一定数量时，调度功能将被启用。

1
/*代码来自官方文档*/
2
void TaskX (void *p_arg)
3
{
4
    OS_ERR  err;
5
    (void)&p_arg;
6
    while (DEF_ON) {
7
        :
8
        OSSchedLock(&err);     /* Prevent other tasks to run         */
9
        /* Check "err" */
10
        :
11
        :                      /* Code protected from context switch */
12
         /* 操作共享资源 */
13
        :
14
        OSSchedUnlock(&err);   /* Enable other tasks to run          */
15
        /* Check "err" */
16
        :
17
        :
18
    }
19
}

不能使用：因为OSSchedLock()->OS不能切换任务->下列函数（比如OSTimeDly）->把任务挂起->死机

1
OSTimeDly()
2
OSSemPend()
3
OSMutexPend()
4
OSQPend()
5
OSFlagPend()

完整例子一：

start_task：初始化 CPU 库、配置 SysTick 中断及优先级、创建另外三个任务
task1：LED0 每 500ms 闪烁
task2：LED1 每 500ms 闪烁
task3：KEY0 挂起 task1，KEY1 恢复 task1

1
#include  <os.h>
2
#include  "bsp.h"
3
#include  "cpu.h"
4

5
/* ----------------------- 任务优先级 ----------------------- */
6
#define  START_TASK_PRIO       3u
7
#define  TASK1_PRIO            4u
8
#define  TASK2_PRIO            5u
9
#define  TASK3_PRIO            6u
10

11
/* ----------------------- 任务堆栈大小 ---------------------- */
12
#define  START_STK_SIZE      128u
13
#define  TASK1_STK_SIZE      128u
14
#define  TASK2_STK_SIZE      128u
15
#define  TASK3_STK_SIZE      128u
16

17
/* ----------------------- TCB 和堆栈 ----------------------- */
18
static  OS_TCB   StartTaskTCB;
19
static  CPU_STK  StartTaskStk[START_STK_SIZE];
20

21
static  OS_TCB   Task1TCB;
22
static  CPU_STK  Task1Stk[TASK1_STK_SIZE];
23

24
static  OS_TCB   Task2TCB;
25
static  CPU_STK  Task2Stk[TASK2_STK_SIZE];
26

27
static  OS_TCB   Task3TCB;
28
static  CPU_STK  Task3Stk[TASK3_STK_SIZE];
29

30
/* ----------------------- 函数声明 ------------------------- */
31
static  void  start_task(void *p_arg);
32
static  void  task1(void *p_arg);
33
static  void  task2(void *p_arg);
34
static  void  task3(void *p_arg);
35

36
/* ----------------------- 主函数 --------------------------- */
37
int main(void)
38
{
39
    OS_ERR err;
40

41
    BSP_Init();          /* 板级初始化 */
42
    CPU_Init();          /* CPU初始化 */
43

44
    OSInit(&err);        /* 初始化 uC/OS-III */
45

46
    OSTaskCreate((OS_TCB     *)&StartTaskTCB,
47
                 (CPU_CHAR   *)"start task",
48
                 (OS_TASK_PTR )start_task,
49
                 (void       *)0,
50
                 (OS_PRIO     )START_TASK_PRIO,
51
                 (CPU_STK    *)&StartTaskStk[0],
52
                 (CPU_STK_SIZE)START_STK_SIZE / 10u,
53
                 (CPU_STK_SIZE)START_STK_SIZE,
54
                 (OS_MSG_QTY  )0u,
55
                 (OS_TICK     )0u,
56
                 (void       *)0,
57
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
58
                 (OS_ERR     *)&err);
59

60
    OSStart(&err);       /* 启动多任务 */
61

62
    while (1) {
63
    }
64
}

`start_task`

1
static void start_task(void *p_arg)
2
{
3
    OS_ERR err;
4

5
    (void)p_arg;
6

7
    CPU_Init();
8

9
    /* 配置 SysTick 时钟节拍 */
10
    OS_CPU_SysTickInit(SystemCoreClock / OSCfg_TickRate_Hz);
11

12
    /* 如果你的工程里需要单独设置 SysTick 优先级，也可在这里配 */
13
    /* 例如：NVIC_SetPriority(SysTick_IRQn, 0); */
14

15
    /* 创建 task1 */
16
    OSTaskCreate((OS_TCB     *)&Task1TCB,
17
                 (CPU_CHAR   *)"task1",
18
                 (OS_TASK_PTR )task1,
19
                 (void       *)0,
20
                 (OS_PRIO     )TASK1_PRIO,
21
                 (CPU_STK    *)&Task1Stk[0],
22
                 (CPU_STK_SIZE)TASK1_STK_SIZE / 10u,
23
                 (CPU_STK_SIZE)TASK1_STK_SIZE,
24
                 (OS_MSG_QTY  )0u,
25
                 (OS_TICK     )0u,
26
                 (void       *)0,
27
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
28
                 (OS_ERR     *)&err);
29

30
    /* 创建 task2 */
31
    OSTaskCreate((OS_TCB     *)&Task2TCB,
32
                 (CPU_CHAR   *)"task2",
33
                 (OS_TASK_PTR )task2,
34
                 (void       *)0,
35
                 (OS_PRIO     )TASK2_PRIO,
36
                 (CPU_STK    *)&Task2Stk[0],
37
                 (CPU_STK_SIZE)TASK2_STK_SIZE / 10u,
38
                 (CPU_STK_SIZE)TASK2_STK_SIZE,
39
                 (OS_MSG_QTY  )0u,
40
                 (OS_TICK     )0u,
41
                 (void       *)0,
42
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
43
                 (OS_ERR     *)&err);
44

45
    /* 创建 task3 */
46
    OSTaskCreate((OS_TCB     *)&Task3TCB,
47
                 (CPU_CHAR   *)"task3",
48
                 (OS_TASK_PTR )task3,
49
                 (void       *)0,
50
                 (OS_PRIO     )TASK3_PRIO,
51
                 (CPU_STK    *)&Task3Stk[0],
52
                 (CPU_STK_SIZE)TASK3_STK_SIZE / 10u,
53
                 (CPU_STK_SIZE)TASK3_STK_SIZE,
54
                 (OS_MSG_QTY  )0u,
55
                 (OS_TICK     )0u,
56
                 (void       *)0,
57
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
58
                 (OS_ERR     *)&err);
59

60
    while (1) {
61
        OSTimeDlyHMSM(0, 0, 1, 0,
62
                      OS_OPT_TIME_HMSM_STRICT,
63
                      &err);
64
    }
65
}

`task1`：LED0 每 500ms 闪烁

1
static void task1(void *p_arg)
2
{
3
    OS_ERR err;
4

5
    (void)p_arg;
6

7
    while (1) {
8
        BSP_LED_Toggle(0);    /* LED0翻转 */
9
        OSTimeDlyHMSM(0, 0, 0, 500,
10
                      OS_OPT_TIME_HMSM_STRICT,
11
                      &err);
12
    }
13
}

`task2`：LED1 每 500ms 闪烁

1
static void task2(void *p_arg)
2
{
3
    OS_ERR err;
4

5
    (void)p_arg;
6

7
    while (1) {
8
        BSP_LED_Toggle(1);    /* LED1翻转 */
9
        OSTimeDlyHMSM(0, 0, 0, 500,
10
                      OS_OPT_TIME_HMSM_STRICT,
11
                      &err);
12
    }
13
}

`task3`：按键控制挂起/恢复 `task1`

1
static void task3(void *p_arg)
2
{
3
    OS_ERR err;
4

5
    (void)p_arg;
6

7
    while (1) {
8
        if (BSP_Key_Scan(KEY0) == 1) {
9
            OSTaskSuspend((OS_TCB *)&Task1TCB, &err);   /* 挂起 task1 */
10
        }
11

12
        if (BSP_Key_Scan(KEY1) == 1) {
13
            OSTaskResume((OS_TCB *)&Task1TCB, &err);    /* 恢复 task1 */
14
        }
15

16
        OSTimeDlyHMSM(0, 0, 0, 20,
17
                      OS_OPT_TIME_HMSM_STRICT,
18
                      &err);
19
    }
20
}

Thanks for reading!