第10章    任务调度-抢占式，时间片和合作式

    本章教程为大家将介绍RTX操作系统支持的任务调度方式，抢占式，时间片和合作式，这部分算是RTX操作系统的核心了。对于初学者来说，要一下子就能够理解这些比较困难些，需要多花些时间把这些基本概念搞清楚，然后阅读下源码，深入理解实现方法。

    本章教程配套的例子含Cortex-M3内核的STM32F103和Cortex-M4内核的STM32F407。

10.1 RTX支持的调度方式

10.2 什么是调度器

10.3 抢占式调度器

10.4 时间片调度器

10.5 合作式调度器

10.6 时间片调度器实验例程说明

10.7 合作式调度器实验例程说明

10.8      总结

2 Y# k- ]6 a/ B

10.1  RTX支持的调度方式

     RTX操作系统支持三种调度方式：

抢占式调度

    每个任务都有不同的优先级，任务会一直运行直到被高优先级任务抢占或者遇到阻塞式的API函数，比如os_dly_wait。

时间片调度

    每个任务都有相同的优先级，任务会运行固定的时间片个数直到遇到系统阻塞式的API函数，比如os_dly_wait。

合作式调度

    每个任务都有相同的优先级，而且时间片调度要被禁止。任务会一直的运行直到遇到阻塞式的API函数，比如os_dly_wait或者用户调用函数os_tsk_pass。

    对于RTX操作系统而言，实际应用主要是抢占式调度和时间片调度，合作式调度用到的很少。

4 q% l0 D9 j+ O' T; |

10.2 什么是调度器

    简单的说，调度器就是使用相关的调度算法来决定当前需要执行的任务。所有的调度器有一个共同的特性：调度器可以区分就绪态任务和挂起任务（由于延迟，信号量等待，邮箱等待，事件组等待等原因而使得任务被挂起）。调度器可以选择就绪态中的一个任务，然后激活它（通过执行这个任务）。当前正在执行的任务是运行态的任务。不同调度器之间最大的区别就是如何分配就绪态任务间的完成时间。

    嵌入式实时操作系统的核心就是调度器和任务切换，调度器的核心就是调度算法。任务切换的实现在各个RTOS中区别不大，基本相同的硬件内核架构，任务切换也是相似的。调度算法就有些区别了。下面我们主要了解一下合作式调度器，抢占式调度器和时间片调度器。

7 `  O% Y( h! _

10.3  抢占式调度器

10.3.1 抢占式调度器基本概念

    在实际的应用中，不同的任务需要不同的响应时间。例如，我们在一个应用中需要使用电机，键盘和LCD显示。电机比键盘和LCD需要更快速的响应，如果我们使用合作式调度器或者时间片调度，那么电机将无法得到及时的响应，这时抢占式调度是必须的。

    如果使用了抢占式调度，最高优先级的任务一旦就绪，总能得到 CPU 的控制权。当一个运行着的任务被其它高优先级的任务抢占，当前任务的 CPU 使用权就被剥夺了，或者说被挂起了，那个高优先级的任务立刻得到了 CPU 的控制权。如果是中断服务程序使一个高优先级的任务进入就绪态，中断完成时，被中断的任务被挂起，优先级高的那个任务开始运行。

    使用抢占式调度器，使得最高优先级的任务什么时候可以执行，可以得到 CPU 的控制权是可知的，同时使得任务级响应时间得以最优化。

    总的来说，学习抢占式调度掌握最关键的一点是：抢占式调度器会为每个任务都分配一个优先级，调度器会激活就绪任务中优先级最高的任务，并运行任务就绪列表里面优先级最高的那个任务。

5 ^! c1 D' S% w- j2 Q) G3 f) D
( K+ \( V' ^( [2 W) e" {2 V( d
. [& N. E: e; i, _; z; `. X10.3.2 RTX抢占式调度器的实现

    如果用户在RTX的配置向导中禁止使用时间片调度，那么每个任务必须配置不同的优先级。当RTX多任务启动执行后：

1.  首先执行的最高优先级的任务Task1，Task1会一直运行直到遇到系统阻塞式的API函数，比如延迟，事件标志等待，信号量等待，Task1任务会被挂起，也就是释放CPU的执行权，让低优先级的任务得到执行。

2.  RTX操作系统继续执行任务就绪列表中下一个最高优先级的任务Task2，Task2执行过程中有两种情况：

          （1）Task1延迟时间到，接收到信号量消息等方面的原因，在抢占式调度器的作用下，Task2的执行会被Task1抢占。

          （2）Task2会一直运行直到遇到系统阻塞式的API函数，比如延迟，事件标志等待，信号量等待，Task2任务会被挂起，继而执行就绪列表中下一个最高优先级的任务。

3.  如果用户创建了多个任务并且采用抢占式调度器的话，基本都是按照上面两条来执行。根据抢占式调度器，当前的任务要么被高优先级任务抢占，要么通过调用阻塞式API来释放CPU使用权让低优先级任务执行，没有用户任务执行时就执行空闲任务。

下面我们通过如下的框图来说明一下抢占式调度在RTX中的运行过程，让大家有一个形象的认识。

                              

运行条件：

1.  这里仅对抢占式调度进行说明。

2.  创建3个任务Task1，Task2和Task3。

3.  Task1的优先级为1，Task2的优先级为2，Task3的优先级为3。RTX操作系统是设置的数值越小任务优先级越低，故Task3的优先级最高，Task1的优先级最低。

4.  此框图是RTX操作系统运行过程中的一部分。

运行过程描述如下：

1.  此时任务Task1在运行中，运行过程中由于Task2就绪，在抢占式调度器的作用下任务Task2抢占Task1的执行。Task2进入到运行态，Task1由运行态进入到就绪态。

2.  任务Task2在运行中，运行过程中由于Task3就绪，在抢占式调度器的作用下任务Task3抢占Task2的执行。Task3进入到运行态，Task2由运行态进入到就绪态。

3.  任务Task3运行过程中调用了阻塞式API函数，比如os_dly_wait，任务Task3被挂起，在抢占式调度器的作用下查找到下一个要执行的最高优先级任务是Task2，任务Task2由就绪态进入到运行态。

4.  任务Task2在运行中，运行过程中由于Task3再次就绪，在抢占式调度器的作用下任务Task3抢占Task2的执行。Task3进入到运行态，Task2由运行态进入到就绪态。

8 E" u" F2 ?" A( f8 R; S

上面就是一个简单的不同优先级任务通过抢占式调度进行任务调度和任务切换的过程。

5 ~. N9 y# I% o5 ?

10.4 时间片调度器
' L( N  K9 w6 B" f
( A1 l; S+ K" z  ~% P/ e10.4.1 抢占式调度器基本概念

    在小型的嵌入式RTOS中，最常用的的时间片调度算法就是Round-robin调度算法。这种调度算法可以用于抢占式或者合作式的多任务中，时间片调度适合用于不要求任务实时响应的情况下。

    实现Round-robin调度算法需要给同优先级的任务分配一个专门的列表，用于记录当前就绪的任务，并为每个任务分配一个时间片（也就是需要运行的时间长度，时间片用完了就进行任务切换）。

10.4.2 RTX时间片调度器的实现

    在RTX操作系统中只有同优先级任务才会使用时间片调度，另外还需要用户在配置向导中使能时间片调度。

                              

Round-Robin Task switching

    选择是否使能时间片调度，选上单选框表示使能时间片调度，取消单选框表示不使用时间片调度。

Round-Robin Timeout [ticks]

    范围1 – 1000。

    表示时间片的大小，单位是系统时钟节拍个数。

下面我们通过如下的框图来说明一下时间片调度在RTX中的运行过程，让大家有一个形象的认识。

运行条件：

1.这里仅对时间片调度进行说明。

2.  创建4个同优先级任务Task1，Task2，Task3和Task4。

3.  每个任务分配的时间片大小是5个系统时钟节拍。

运行过程描述如下：

1.  先运行任务Task1，运行够5个系统时钟节拍后，通过时间片调度切换到任务Task2。

2.  任务Task2运行够5个系统时钟节拍后，通过时间片调度切换到任务Task3。

3.  任务Task3在运行期间调用了阻塞式API函数，调用函数时，5个系统时钟节拍的时间片大小还没有用完，此时会通过时间片调度切换到下一个任务Task4。

4.  任务Task4运行够5个系统时钟节拍后，通过时间片调度切换到任务Task1。

上面就是一个简单的同优先级任务通过时间片调度进行任务调度和任务切换的过程。

10.5 合作式调度器
. V3 q  T$ J; A  D" Y+ l
10.5.1 合作式调度器基本概念

    RTX中设计的合作式调度器比较简单，实战意义不大，用户作为了解即可，项目中没有必要采用这种调度方式的任务设计，这个也是官方的意思。原话是这么说的：For most applications, this（Round Robin Pre-emptive Scheduling） is the most useful option and you should use this scheduling schemeunless there is a strong reason to do otherwise。

    对于同优先级的任务，如果用户将RTX系统配置向导中时间片调度关闭后，这些同优先级的任务就是在合作式调度器的作用下运行。其表现出来的效果就是这些同优先级的任务会依次执行，每个任务会一直执行直到遇到阻塞式API函数或者函数os_tsk_pass ()就会切换到下个任务，这就是RTX中所说的合作式调度器。

, o; L, X# J7 ~  R0 V- i5 m
10.5.2 RTX合作式调度器的实现

    如果用户打算使用合作式调度器必须在RTX的配置向导中将时间片调度关闭并且这些任务必须是同优先级的。

    下面我们通过如下的框图来说明一下合作式调度在RTX中的运行过程，让大家有一个形象的认识。

                              

运行条件：

1.  这里仅对合作式调度进行说明。

2.  创建4个同优先级任务Task1，Task2，Task3和Task4。

运行过程描述如下：

1.  先运行任务Task1，然后调用阻塞式API或者os_tsk_pass切换到任务Task2。

2.  任务Task2运行，然后调用阻塞式API或者os_tsk_pass切换到任务Task3。

3.  任务Task3运行，然后调用阻塞式API或者os_tsk_pass切换到任务Task4。

4.  任务Task4运行，然后调用阻塞式API或者os_tsk_pass重新切换回任务Task1。

5.  一直如此循环往复下去。

上面就是一个简单的同优先级任务通过合作式调度进行任务调度和任务切换的过程。

3 |2 Z% V' ]# Y0 z, I

10.6 时间片调度器实验例程说明

10.6.1 STM32F103开发板实验

配套例子：

    V4-405_RTX实验_时间片调度

实验目的：

    1. 本实验主要学习RTX的时间片调度

实验内容：

    1. K1按键按下，串口打印。

    2. 本实验将任务AppTaskLED和AppTaskMsgPro的优先级都设置为2，同优先级的任务才会用到时间片调度。

    3. 时间片调度的使能和每个任务时间片的大小在文件RTX_Conf_CM.c文件里面

      #define OS_ROBIN        1  //使能时间片调度

      #define OS_ROBINTOUT   5  //设置每个同优先级任务的时间片大小。

    4. 各个任务实现的功能如下：

      AppTaskUserIF任务   ：按键消息处理。

      AppTaskLED任务     ：LED闪烁。

      AppTaskMsgPro任务 ：消息处理，这里用作LED闪烁。

      AppTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。

RTX配置：

    RTX配置向导详情如下：

                              

Task Configuration

Number of concurrent running tasks

        允许创建4个任务，实际创建了如下四个任务

                    AppTaskUserIF任务   ：按键消息处理。

                    AppTaskLED任务     ：LED闪烁。

                    AppTaskMsgPro任务 ：消息处理，这里是用作LED闪烁。

                    AppTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。

Number of tasks with user-provided stack

        创建的4个任务都是采用自定义堆栈方式。

Round-Robin Task switching

        使能时间片调度

Round-Robin Timeout [ticks]

    范围1 – 1000。

设置同优先级任务的时间片是5个系统时间节拍。

RTX任务调试信息：

程序设计：

任务栈大小分配：

    staticuint64_t AppTaskUserIFStk[512/8];   /* 任务栈 */

    staticuint64_t AppTaskLEDStk[256/8];      /* 任务栈 */

    staticuint64_t AppTaskMsgProStk[512/8];  /* 任务栈 */

    staticuint64_t AppTaskStartStk[512/8];     /* 任务栈 */

      将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数，浮点运算和uint64_t类型数据运算会出问题。

系统栈大小分配：

RTX初始化：

1. /*
   
2. *********************************************************************************************************
   + H3 ^1 ]; z4 w3 ~, e2 }
3. *    函 数 名: main
   " L$ _& f' k0 }; i
4. *    功能说明: 标准c程序入口。
   5 p% e! o) c* v" H* A9 a& Q
5. *    形    参: 无
   
6. *    返 回 值: 无
   0 s7 F" j2 ?9 k) s9 z
7. *********************************************************************************************************
   
8. */
   
9. int main (void)
   
10. {   
      I) n% F' U) x( O( r1 o$ ^) l
11.      /* 初始化外设 */
    % a$ `4 ?! ?  D* a, h
12.      bsp_Init();
    3 u  @( ?3 A$ V3 `+ M
13.    
    ! s9 v+ G/ w2 x9 U% L7 K! u
14.      /* 创建启动任务 */
    ! n, w8 V6 i% F' Y" B3 V
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    ( L5 x8 [, r" {3 C0 P' J3 r9 {; L
19.      while(1);
    ! b4 l' A* |; I
20. }

复制代码

- u. B; p: Z3 P: @% Q3 m' ^

RTX任务创建：

1. /*
   4 ]6 r5 U) v/ U5 |6 q9 |
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskCreate
   
4. *    功能说明: 创建应用任务
   
5. *    形    参: 无
   * q8 f  p) t8 x1 W  B
6. *    返 回 值: 无
   $ V. K2 X% s& B" j1 }5 e: @
7. *********************************************************************************************************
   
8. */
   
9. static void AppTaskCreate (void)
   2 B: j7 c9 g3 a# m* E
10. {
    
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    
12.                                            1,                         /* 任务优先级 */
    + d) Z: X6 D6 V% e4 o/ e& \8 r
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    $ [" {' `- T6 j3 u5 O0 N2 Z  d5 {
15.    
    5 x$ B8 U; F  r
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    5 _7 j. w. }0 b1 @, v7 e6 E
17.                                         2,                       /* 任务优先级 */
    ' v2 x% R! @1 ?: _$ M9 u' A5 i
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    ( R; R3 T- }9 J& P
20.    
    
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    * ^( `4 V! a/ y( g" k; K
22.                                            2,                         /* 任务优先级 */
    
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    - g$ @/ O5 o2 z! f" J
25. }

复制代码

# D+ H7 o4 }5 I6 A3 ?" M& A

四个RTX任务的实现：

1. /*
   9 S& M1 j+ S, m, I' U8 r& m4 V
2. *********************************************************************************************************
   0 A) m) N# x# _8 @: O" d! w. ]0 n
3. *    函 数 名: AppTaskUserIF
     j8 p5 [( v1 }, B: \+ W  c
4. *    功能说明: 按键消息处理     
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   
8. *********************************************************************************************************
   . j( ~1 s& Q1 P  q
9. */
   
10. __task void AppTaskUserIF(void)
    
11. {
    / o, y  u- p4 t
12.      uint8_t ucKeyCode;
    ( F' p! E- i$ I- z7 s
13. 
    
14.     while(1)
    
15.     {
    0 o( a+ _# u! ~+ h4 m6 L
16.          ucKeyCode = bsp_GetKey();
    
17.         
    
18.          if (ucKeyCode != KEY_NONE)
    
19.          {
    " |# n; M5 U& h, x
20.               switch (ucKeyCode)
    
21.               {
    4 K& o6 P4 s; R1 U; ~
22.                    /* K1键按下，打印调试说明 */
    8 o. [7 `9 s9 [) B' Y
23.                    case KEY_DOWN_K1:
    
24.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    ' Q* _; C+ ?) e
25.                        break;  
    
26. 
    1 e) I: H7 z; Z* S' E- |
27.                    /* K2键按下，非特权级模式下设置NVIC分组，从而导致系统进入到硬件异常HardFault_Handler */
    . T  w1 L, @: Q
28.                    case KEY_DOWN_K2:
    
29.                        printf("K2键按下，非特权级模式下设置NVIC分组，从而导致系统进入到硬件异常
    
30. HardFault_Handler\r\n");
    % W% ~$ L) n; a; M* K
31.                        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
    3 e4 B$ s" z1 |# Y8 W- m
32.                        break;
    
33. 
    
34.                    /* 其他的键值不处理 */
    ; s6 T2 c/ |' k8 o. u
35.                    default:                    
    / ?  J) d/ E: G% h
36.                        break;
    
37.               }
    
38.          }
    ( {( _7 ]& g& c2 ~( @1 c
39.         
    % B* j% \% _; R
40.          os_dly_wait(20);
    
41.      }
    
42. }
    . H  M4 D. ~$ T9 p2 u1 |
43. 
    4 Z' u, y% c& f
44. /*
    , O- f/ I# z0 ?' m2 N
45. *********************************************************************************************************
    
46. *    函 数 名: AppTaskLED
    
47. *    功能说明: LED闪烁。
    - Y% }+ ^8 B& Y( E5 {
48. *    形    参: 无
    % M, |+ x* L- f6 q! [" o6 P
49. *    返 回 值: 无
    
50. *   优 先 级: 2
    , u3 Y1 O  T& D$ J0 e" E
51. *********************************************************************************************************
    
52. */
    4 l, E* Q8 N; ], _) w+ ~
53. __task void AppTaskLED(void)
    
54. {
    
55.      const uint16_t usFrequency = 200; /* 延迟周期 */
    + c6 U3 o. M3 M! i
56.    
    
57.      /* 设置延迟周期 */
    # r; W8 M2 |  u: ~6 k1 i
58.      os_itv_set(usFrequency);
    
59.    
    - M5 n5 t# g5 J; {' q
60.     while(1)
    ! G3 M/ ?! b; F8 H9 J
61.     {
    
62.          bsp_LedToggle(2);
    ) T' v! ?2 }/ p
63.          bsp_LedToggle(3);
    
64. 
    6 F' ~& I- y; L- _9 X) @: e3 ~0 k
65.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    
66.           os_itv_wait();
    
67.     }
    
68. }
    : P9 m. Z& c' B) z( ]$ W
69. 
    / N8 q1 l( ?, r* v
70. /*
    
71. *********************************************************************************************************
    
72. *    函 数 名: AppTaskMsgPro
    , X7 S5 a6 b9 c3 T/ j- T$ n
73. *    功能说明: 消息处理，这里用作LED闪烁
    
74. *    形    参: 无
    
75. *    返 回 值: 无
    
76. *    优 先 级: 2
    
77. *********************************************************************************************************
    
78. */
    ) J. }) c+ f# x" l9 B* }) o2 K
79. __task void AppTaskMsgPro(void)
    
80. {
    + M2 ^2 @6 Q0 f
81.      const uint16_t usFrequency = 500; /* 延迟周期 */
    6 j' M" Y! r/ Y5 K" j
82.    
    % e* b8 R5 c. t3 l  O  w- {7 V: O' z
83.      /* 设置延迟周期 */
    
84.      os_itv_set(usFrequency);
    
85.    
    2 D1 w9 r% m. S) h  K% G4 {
86.      while(1)
    
87.      {
    
88.          bsp_LedToggle(1);
    
89.          bsp_LedToggle(4);
    
90. 
    
91.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    6 V- G  N6 r0 ?0 Q  ~2 i
92.          os_itv_wait();
    
93.      }   
    5 v0 ?2 `& }/ k9 H% e2 O% Y# {
94. }
    
95. 
    ; n- [  s- u1 Y
96. /*
    ! N; P: e0 R" ]4 n+ W1 Y+ j
97. *********************************************************************************************************
    0 `1 E- ?4 J" o( k7 c# N. q
98. *    函 数 名: AppTaskStart
    
99. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
    + k' d; |3 ?% h. M! M, C- @" b' ~
100. *    形    参: 无
     . U8 s" q0 S7 ?% P% d/ L: C+ p
101. *    返 回 值: 无
     - j% x. d; C8 b7 k* D/ t  R( ^
102. *   优 先 级: 4
     
103. *********************************************************************************************************
       E# ~8 b* r& B" m3 q
104. */
     
105. __task void AppTaskStart(void)
     6 W, Q* a: j# d/ J( I& P2 `" y5 O
106. {
     
107.      /* 创建任务 */
     : o, l  Q8 {# z
108.      AppTaskCreate();
     % s5 {+ v& N3 `! s1 j9 I  I
109.    
     
110.     while(1)
     9 G! ^6 f) e7 n" N& _, R/ C
111.     {
     / a. i% g! B3 P8 D
112.          /* 按键扫描 */
     
113.          bsp_KeyScan();
     
114.         os_dly_wait(10);
     " N% S4 `9 ?% d) G
115.     }
     
116. }

复制代码

- d% }/ G0 y8 j/ W! G
1 X- v$ q3 |$ z% k
/ D- e, u0 n: y2 a0 U% n$ G

; e. }$ H$ \$ \
6 {6 F. T6 [* s% A10.6.2 STM32F407开发板实验

配套例子：

        V5-405_RTX实验_时间片调度

实验目的：

      1. 本实验主要学习RTX的时间片调度

实验内容：

      1. K1按键按下，串口打印。

      2. 本实验将任务AppTaskLED和AppTaskMsgPro的优先级都设置为2，同优先级的任务才会用到时间片调度。

      3. 时间片调度的使能和每个任务时间片的大小在文件RTX_Conf_CM.c文件里面

         #define OS_ROBIN        1  //使能时间片调度

         #define OS_ROBINTOUT   5  //设置每个同优先级任务的时间片大小。

      4. 各个任务实现的功能如下：

        AppTaskUserIF任务   ：按键消息处理。

        AppTaskLED任务     ：LED闪烁。

        AppTaskMsgPro任务 ：消息处理，这里用作LED闪烁。

         AppTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。

RTX配置：

    RTX配置向导详情如下：

Task Configuration   

Number of concurrent running tasks

       允许创建4个任务，实际创建了如下四个任务

                      AppTaskUserIF任务   ：按键消息处理。

                      AppTaskLED任务     ：LED闪烁。

                      AppTaskMsgPro任务 ：消息处理，这里是用作LED闪烁。

                      AppTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。

Number of tasks with user-provided stack

        创建的4个任务都是采用自定义堆栈方式。

Round-Robin Task switching

        使能时间片调度

Round-Robin Timeout [ticks]

        范围1 – 1000。

        设置同优先级任务的时间片是5个系统时间节拍。

RTX任务调试信息：

程序设计：

任务栈大小分配：

        staticuint64_t AppTaskUserIFStk[512/8];   /* 任务栈 */

        staticuint64_t AppTaskLEDStk[256/8];      /* 任务栈 */

        staticuint64_t AppTaskMsgProStk[512/8];  /* 任务栈 */

        staticuint64_t AppTaskStartStk[512/8];     /* 任务栈 */

           将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数，浮点运算和uint64_t类型数据运算会出问题。

系统栈大小分配：

RTX初始化：

1. /*
   
2. *********************************************************************************************************
   3 m% ^6 c, B8 H/ t3 @
3. *    函 数 名: main
   & Z8 b1 k9 m) l
4. *    功能说明: 标准c程序入口。
   
5. *    形    参: 无
   0 J: R& Q) u! p7 X" d4 l+ B, I
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   ' L/ i. F) J  V, n; f3 g/ j
8. */
   
9. int main (void)
   # N9 ~$ N- `9 L' c8 I/ V+ n
10. {
    7 d) s3 |; z3 l) L5 d! E
11.      /* 初始化外设 */
    
12.      bsp_Init();
    / @7 D3 s* q! t' f
13.      /* 创建启动任务 */
    
14.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    
15.                        4,                        /* 任务优先级 */
    
16.                        &AppTaskStartStk,         /* 任务栈 */
    
17.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    
18.      while(1);
    
19. }
    

复制代码

5 u$ k# M# w& I

RTX任务创建：

1. /*
   
2. /*
   0 l3 [1 n3 H6 K. U4 U- t
3. *********************************************************************************************************
   8 G6 l4 n) B& M4 S) o  |% u9 g
4. *    函 数 名: AppTaskUserIF
   % Z: v) ?$ c4 |2 Q- i2 e) G
5. *    功能说明: 按键消息处理
   9 l& t9 q0 S2 I+ @9 E& _" V5 h
6. *    形    参: 无
   
7. *    返 回 值: 无
   
8. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   " B& J2 D- e9 W& J6 G* j3 A
9. *********************************************************************************************************
   ) N+ i% x) m7 G
10. */
    ; t0 P" d% E9 d( ]( x0 q2 R
11. __task void AppTaskUserIF(void)
    % f' ]6 f* @8 D( B, W5 N
12. {
    
13.      uint8_t ucKeyCode;
    
14.     while(1)
    2 h3 _, n! P7 g8 Y5 q
15.     {
    
16.          ucKeyCode = bsp_GetKey();
    
17.          if (ucKeyCode != KEY_NONE)
    : W& {% i! K& c0 M! c
18.          {
    ' o- _! S( O/ W8 L3 i8 {& }1 }
19.               switch (ucKeyCode)
    
20.               {
    ) _0 z, W, I: _
21.                    /* K1键按下，打印调试说明 */
    
22.                    case KEY_DOWN_K1:
    2 o# V9 D  A; U5 T
23.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    
24.                        break;
    
25.                    /* 其他的键值不处理 */
    ) X- O# N( _' h+ g
26.                    default:
    & v2 z; r7 G3 ^2 R4 D+ d
27.                        break;
    
28.               }
    
29.          }
    
30.          os_dly_wait(20);
    
31.      }
    
32. }
    
33. /*
    8 Y; Y5 ]( X; \" U' ^5 p5 \
34. *********************************************************************************************************
    5 ?6 N, ~4 O3 g/ I. o
35. *    函 数 名: AppTaskLED
    
36. *    功能说明: LED闪烁。
    
37. *    形    参: 无
    % E1 G. I/ H2 G! E  p
38. *    返 回 值: 无
    0 d: T$ q& q" p* I. }- v
39. *   优 先 级: 2
    
40. *********************************************************************************************************
    6 a( _) q3 W! U9 J
41. */
    
42. __task void AppTaskLED(void)
    * g0 _9 h+ a& L) u7 W/ @/ ~; w& ?
43. {
    8 Z0 s' K+ {$ N
44.      const uint16_t usFrequency = 200; /* 延迟周期 */
    5 S7 _* c1 ?: g6 K7 p. h. x  L, _4 ^" ?
45.      /* 设置延迟周期 */
    7 W4 ?  d/ \4 K9 \
46.      os_itv_set(usFrequency);
    4 S( U1 U) Y8 H  u
47.     while(1)
    * L7 s1 f3 Y% z8 C, J* H
48.     {
    
49.          bsp_LedToggle(2);
    6 R! a# `. F. s+ u' [& M
50.          bsp_LedToggle(3);
    0 j, N* d" M7 i3 \
51.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    7 M: B1 \1 w) g- \. j6 r
52.          os_itv_wait();
    # [7 d# B9 X: O9 A- W; l
53.     }
    
54. }
    
55. /*
    , F$ q7 w) q. `/ M$ k7 o/ d+ R2 r
56. *********************************************************************************************************
    4 p$ K1 z$ t! c. R5 \# D
57. *    函 数 名: AppTaskMsgPro
    $ \+ @- v/ b  J. x. [1 {% y( _2 [( W5 g; \
58. *    功能说明: 消息处理，这里用作LED闪烁
    : i4 @6 ^7 e2 a9 S# v
59. *    形    参: 无
    
60. *    返 回 值: 无
    # ?8 }2 n, K- v  h
61. *   优 先 级: 2
    
62. *********************************************************************************************************
    
63. */
    
64. __task void AppTaskMsgPro(void)
    + S4 R0 t' d$ d% W; t/ G6 L3 J
65. {
    
66.      const uint16_t usFrequency = 500; /* 延迟周期 */
      y) w. L. V& s7 o5 O
67.      /* 设置延迟周期 */
    
68.      os_itv_set(usFrequency);
    
69.      while(1)
    
70.      {
    4 G% O* s, z: a+ D8 j5 j0 W- c
71.          bsp_LedToggle(1);
    
72.          bsp_LedToggle(4);
    3 T$ [( _- A" G4 d8 b. G5 f! T
73.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    1 {5 H+ i! N/ l2 C; R2 P5 F
74.          os_itv_wait();
      C4 j, r% @& X, F
75.      }
    
76. }
    
77. /*
    
78. *********************************************************************************************************
    6 M$ E4 d0 G3 N
79. *    函 数 名: AppTaskStart
    
80. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
    
81. *    形    参: 无
    
82. *    返 回 值: 无
    
83. *   优 先 级: 4
    
84. *********************************************************************************************************
    5 o3 D3 f/ O. d$ r6 Z% H
85. */
    
86. __task void AppTaskStart(void)
    ( \4 \7 \. L8 _: A/ u; O& {
87. {
    
88.      /* 创建任务 */
    
89.      AppTaskCreate();
    # N7 u, v; V$ Q6 J2 @
90.     while(1)
    
91.     {
    7 s! `$ ]# k( V1 w+ T( `
92.          /* 按键扫描 */
    6 [: z9 ]' i+ \9 m
93.          bsp_KeyScan();
    ; ]+ R; C5 U; P- |) j7 H
94.         os_dly_wait(10);
    
95.     }
    1 E/ q2 y" s6 B8 l% M6 T2 ~, Z
96. }

复制代码

5 L& \; h7 ~9 A; c% W

# {2 x  a7 }0 n$ y5 f: o
2 R- z. u& R  o" f3 e! A, {* r
' U( y$ X2 W! G2 v

10.7 合作式调度器实验例程说明
- M. h0 f* U, |+ [: ]2 Z! g( ~5 T
10.7.1 STM32F103开发板实验

配套例子：

    V4-406_RTX实验_合作式调度

实验目的：

    1. 本实验主要学习RTX的合作式调度

实验内容：

    1. K1按键按下，串口打印。

    2. 本实验将任务AppTaskLED和AppTaskMsgPro的优先级都设置为2，同优先级的任务才会用到合作式调度。

    3. 使用合作式调度的话，用户必须在RTX操作系统的配置向导文件RTX_Conf_CM.c中禁止时间片调度：

      #define OS_ROBIN       0 //禁止时间片调度

    4. 各个任务实现的功能如下：

     AppTaskUserIF任务   ：按键消息处理。

     AppTaskLED任务     ：LED闪烁。

     AppTaskMsgPro任务 ：消息处理，这里用作LED闪烁。

     AppTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。

RTX配置：

     RTX配置向导详情如下：

                              

Task Configuration

    Number of concurrent running tasks

          允许创建4个任务，实际创建了如下四个任务

                    AppTaskUserIF任务   ：按键消息处理。

                    AppTaskLED任务     ：LED闪烁。

                    AppTaskMsgPro任务 ：消息处理，这里是用作LED闪烁。

                    AppTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。

    Number of tasks with user-provided stack

         创建的4个任务都是采用自定义堆栈方式。

    Round-Robin Task switching

        使用合作式调度必须禁止时间片调度，切记。

RTX任务调试信息：

程序设计：

任务栈大小分配：

    staticuint64_t AppTaskUserIFStk[512/8];   /* 任务栈 */

    staticuint64_t AppTaskLEDStk[256/8];      /* 任务栈 */

    staticuint64_t AppTaskMsgProStk[512/8];  /* 任务栈 */

    staticuint64_t AppTaskStartStk[512/8];     /* 任务栈 */

    将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数，浮点运算和uint64_t类型数据运算会出问题。

系统栈大小分配：

RTX初始化：

1. /*
   - o" n! G8 x. F9 R  m8 M
2. *********************************************************************************************************
   - p3 ~9 ?& R0 ^8 v+ }' e
3. *    函 数 名: main
   
4. *    功能说明: 标准c程序入口。
   , L8 k! l% y, x3 i; H+ h
5. *    形    参: 无
   
6. *    返 回 值: 无
   ; M; G8 l# I/ {- p) I7 s+ a5 ~1 `
7. *********************************************************************************************************
   ! l' v& p& s" N/ X9 K
8. */
   
9. int main (void)
   
10. {   
    , p; `: P$ V$ u1 ?1 U* Y
11.      /* 初始化外设 */
    / ^( K, S, y$ Q+ U6 G8 T
12.      bsp_Init();
    ) P# j0 w; x2 u- X" o
13.    
    
14.      /* 创建启动任务 */
    , ?2 [. l2 b$ U9 U9 W2 Y' i/ D
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    , g0 m4 S9 H% L3 t0 w1 C: E( r0 C
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    ; i" Y( ]5 C2 S- f8 w6 O9 Q7 v6 A
19.      while(1);
    % B. g1 a9 a% r' M
20. }

复制代码

! n' a4 U0 Y, h) D! c" b' D: {* }

RTX任务创建：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskCreate
   
4. *    功能说明: 创建应用任务
   * R0 W% \5 F9 A$ Y5 x
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void AppTaskCreate (void)
   8 j. a9 Y1 j5 L# R
10. {
    
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    
12.                                            1,                         /* 任务优先级 */
    
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    + @% B& d$ ]/ x- m# R4 U4 Q* X% ^
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    
15.    
    5 C7 j. ^3 n# N; P2 F
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    
17.                                         2,                       /* 任务优先级 */
    + v5 p+ }/ {: u1 ]/ H8 T$ k
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    1 h5 z2 ~6 S: p8 `
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    
20.    
    # p$ m4 b& W, B- k+ t0 }# D0 h
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    
22.                                            2,                         /* 任务优先级 */
    
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    4 Z1 C& M: S( N4 s
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    
25. }

复制代码

四个RTX任务的实现：

1. /*
   
2. *********************************************************************************************************
   - D4 X; }5 A' ~% q: T3 g8 y
3. *    函 数 名: AppTaskUserIF
   3 H* K* g! j% t, D- ?
4. *    功能说明: 按键消息处理     
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   . W  z8 i- I. x  C
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   0 G! I/ K, G; o" J+ v2 Y
8. *********************************************************************************************************
   
9. */
   5 a0 e; u' k) |2 P8 X' z
10. __task void AppTaskUserIF(void)
    
11. {
    ' R0 p! v3 o( `7 O  I4 G2 z
12.      uint8_t ucKeyCode;
    9 {  m( v/ V7 [
13. 
    0 F. {6 J6 D: S: u  @- n
14.     while(1)
    
15.     {
    % v+ h* E# l, ~+ @) r- H
16.          ucKeyCode = bsp_GetKey();
    
17.         
    : `9 s) V5 i8 n' n9 Q
18.          if (ucKeyCode != KEY_NONE)
    
19.          {
    
20.               switch (ucKeyCode)
    + L$ Q1 ~) @3 K0 {$ v
21.               {
    ' _: v, N' ?: S" u) o5 U4 C  H
22.                    /* K1键按下，打印调试说明 */
    
23.                    case KEY_DOWN_K1:
    ! s6 H5 e% {* T; @6 y1 r5 H
24.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    
25.                        break;  
    9 H: S; P) u4 h1 M5 E% e" x
26. 
    3 p. z, G6 ~# E4 Y2 m: E
27.                    /* 其他的键值不处理 */
    ' i4 H% [7 S0 V( b' q' L, v
28.                    default:                     
    , A# y" o- M: g4 G# g
29.                        break;
    $ X8 G3 ^7 _' p: u
30.               }
      [: f/ D: i2 t8 _+ k( N2 ]  Z
31.          }
    * i; P- O( q" W# s
32.         
    $ [: s* A/ h) W6 s3 v4 A
33.          os_dly_wait(20);
    0 r' y& i/ Q  a- Y
34.      }
    
35. }
    
36. 
      n8 e7 Y- F- Z+ i
37. /*
    
38. *********************************************************************************************************
    
39. *    函 数 名: AppTaskLED
    - T9 n# J2 r& t+ |  M' h5 d
40. *    功能说明: LED闪烁。
    
41. *    形    参: 无
    
42. *    返 回 值: 无
    * f/ j" t$ o7 m
43. *   优 先 级: 2
    ' `. N1 R7 a* L# u
44. *********************************************************************************************************
    
45. */
    9 W2 a6 p5 U3 R  l5 Z
46. __task void AppTaskLED(void)
    
47. {
    
48.      const uint16_t usFrequency = 200; /* 延迟周期 */
    * F! ?, J# J+ g3 T/ M
49.    
    0 F5 m( H' v% F8 q8 M" s, T; B
50.      /* 设置延迟周期 */
    
51.      os_itv_set(usFrequency);
    # k/ M( J2 J1 q! r& z. }3 K
52.    
    
53.     while(1)
    ; E! i$ B! U! |4 D6 J; V& x
54.     {
    " F; F# A/ J1 L
55.          bsp_LedToggle(2);
    
56.          bsp_LedToggle(3);
    0 i# b& p' N7 @( `
57. 
    * q  I4 s/ d6 _( w% n- E5 i
58.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    4 U+ \1 R  Y8 J* x
59.          os_itv_wait();
    + j$ L# R2 S5 A, Q8 C2 s( m& l
60.     }
    
61. }
    3 S- Z' a( \" {
62. 
    
63. /*
    0 t* @" ~: @: |; H! ]
64. *********************************************************************************************************
    
65. *    函 数 名: AppTaskMsgPro
    
66. *    功能说明: 消息处理，这里用作LED闪烁
    
67. *    形    参: 无
    
68. *    返 回 值: 无
    8 O" o1 M# Z& T6 M2 a
69. *    优 先 级: 2
    
70. *********************************************************************************************************
    
71. */
    ) G: P+ P8 }7 q) T4 }4 s$ O& Y
72. __task void AppTaskMsgPro(void)
    
73. {
    
74.      const uint16_t usFrequency = 500; /* 延迟周期 */
    * p/ A" Q' e8 v7 f' X0 |  D, z
75.    
    
76.      /* 设置延迟周期 */
    
77.      os_itv_set(usFrequency);
    0 I0 f8 F& L. \/ u2 g4 G4 r1 S
78.    
    
79.      while(1)
    & O2 H" o3 x7 n9 x
80.      {
    ; I) P0 G7 n" d+ ]6 v! T
81.          bsp_LedToggle(1);
    
82.          bsp_LedToggle(4);
    
83. 
    
84.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    3 H2 z# F) A; p4 o
85.          os_itv_wait();
    , y. v; H* c% P% t
86.      }   
    
87. }
    0 z0 u4 B; T9 h- d" _- N
88. 
    9 E/ `8 d/ }, f) f
89. /*
    
90. *********************************************************************************************************
    ' L- |; [) _$ P' ~4 W2 z& z8 A
91. *    函 数 名: AppTaskStart
    + Q5 Z/ ~2 a) c6 K
92. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
    
93. *    形    参: 无
    
94. *    返 回 值: 无
    
95. *   优 先 级: 4
    
96. *********************************************************************************************************
    
97. */
    
98. __task void AppTaskStart(void)
    . F0 b+ Z0 l0 l9 m
99. {
    
100.      /* 创建任务 */
     
101.      AppTaskCreate();
     
102.    
     
103.     while(1)
     # @: T; O/ {! x# \* y& X
104.     {
     6 b* R4 D% ?* |. J: z
105.          /* 按键扫描 */
     : B4 B' L- c) C  z) e
106.          bsp_KeyScan();
     
107.         os_dly_wait(10);
     2 Z# O7 w1 |# R3 B
108.     }
     
109. }

复制代码

$ f/ O/ w! r( Q% C

10.7.2 STM32F407开发板实验

配套例子：

      V5-406_RTX实验_合作式调度

实验目的：

      1. 本实验主要学习RTX的合作式调度

实验内容：

      1. K1按键按下，串口打印。

      2. 本实验将任务AppTaskLED和AppTaskMsgPro的优先级都设置为2，同优先级的任务才会用到合作式调度。

      3. 使用合作式调度的话，用户必须在RTX操作系统的配置向导文件RTX_Conf_CM.c中禁止时间片调度：

          #define OS_ROBIN       0 //禁止时间片调度

      4. 各个任务实现的功能如下：

         AppTaskUserIF任务   ：按键消息处理。

         AppTaskLED任务     ：LED闪烁。

         AppTaskMsgPro任务 ：消息处理，这里用作LED闪烁。

         AppTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。

RTX配置：

      RTX配置向导详情如下：

Task Configuration

    Number of concurrent running tasks

        允许创建4个任务，实际创建了如下四个任务

                      AppTaskUserIF任务   ：按键消息处理。

                      AppTaskLED任务     ：LED闪烁。

                      AppTaskMsgPro任务 ：消息处理，这里是用作LED闪烁。

                      AppTaskStart任务    ：启动任务，也是最高优先级任务，这里实现按键扫描。

    Number of tasks with user-provided stack

         创建的4个任务都是采用自定义堆栈方式。

    Round-Robin Task switching

        使用合作式调度必须禁止时间片调度，切记。

RTX任务调试信息：

程序设计：

任务栈大小分配：

      staticuint64_t AppTaskUserIFStk[512/8];   /* 任务栈 */

      staticuint64_t AppTaskLEDStk[256/8];      /* 任务栈 */

      staticuint64_t AppTaskMsgProStk[512/8];  /* 任务栈 */

      staticuint64_t AppTaskStartStk[512/8];     /* 任务栈 */

        将任务栈定义成uint64_t类型可以保证任务栈是8字节对齐的，8字节对齐的含义就是数组的首地址对8求余等于0。如果不做8字节对齐的话，部分C语言库函数，浮点运算和uint64_t类型数据运算会出问题。

系统栈大小分配：

RTX初始化：

1. /*
   ; h% H+ K( O: k3 e
2. *********************************************************************************************************
   6 Z8 h; `2 S3 V" u" U6 G+ M  B
3. *    函 数 名: main
   5 n6 j+ Q5 Q$ I
4. *    功能说明: 标准c程序入口。
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. int main (void)
   
10. {   
    
11.      /* 初始化外设 */
    * ^* s+ e$ _5 J1 s3 D. [. J4 k5 N& Z
12.      bsp_Init();
    8 v* Y. Q; P; T1 s5 R* P
13.    
    ( b; b$ H5 S6 C( F4 Q% @$ i
14.      /* 创建启动任务 */
    ' b" T2 a/ J  K/ z# A
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    0 w$ @( N2 `+ N  \. m; u4 f0 @7 u& M! ?0 L
19.      while(1);
    0 ]2 ?& q& N* g
20. }

复制代码

& K  @9 }9 |! y8 n- b* `

RTX任务创建：

1. /*
   " ]0 ^) C/ j2 K; l4 n5 l" \% L, K1 ?+ y
2. /*
   : o8 b0 _1 R, i- {5 h  S8 y
3. *********************************************************************************************************
   1 m2 A7 E' c5 G* G9 N
4. *    函 数 名: AppTaskUserIF
   
5. *    功能说明: 按键消息处理     
   
6. *    形    参: 无
   
7. *    返 回 值: 无
   
8. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   ' F4 [% d; ]/ w3 }9 I
9. *********************************************************************************************************
   0 d$ |( ~2 c5 a0 n
10. */
    
11. __task void AppTaskUserIF(void)
    
12. {
    ! x* S3 Y* t- k5 {  R, {( v
13.      uint8_t ucKeyCode;
      b& K" j3 h2 ?& K4 q* g
14. 
    3 k) V: U0 k: R; P7 V3 h  {
15.     while(1)
    
16.     {
    
17.          ucKeyCode = bsp_GetKey();
    
18.         
    
19.          if (ucKeyCode != KEY_NONE)
    / [9 Q3 Y( N- W
20.          {
    # w) d2 J8 |$ V* D3 T  H
21.               switch (ucKeyCode)
    
22.               {
      U! s& q7 a' N2 z. }7 k+ S
23.                    /* K1键按下，打印调试说明 */
    0 O" D  C& J! o" |
24.                    case KEY_DOWN_K1:
    9 v( v! O) d4 d7 b6 K/ O9 B+ Y# X5 [
25.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    
26.                        break;  
    
27. 
    4 E4 S6 W- o4 d1 d
28.                    /* 其他的键值不处理 */
    
29.                    default:                    
    % q0 ?6 Z( B: i$ U  D1 `. l+ F0 m
30.                        break;
    
31.               }
    2 Y5 Q, E) s$ ?5 h8 d7 h7 T: N
32.          }
    
33.         
    
34.          os_dly_wait(20);
    
35.      }
    # G/ s5 B# g6 V) j8 S6 j
36. }
    7 w3 @1 h% N: s) s
37. 
    
38. /*
    
39. *********************************************************************************************************
    
40. *    函 数 名: AppTaskLED
    
41. *    功能说明: LED闪烁。
    
42. *    形    参: 无
    
43. *    返 回 值: 无
    ( v9 }0 A8 c8 a
44. *   优 先 级: 2
    $ T7 M$ ?. R' s
45. *********************************************************************************************************
    ; X- _& K" ]" B" n3 K: x
46. */
    
47. __task void AppTaskLED(void)
    & C# S% O& g. E7 ^, F
48. {
    6 t+ t2 X- E3 }6 G' z
49.      const uint16_t usFrequency = 200; /* 延迟周期 */
    
50.    
    
51.      /* 设置延迟周期 */
    
52.      os_itv_set(usFrequency);
    . T7 c# z4 P7 i4 \  y% H! X" o/ s/ y* V
53.    
    ! q9 E$ i# ^8 R6 |" f9 c( d: v. x) ~
54.     while(1)
    
55.     {
    
56.          bsp_LedToggle(2);
    ( s4 t" F  e' z2 Y/ O9 j4 q
57.          bsp_LedToggle(3);
    / G1 K1 F) ]+ m! w4 j
58. 
    
59.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    ' I4 B7 |9 i1 O$ A1 ?# M, Q
60.          os_itv_wait();
    ! h* n1 f4 w9 D8 x& }+ u. X
61.     }
    9 ]  C5 l$ N6 h" G, [3 W$ M* v6 W5 ~
62. }
    
63. 
    
64. /*
    * `3 `4 E9 F- m8 J
65. *********************************************************************************************************
    
66. *    函 数 名: AppTaskMsgPro
    
67. *    功能说明: 消息处理，这里用作LED闪烁
    
68. *    形    参: 无
    
69. *    返 回 值: 无
    % \3 S8 T* w4 }1 B: X- ]
70. *   优 先 级: 2
    
71. *********************************************************************************************************
    
72. */
    
73. __task void AppTaskMsgPro(void)
    2 ~) N5 Z$ _: s6 Q+ A& w
74. {
    9 ]" Z; ]! h! U: K, g! L$ v
75.      const uint16_t usFrequency = 500; /* 延迟周期 */
    
76.    
    ; \) Z; D1 W( _& b4 m) \' {- g
77.      /* 设置延迟周期 */
    
78.      os_itv_set(usFrequency);
    . f' C; Q1 W- [5 B0 r( V/ d
79.    
    7 h; K+ n5 T1 K! y% D
80.      while(1)
    
81.      {
    
82.          bsp_LedToggle(1);
    
83.          bsp_LedToggle(4);
    , Q2 v' Z" `5 t$ u$ H, D4 E# K& \! W
84. 
    0 J+ p" g( f0 E3 s% M7 o' U& w
85.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    ; Q  j$ t! i2 {' `# F/ M
86.          os_itv_wait();
    
87.      }   
    3 u9 f  q$ L7 p; v* M
88. }
    
89. 
    
90. /*
    
91. *********************************************************************************************************
    2 |; B3 c, z+ ?2 W- k
92. *    函 数 名: AppTaskStart
    
93. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
    
94. *    形    参: 无
    4 k0 X9 f5 v' J1 E& n
95. *    返 回 值: 无
    
96. *   优 先 级: 4
    
97. *********************************************************************************************************
    
98. */
    
99. __task void AppTaskStart(void)
    " }  I0 y9 v; a3 ]5 A  z: y1 K
100. {
     
101.      /* 创建任务 */
     & C$ K- q' H. c& R5 O
102.      AppTaskCreate();
     
103.    
     
104.     while(1)
     
105.     {
     : r: Y/ h6 i# D: d" w
106.          /* 按键扫描 */
     
107.          bsp_KeyScan();
     8 S! o) i+ o4 u
108.         os_dly_wait(10);
     
109.     }
     
110. }

复制代码

/ E7 f5 x5 d$ D) Z) [

10.8 总结

    本章节是RTX操作系统的核心，初学者要深入理解的话要多花些时间。当然，如果有其它RTOS的基础的话，这个学起来也是很快的。

   好东西  感谢LZ