第17章    定时器组

    本章节为大家讲解RTX支持的定时器组，或者叫软件定时器，或者叫用户定时器均可。软件定时器的功能比较简单，也容易掌握。被称为定时器组是因为用户可以创建多个定时器，创建的个数是可配置的。

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

17.1 定时器组介绍

17.2 定时器组API函数

17.3 实验例程说明

17.4      总结

& r5 O6 |5 Y2 c% ]

17.1  定时器组介绍

    RTX提供的定时器功能仅支持单次定时器，也就是用户创建了定时器并启动了定时器后，定时时间到将不再重新执行，此定时器会被删除掉并且就执行一次，下次使用要重新的创建，这个就是单次定时器的含义。另外就是单次定时时间到后会调用定时器的回调函数，用户可以回调函数中加入需要执行的工程代码。

    使用此定时器组注意以下问题：

（1）定时器回调函数os_tmr_call在文件RTX_Conf_CM.c文件中。

（2）定时器回调函数os_tmr_call中仅支持isr_开头的系统函数，os_开头的不支持，因为回调函数是在滴答定时器中断中执行的。

（3）RTX的定时器仅支持单次，不支持周期性执行，如果需要周期执行，需要重复创建。

（4）可以创建的定时器个数可以在RTX配置向导中设置：

17.2  定时器组API函数

   使用如下3个函数可以实现RTX的定时器组：

os_tmr_create

os_tmr_kill

os_tmr_call

关于这3个函数的讲解及其使用方法可以看教程第3章3.3小节里面说的参考资料rlarm.chm文件

                              

这里我们重点的说一下函数os_tmr_create和os_tmr_call。

17.2.1  函数os_tmr_create

函数原型：

1. OS_ID os_tmr_create (
   $ A/ s6 I; s! K8 ~/ d8 y! D
2.     U16 tcnt,      /* 定时器的时钟节拍个数 */
   # j3 H5 Q% n( T" Q- F
3.     U16 info );    /* 定时器回调函数的参数，可用于区分不同的定时器 */

复制代码

函数描述：

函数os_tmr_create用于创建定时器组并启动定时器，定时时间到后调用回调函数os_tmr_call。函数os_tmr_create的第二个参数也会传递给回调函数os_tmr_call用于区分不同的定时器。

    （1）第1个参数填写定时器的时钟节拍个数。范围0-0xFFFF。

    （2）第2个参数填写回调函数的参数，可用于区分不同的定时器。

    （3）定时器创建成功的话会返回定时器的ID标识，失败的话返回NULL。

使用举例：

1. #include <rtl.h>
   
2. 
   
3. /* 定时器句柄 */
   
4. OS_ID  OneShotTimerID1;
   
5. 
   $ C* T; X6 I7 X" r/ `
6. __task void task1 (void) {
   9 L* n  F, ?6 h, [+ W2 n( `- P
7.    ..
   5 H: E8 T  g, u0 R/ K( E- _
8.   OneShotTimerID1= os_tmr_create (10, 1);
   
9.   if (OneShotTimerID1 == NULL) {
   
10.     printf ("创建失败\n");
    8 A& P5 M& W7 V4 b5 R
11.   }
    
12.    ..
    8 F5 y8 l9 y# y% E1 x* L
13. }

复制代码

  U/ A9 G+ I- ~( y& Q3 i' |. I" G
17.2.2 函数os_tmr_call

函数原型：

1. void os_tmr_call (
   
2.     U16 info );    /*定时器回调函数的参数，可用于区分不同的定时器*/

复制代码

8 m, m6 c' d, x; J

函数描述：

当函数os_tmr_create设置的定时时间到后调用回调函数os_tmr_call。函数os_tmr_create的第二个参数也会传递给回调函数os_tmr_call用于区分不同的定时器。此函数执行完毕后，通过函数os_tmr_create创建的定时器会被删除，下次使用需要重新创建。

（1）此函数的参数不需要用户去添加，系统会自动将函数os_tmr_create第二个参数赋值给这个参数。

使用举例：

1. #include <rtl.h>
   9 n  g7 Q, Y' A1 {! i
2. 
   
3. void os_tmr_call (U16 info) {
   5 s) h+ f% I, y3 g, \
4.   /* 定时器回调函数中仅支持isr_开头的系统函数，os_开头的不支持，此回调函数是在
   % v+ h3 j! j4 F9 ]2 R/ A
5.      滴答定时器中断中执行的。
   # [% v, W9 E5 {8 C( t8 y
6.   */
   
7.   switch(info)
   
8.   {
   
9. case 1:          /* 参数为1 */
   
10.          isr_sem_send (&semaphore);     
    ) `# U) \4 O! T4 s, |" x2 u  Z
11.          break;
    
12.          
    + K$ d$ e- ~# O# V' K; D
13.       case 2:          /* 参数为2 */
    
14.         bsp_LedToggle(1);   
    # k* ]1 g$ T  u, [/ Y
15.         break;
    
16.   }
    
17. }

复制代码

& G! C. ^5 s* L
6 h( Z; U' J1 i( \0 u$ W$ R

17.3 实验例程说明
; ?  h9 k+ q& [17.3.1 STM32F103开发板实验

配套例子：

    V4-416_RTX实验_定时器组

实验目的：

    1.     学习RTX的定时器组

    2.     RTX的定时器仅支持单次，不支持周期性执行，如果需要周期执行，需要重复创建

    3.     定时器回调函数os_tmr_call中仅支持isr_开头的系统函数，os_开头的不支持，此回调函数是在滴答定时器中断中执行的。

    4.     回调函数os_tmr_call在文件RTX_Conf_CM.c文件中。

实验内容：

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

    2.K2键按下，创建单次定时器，10个系统时钟节拍后在定时器回调函数中给任务AppTaskMsgPro发信号量同步信号。

    3.K3键按下，创建单次定时器，10个系统时钟节拍后在定时器回调函数翻转LED1。

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

  AppTaskUserIF任务   ：按键消息处理。

  AppTaskLED任务     ：LED闪烁。

  AppTaskMsgPro任务 ：消息处理，等待RTX定时器发来的信号量同步信号。

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

RTX配置：

    RTX配置向导详情如下：

                              

Task Configuration

    Number of concurrent running tasks

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

                AppTaskUserIF任务   ：按键消息处理。

                AppTaskLED任务     ：LED闪烁。

                AppTaskMsgPro任务 ：消息处理，等待RTX定时器发来的信号量同步信号。

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

    Number of tasks with user-provided stack

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

    Number of user timers

  范围1 – 250，表示用户定时器个数。

  这里创建了1个用户定时器。

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. /*
   4 s3 B4 H* ~0 B/ q7 Y- \) g
2. *********************************************************************************************************
   
3. *    函 数 名: main
   ; d. Q# F2 a! @% ^8 ^# ^
4. *    功能说明: 标准c程序入口。
   
5. *    形    参: 无
   8 q( j  r7 H6 Y8 H. y
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ( D& R- v/ f. |; V
9. int main (void)
   
10. {   
    ! ~1 `! G- e4 B* ]
11.      /* 初始化外设 */
    
12.      bsp_Init();
    * ]( P) a" q6 S1 G! j
13.    
    
14.      /* 创建启动任务 */
    . P; D. S& C0 ]  t! m$ G9 @2 u
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    % Q9 g- g" B6 i0 a! ~+ _
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    
19.      while(1);
    9 k  w: C- b& n
20. }

复制代码

RTX任务创建：

1. /*
   ! T! E9 ^- o% i
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskCreate
   7 ]+ r- Y( }* n! {  |6 V
4. *    功能说明: 创建应用任务
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   . `: l/ ?' W6 ]6 l+ `8 r  }8 U
8. */
   ) o1 U( C9 y# z+ a, |8 L' u
9. static void AppTaskCreate (void)
   4 O3 s; Q. l: K0 ]. |# d- b* |1 y  S
10. {
    0 u0 U2 z$ l, Y: V. w
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    $ d" Z7 F2 e2 V9 d  A. A
12.                                            1,                         /* 任务优先级 */
    
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    
15.    
    4 D" q2 W9 U0 Q  B- a( H& o* L
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    
17.                                         2,                       /* 任务优先级 */
    ; ]  v! j; [2 W. G0 Q. K! J0 l
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    8 _- Q( v# B( y% E' ]7 W2 \
20.    
    , u( y( n% {4 v/ z% u- ]9 @0 |$ H2 q
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    
22.                                            3,                         /* 任务优先级 */
    
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    8 G) e; d) D% w
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    : S9 A- P* V! _$ U+ ~9 D$ H
25. }

复制代码

创建信号量：

1. OS_SEM semaphore;
   $ \4 w5 I1 z* \! v, Q
2. 
   ( O. Y( w- i  n% T4 R8 M
3. /*
   : \" a2 C, _$ M( ~( Q9 \7 _4 }4 d
4. *********************************************************************************************************
   : Y' ]% u# V4 k' U1 S
5. *    函 数 名: AppObjCreate
   
6. *    功能说明: 创建任务通信机制
   9 T! a/ d/ e% W' }6 E' u3 f
7. *    形    参: 无
   
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   & O! t" H7 h3 c+ j/ x1 U
10. */
    
11. static void AppObjCreate (void)
    ! G8 m3 J$ }1 y9 Y" U
12. {
    
13.      /* 创建信号量计数值是0, 用于任务同步 */
    ' `! i5 O7 O! h9 O2 m; M/ ]( C' B
14.      os_sem_init (&semaphore, 0);
    3 [: }' m8 \' c. K
15.    
    - P0 T6 F( H# ~5 l, H. T0 j
16. }

复制代码

四个RTX任务的实现，定时器的创建在任务AppTaskUserIF中实现：

1. /*
   
2. /*
   , @" A" c8 m6 i7 G
3. *********************************************************************************************************
   # G/ R" Y# _6 @
4. *    函 数 名: AppTaskUserIF
   8 L, k+ _/ L5 \
5. *    功能说明: 按键消息处理     
   0 L0 D: ]3 j3 F* N0 H
6. *    形    参: 无
   1 D! J% S% c$ ~5 O( `
7. *    返 回 值: 无
   
8. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   : U% s% ?3 W8 h* m2 d- o
9. *********************************************************************************************************
   
10. */
    ' a4 l! L& c9 j& E7 {' P9 m1 f
11. __task void AppTaskUserIF(void)
    
12. {
    
13.      uint8_t ucKeyCode;
      L" o. J+ q9 G1 d9 S' F# _5 G
14. 
    ) q, _7 v! }1 Y  s3 |$ T: Q' w* P, @, h
15.     while(1)
    + H+ t, u  E+ J! S, d% s
16.     {
    
17.          ucKeyCode = bsp_GetKey();
    6 O6 l) o8 J3 `/ \; V' I8 k: h
18.         
    
19.          if (ucKeyCode != KEY_NONE)
    6 n8 n+ q+ N& x% m( C% k" ?
20.          {
    
21.               switch (ucKeyCode)
      V4 ~6 V* l9 y. m1 }) X
22.               {
    # P6 r4 `$ ^2 W5 `' ~
23.                    /* K1键按下，打印调试说明 */
    
24.                    case KEY_DOWN_K1:
    % D1 a! d( d( r6 b1 k0 E
25.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    
26.                        break;  
    
27.                   
    + r! M5 h1 h9 C6 E+ B
28.                    /*
    , u. @+ T. i( B1 l, b7 L! M
29.                       K2键按下，创建单次定时器，定时时间10个系统时钟节拍, 在定时器回调函数中给任务
    
30.                       AppTaskMsgPro发信号量同步信号
    
31.                    */
    
32.                    case KEY_DOWN_K2:
    3 b1 }4 g+ P$ S
33.                        printf("K2键按下，创建单次定时器，10个系统时钟节拍后在定时器回调函数中给任务
    0 p4 q$ }; W0 l4 `6 z& u
34. AppTaskMsgPro发信号量同步信号\r\n");
    
35.                        /*
    4 ~6 T1 A' F, z% k6 s5 T0 C$ t- s8 N# ]- P
36.                          1. RTX的定时器仅支持单次，不支持周期性执行，如果需要周期执行，需要重复创建
    
37.                          2. 定时器回调函数os_tmr_call中仅支持isr_开头的系统函数，os_开头的不支持，此回调函
    
38. 数是在滴答定时器中断中执行的。
    1 {6 N  X/ M! n. I
39.                          3. 回调函数os_tmr_call在文件RTX_Conf_CM.c文件中。
    & {8 u! f: g6 C& ~& |' F) k
40.                        */
    % \' Z$ g* G0 [1 e8 i7 D
41.                        OneShotTimerID1 = os_tmr_create(10,  /* 定时10个系统时钟节拍 */
    " k/ b# e% C6 C& S- }
42.                                                       1);  /* 回调函数的参数，可用于区分不同的定时器 */
    % X% W7 t' Y5 i( p
43.                      
    
44.                        if (OneShotTimerID1 == NULL)
    
45.                        {
    
46.                             /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
    
47.                        }
    
48.                        break;
    ' J6 o2 V( t  e. |" J5 i: x
49.                      
    6 _2 _; f% u: w& n( |7 o; }
50.                    case KEY_DOWN_K3:
    0 z) u; F; Z( J- p) l! X
51.                        printf("K3键按下，创建单次定时器，10个系统时钟节拍后在定时器回调函数翻转LED1\r\n");
    4 d0 a* P! N' M4 ?
52.                        OneShotTimerID2 = os_tmr_create(10,  /* 定时10个系统时钟节拍 */
    
53.                                                        2);  /* 回调函数的参数，可用于区分不同的定时器 */
    
54.                      
    
55.                        if (OneShotTimerID2 == NULL)
    0 K, \2 Y3 `+ O  Z1 }$ v! P
56.                        {
    
57.                             /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
    
58.                        }
    # r8 x3 V  O; [
59.                        break;
      d  ?: u2 F4 U5 A1 |1 Z
60. 
    9 q. `, p( P& }0 \; r- e& T
61.                    /* 其他的键值不处理 */
    
62.                    default:                    
    + {( @% Y+ T$ d1 I+ @6 _
63.                        break;
    + s# H& a- g: }+ [7 |" N  g* `
64.               }
    2 N9 c. \: E. o; T% p: ^! e
65.          }
    4 [; }8 r  m" ~
66.         
    ; j& Z! H, W: `" |6 ^# ~, J" X
67.          os_dly_wait(20);
    ' K* A  J" U9 }2 G( h/ X" x8 Y4 e0 `
68.      }
    
69. }
    , D, @8 I! r, n! }3 B5 c0 d- Q
70. 
    
71. /*
    
72. *********************************************************************************************************
    # E) }5 l& y$ ?4 b& `" [
73. *    函 数 名: AppTaskLED
    
74. *    功能说明: LED闪烁。
    
75. *    形    参: 无
    
76. *    返 回 值: 无
    
77. *   优 先 级: 2
    
78. *********************************************************************************************************
    
79. */
    
80. __task void AppTaskLED(void)
    
81. {
    
82.      const uint16_t usFrequency = 200; /* 延迟周期 */
    
83.    
    
84.      /* 设置延迟周期 */
    ; V2 }' o6 S) O1 ^+ |1 M
85.      os_itv_set(usFrequency);
    . O5 h  P- Z; h6 ^: P
86.    
    
87.     while(1)
    % t9 j: z9 ?) y* _5 n0 ^3 w
88.     {
    1 N$ b# X& [0 e+ K
89.          bsp_LedToggle(2);
    
90.          bsp_LedToggle(3);
    # G6 S  m2 ^4 K5 O5 |" f8 O
91. 
    
92.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    6 z, _( E# k" I3 M3 Y/ P& x
93.          os_itv_wait();
    9 m, b1 A; E+ Z% j* g7 ]
94.     }
    
95. }
    
96. 
    ( j0 F( w) l9 F, H1 ^5 W  N
97. /*
    
98. *********************************************************************************************************
    , L/ M  \+ P, G& f& x
99. *    函 数 名: AppTaskMsgPro
    ! h9 ~+ j" U6 B( h% C! I
100. *    功能说明: 消息处理，等待RTX定时器发来的信号量同步信号
     
101. *    形    参: 无
     9 x6 A9 t: I% ~1 T) W3 f
102. *    返 回 值: 无
     0 k  H$ ^' G) ?8 a- H
103. *   优 先 级: 3
     3 G7 `& e/ H* E( p0 X
104. *********************************************************************************************************
     + g5 T3 K% A+ Z4 O3 V$ }* ^$ W7 i
105. */
     
106. __task void AppTaskMsgPro(void)
     6 t- D# E% M* V, e; t# H3 w
107. {
     # N" c' X3 @& ^) X0 X1 x
108.      OS_RESULT xResult;
     ) p0 m" M4 y) o# \' |3 v! o
109.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
     + |1 X0 n* ^/ A$ j' D. C
110.    
       y* a0 R& d" O3 |9 ?
111.     while(1)
     + g, m1 a" h" @: l
112.     {
     
113.          xResult = os_sem_wait (&semaphore, usMaxBlockTime);
     
114.         
     
115.          switch (xResult)
     ( t- f. j" q8 x/ b6 W, W
116.          {
     * w/ M# R7 p- X: A+ H/ y, u$ r
117.               /* 无需等待接受到信号量同步信号 */
       Q, r6 p$ b, B3 D5 ~
118.               case OS_R_OK:
     
119.                    printf("无需等待接受到信号量同步信号\r\n");
     & g/ L( e/ C. G$ {( |
120.                    break;  
     9 i7 V" d6 W; p2 L  o' q2 Q+ Y
121. 
     
122.               /* 信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号 */
     
123.               case OS_R_SEM:
     
124.                    printf("信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号\r\n");
     0 f- f" c2 o. T( Q6 y
125.                    break;
     
126. 
     
127.               /* 超时 */
     
128.               case OS_R_TMO:
     3 D* _% q) ?0 D- m7 @
129.                    bsp_LedToggle(4);
     * p( B  [9 M0 c& w* N% j, I
130.                    break;
     9 H& O1 H. @- t, s- L5 d0 C: q6 ^
131.             
     
132.               /* 其他值不处理 */
     
133.               default:                    
     
134.                    break;
     , K" E# S  q6 T
135.          }   
     
136.     }
     
137. }
     * g! C1 {; {5 v  B3 K' v8 Y& a5 {) x
138. 
     3 X! F& N5 Y, h7 k  c& E: }8 @# ~+ k' O
139. /*
     
140. *********************************************************************************************************
     
141. *    函 数 名: AppTaskStart
     
142. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     
143. *    形    参: 无
     % l) p8 e  i, g8 C
144. *    返 回 值: 无
     ) l9 r! E: z' m& E; z2 ?
145. *   优 先 级: 4
     
146. *********************************************************************************************************
     
147. */
     
148. __task void AppTaskStart(void)
     ' S$ N' N% i9 R6 Y# {$ M9 t  Q! [, T
149. {
     $ E0 l1 W/ n$ L. b7 B6 _9 X
150.      /* 创建任务 */
     
151.      AppTaskCreate();
     
152.    
       ^9 }& k1 S* `9 y, P
153.      /* 创建任务通信机制 */
     
154.      AppObjCreate();
     ) o. D. F- r+ A6 v9 ^
155.    
     9 z0 d* A( y3 s; z8 I3 j% T
156.     while(1)
     : H- D* E0 G! O* u2 w1 X9 d8 z
157.     {
     * w+ j/ C' E( X1 h( x
158.          /* 按键扫描 */
     
159.          bsp_KeyScan();
     & I& Z/ ]+ H$ x* _0 F  i
160.         os_dly_wait(10);
     3 w" `+ s! J$ M1 |
161.     }
     ( U& D9 \# B6 J' u' @9 ~) \2 k$ i
162. }

复制代码

定时器回调函数的实现，在文件RTX_Conf_CM.c：

1. /*--------------------------- os_tmr_call -----------------------------------*/
   
2. #include "bsp.h"
   
3. extern OS_SEM semaphore;
   
4. void os_tmr_call (U16 info) {
   
5.   /* This function is called when the user timer has expired. Parameter   */
   
6.   /* 'info' holds the value, defined when the timer was created.          */
   * i8 |  ?, [/ R
7. 
   4 y# Z( i7 a; X  ?& w+ J# `
8.   /* HERE: include optional user code to be executed on timeout. */
   
9.   /* 定时器回调函数中仅支持isr_开头的系统函数，os_开头的不支持，此回调函数是在
   
10.      滴答定时器中断中执行的。
    
11.   */
    ' s' A# W/ r- F# ?: o
12.   switch(info)
    . A" x4 S6 x# A  n
13.   {
    % X$ V& f" p) Q' o1 B" M6 J( _
14.      case 1:          /* 参数为1 */
    & _& f8 j. G6 d" o" A7 o6 J
15.       isr_sem_send (&semaphore);     
    
16.       break;
    
17.    
    
18.      case 2:          /* 参数为2 */
    
19.        bsp_LedToggle(1);   
    
20.       break;
    5 Y; F: H3 z  A+ A) R' E2 R
21.   }
    ' D! z4 D. r4 w5 A, w7 U
22. }

复制代码

! N* e: S: t2 I( D) A* h
0 J/ Y& G& c* X( Y

17.3.2 STM32F407开发板实验

配套例子：

    V4-416_RTX实验_定时器组

实验目的：

    1.     学习RTX的定时器组。

    2.     RTX的定时器仅支持单次，不支持周期性执行，如果需要周期执行，需要重复创建。

    3.     定时器回调函数os_tmr_call中仅支持isr_开头的系统函数，os_开头的不支持，此回调函数是在滴答定时器中断中执行的。

    4.     回调函数os_tmr_call在文件RTX_Conf_CM.c文件中。

实验内容：

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

    2.K2键按下，创建单次定时器，10个系统时钟节拍后在定时器回调函数中给任务AppTaskMsgPro发信号量同步信号。

    3.K3键按下，创建单次定时器，10个系统时钟节拍后在定时器回调函数翻转LED1。

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

    AppTaskUserIF任务   ：按键消息处理。

    AppTaskLED任务     ：LED闪烁。

    AppTaskMsgPro任务 ：消息处理，等待RTX定时器发来的信号量同步信号。

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

RTX配置：  

    RTX配置向导详情如下：

                              

Task Configuration

Number of concurrent running tasks

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

                AppTaskUserIF任务   ：按键消息处理。

                AppTaskLED任务     ：LED闪烁。

                AppTaskMsgPro任务 ：消息处理，等待RTX定时器发来的信号量同步信号。

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

    Number of tasks with user-provided stack

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

    Number of user timers

  范围1 – 250，表示用户定时器个数。

  这里创建了1个用户定时器。

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. *    函 数 名: main
   
4. *    功能说明: 标准c程序入口。
   ; P3 d9 I$ p) S4 r! k
5. *    形    参: 无
   
6. *    返 回 值: 无
   % I8 E# j: z8 s' ^1 n$ ?% u: f
7. *********************************************************************************************************
   % m6 u9 E! S, J1 T  d6 {- z( V
8. */
   
9. int main (void)
   : ]4 ^$ G- x( j
10. {   
    
11.      /* 初始化外设 */
    
12.      bsp_Init();
      D; ]6 x; y1 [8 f! P( ]7 J( A
13.    
    
14.      /* 创建启动任务 */
    # ]( d: l& r7 U; b
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    
19.      while(1);
      {0 O+ V4 V4 {% [, \
20. }

复制代码

RTX任务创建：

1. /*
   
2. *********************************************************************************************************
   : c: B# }- n8 @! U7 M. D
3. *    函 数 名: AppTaskCreate
   # j7 ?; N6 V, R) T% S" J- a
4. *    功能说明: 创建应用任务
   9 k' Z' _' m' u3 m* F
5. *    形    参: 无
   . C( p# e) D& {. a  {8 i
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void AppTaskCreate (void)
   
10. {
    3 Q# ?% O; F; c& [0 k# l. G
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    4 F" l" P; ^  R
12.                                            1,                         /* 任务优先级 */
    . {" T2 ]* P2 b2 F" G& B6 \+ c
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    
15.    
    ; z7 v! C# N% M  @7 z
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    
17.                                         2,                       /* 任务优先级 */
      l1 K$ B" n6 j$ p) X
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    ! M5 \& Y) x7 K/ C4 k& w
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    ' u- ~# a2 L. w; l) f
20.    
    0 ^) h8 W- i1 `, J( s
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    0 R  O) q# s: b( W% O/ a9 O, f
22.                                            3,                         /* 任务优先级 */
    
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    8 O7 W+ a8 g# b; D
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    ! {2 }. m5 L8 f" q9 c
25. }

复制代码

% b5 ^* Y4 G' k/ O# R' V

创建信号量：

1. OS_SEM semaphore;
   
2. 
   3 Y* N; K8 `/ t- b: k$ b+ I
3. /*
   
4. *********************************************************************************************************
   2 Z6 ]- |$ o" H1 \9 x9 n
5. *    函 数 名: AppObjCreate
   1 o* n$ g" y! a% w( P1 v6 [* i
6. *    功能说明: 创建任务通信机制
   
7. *    形    参: 无
   2 }( d% q- N2 r8 ?  ?2 ?  g# G4 N
8. *    返 回 值: 无
   
9. *********************************************************************************************************
   # [. i6 g& A: f3 w# x/ ?4 R5 r
10. */
    : d1 \2 w; k* A0 z$ J
11. static void AppObjCreate (void)
    2 S2 i: N% G% l0 h. ]2 ~
12. {
    + \+ Q- t, w4 z5 B$ @
13.      /* 创建信号量计数值是0, 用于任务同步 */
    
14.      os_sem_init (&semaphore, 0);
    ) W2 p, y* T# X( z( i
15.    
    1 \6 h4 K8 ~% i* I* W3 o8 S
16. }

复制代码

四个RTX任务的实现，定时器的创建在任务AppTaskUserIF中实现：

1. /*
   
2. /*
   ! p8 m+ U8 h# v2 a5 Q# p8 \4 u) e
3. *********************************************************************************************************
   
4. *    函 数 名: AppTaskUserIF
   
5. *    功能说明: 按键消息处理     
   7 J2 A1 u3 t' M: c" O( ?
6. *    形    参: 无
   
7. *    返 回 值: 无
   - V4 W- ~9 S, W2 T; ^: l0 l
8. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   
9. *********************************************************************************************************
   
10. */
    
11. __task void AppTaskUserIF(void)
    ' C! P$ T8 }5 H0 m' x
12. {
    
13.      uint8_t ucKeyCode;
    
14. 
    
15.     while(1)
    
16.     {
    
17.          ucKeyCode = bsp_GetKey();
    
18.         
    0 y: f( i% T$ l) h# m, a/ P( G* Q
19.          if (ucKeyCode != KEY_NONE)
    
20.          {
    # ?0 H/ M! N) R3 H3 \
21.               switch (ucKeyCode)
    
22.               {
    
23.                    /* K1键按下，打印调试说明 */
    3 `% D, w: Q0 [" h
24.                    case KEY_DOWN_K1:
    , r/ w7 B( h' a( F, m
25.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    
26.                        break;  
    / [; W  D& F& t8 _$ _  d. o
27.                   
    
28.                    /*
    
29.                       K2键按下，创建单次定时器，定时时间10个系统时钟节拍, 在定时器回调函数中给任务
    1 o+ O* f6 W) E' O. Z
30.                       AppTaskMsgPro发信号量同步信号
    
31.                    */
    
32.                    case KEY_DOWN_K2:
    
33.                        printf("K2键按下，创建单次定时器，10个系统时钟节拍后在定时器回调函数中给任务
    
34. AppTaskMsgPro发信号量同步信号\r\n");
    
35.                        /*
    . [0 g+ ?' N( [8 k
36.                          1. RTX的定时器仅支持单次，不支持周期性执行，如果需要周期执行，需要重复创建
    8 P/ H3 ?' @: m' C+ G0 J
37.                          2. 定时器回调函数os_tmr_call中仅支持isr_开头的系统函数，os_开头的不支持，此回调函
    
38. 数是在滴答定时器中断中执行的。
    . j. i$ c8 c7 p" Q: O
39.                          3. 回调函数os_tmr_call在文件RTX_Conf_CM.c文件中。
    
40.                        */
    ( q2 B, S8 G1 O% k
41.                        OneShotTimerID1 = os_tmr_create(10,  /* 定时10个系统时钟节拍 */
    
42.                                                       1);  /* 回调函数的参数，可用于区分不同的定时器 */
    5 P" I7 i1 T* N& F; c2 w% g0 D) e
43.                      
    " i. |1 Z* c; r* d4 a1 d1 i+ u" C- F
44.                        if (OneShotTimerID1 == NULL)
    6 E# \+ u, V9 p9 Q/ A4 V# ]
45.                        {
    
46.                             /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
    
47.                        }
    & Q3 ^  P/ e& o( `
48.                        break;
    " u  Z- f$ O: _
49.                      
    
50.                    case KEY_DOWN_K3:
    
51.                        printf("K3键按下，创建单次定时器，10个系统时钟节拍后在定时器回调函数翻转LED1\r\n");
    * z+ i9 ]4 T, Z% k
52.                        OneShotTimerID2 = os_tmr_create(10,  /* 定时10个系统时钟节拍 */
    6 u/ d. m, `, N: G; h5 @; C
53.                                                        2);  /* 回调函数的参数，可用于区分不同的定时器 */
    . x! j7 i5 f! N" o
54.                      
    1 x5 [; {5 i6 }( y! Z8 y
55.                        if (OneShotTimerID2 == NULL)
    8 v  W  y" q) n. \
56.                        {
    * C8 D# i, T" _1 O" q" R
57.                             /* 没有创建成功，用户可以在这里加入创建失败的处理机制 */
    & |, J$ g% I8 x7 |: h& M
58.                        }
    
59.                        break;
    % B9 M% I# i" {+ `1 e# F% t
60. 
    3 n* ~6 Y5 @" _3 l0 p, H
61.                    /* 其他的键值不处理 */
    
62.                    default:                    
    
63.                        break;
    
64.               }
    
65.          }
    
66.         
    
67.          os_dly_wait(20);
    " ^- ]% F& J- p2 K0 O  `6 R
68.      }
    
69. }
    
70. 
    . |8 C# K3 l' u
71. /*
    
72. *********************************************************************************************************
    * w0 i: D7 p- x1 z/ Z
73. *    函 数 名: AppTaskLED
    
74. *    功能说明: LED闪烁。
    
75. *    形    参: 无
    " {& H' v: s( c6 k2 N  v! w
76. *    返 回 值: 无
    1 n' n$ V" @( R$ b* I3 |. @% p
77. *   优 先 级: 2
    . ~" F! I  ~8 F( U
78. *********************************************************************************************************
    2 W" S) f! g, S2 `1 j  P
79. */
    : _% S/ X0 F" s3 ~2 o
80. __task void AppTaskLED(void)
    8 p( M1 H5 S" ]0 d# n
81. {
    
82.      const uint16_t usFrequency = 200; /* 延迟周期 */
    
83.    
    ( E. ~: C+ T  w# `, X! o7 K, Q0 ^
84.      /* 设置延迟周期 */
    
85.      os_itv_set(usFrequency);
    
86.    
    
87.     while(1)
    
88.     {
    
89.          bsp_LedToggle(2);
    , O' x8 \6 U' W& l3 ^% o; q+ t% k; B
90.          bsp_LedToggle(3);
    : ~% D( i2 g1 B( z
91. 
    / b, c6 V7 }. x/ h- i
92.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    
93.          os_itv_wait();
    5 R! M- L$ m* l7 K7 z: y
94.     }
    
95. }
    
96. 
      h; c6 h  ]; ~% a
97. /*
    * C6 L0 T% z! ?- ~
98. *********************************************************************************************************
    2 c  E# ]7 T6 E( _  J( i
99. *    函 数 名: AppTaskMsgPro
    
100. *    功能说明: 消息处理，等待RTX定时器发来的信号量同步信号
       G! d3 E3 {; m0 X
101. *    形    参: 无
     $ ^- i. k8 M7 g
102. *    返 回 值: 无
     
103. *   优 先 级: 3
     
104. *********************************************************************************************************
     ! P# K. n; A' Y  a' U6 w
105. */
     
106. __task void AppTaskMsgPro(void)
     , j0 I- h- f6 m, l
107. {
     
108.      OS_RESULT xResult;
     ( r* T# D! b' \
109.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
     + p) [2 z& X- B+ h# k
110.    
     : H' A0 o) z! Q, {, Y: f& {
111.     while(1)
     + L6 x" o7 Z" Y" x. f7 A5 w8 z
112.     {
     
113.          xResult = os_sem_wait (&semaphore, usMaxBlockTime);
     ) @2 o! _/ T5 j: Q  r* W6 ]+ Y6 u! }
114.         
     : m+ A2 F- j. h) F7 J
115.          switch (xResult)
     * U; t% b7 {% v; t2 {
116.          {
     
117.               /* 无需等待接受到信号量同步信号 */
     
118.               case OS_R_OK:
     
119.                    printf("无需等待接受到信号量同步信号\r\n");
     # A# A1 \' S# P2 X8 L0 w) k$ h
120.                    break;  
     ; R+ m5 y% U6 @  F
121. 
     0 e8 Q  K7 p+ e, M6 u( d- T
122.               /* 信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号 */
     
123.               case OS_R_SEM:
     4 t: e  X6 _" m* y7 P6 r/ x( @; {
124.                    printf("信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号\r\n");
     6 R1 m, |9 V. G! B  {
125.                    break;
     
126. 
     8 ?4 x% X! w" e, V7 g& {
127.               /* 超时 */
     
128.               case OS_R_TMO:
     5 Q$ Z% W1 P) t
129.                    bsp_LedToggle(4);
     
130.                    break;
     
131.             
     , V8 q" N: {4 r( o% \, i+ U
132.               /* 其他值不处理 */
     5 A: S" k% }9 ^' o  ^8 E
133.               default:                    
     
134.                    break;
     + ^% f+ H+ Q) O: v
135.          }   
     
136.     }
     9 z) A- n. M3 c$ l- J9 K
137. }
     
138. 
     6 l8 t: |+ O1 X4 X! T- S- w4 O
139. /*
     
140. *********************************************************************************************************
     
141. *    函 数 名: AppTaskStart
     
142. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     , v8 ~. y: J" N. t% |) T9 I; r
143. *    形    参: 无
     7 {- d& X* K; B0 f+ b
144. *    返 回 值: 无
     - }' M* }/ q6 A: |* ?, e- W
145. *   优 先 级: 4
     " E  I4 k2 @+ v9 v/ B7 F) T
146. *********************************************************************************************************
     
147. */
     # v0 @& j: h1 u3 ]
148. __task void AppTaskStart(void)
     6 @$ b# _! i! X
149. {
     
150.      /* 创建任务 */
     
151.      AppTaskCreate();
     * r5 B+ I) L. {8 `* U
152.    
     
153.      /* 创建任务通信机制 */
     
154.      AppObjCreate();
     
155.    
     0 h9 `+ N, [9 r# O
156.     while(1)
     
157.     {
     
158.          /* 按键扫描 */
     7 w; t2 ]3 Y+ {/ f
159.          bsp_KeyScan();
     . v. n0 P4 |- p
160.         os_dly_wait(10);
     " P1 r3 ^: w9 N
161.     }
     7 \# P$ [4 c0 L, e! t
162. }

复制代码

定时器回调函数的实现，在文件RTX_Conf_CM.c：

1. /*--------------------------- os_tmr_call -----------------------------------*/
   
2. #include "bsp.h"
   
3. extern OS_SEM semaphore;
   7 x- C. p# |4 G5 I9 I- I
4. void os_tmr_call (U16 info) {
   
5.   /* This function is called when the user timer has expired. Parameter   */
   ! I% R$ P0 N+ L( l3 J* N
6.   /* 'info' holds the value, defined when the timer was created.          */
   
7. 
   
8.   /* HERE: include optional user code to be executed on timeout. */
   
9.   /* 定时器回调函数中仅支持isr_开头的系统函数，os_开头的不支持，此回调函数是在
   & ~# L4 f* W1 [" e3 ]; O8 w
10.      滴答定时器中断中执行的。
    , o! ?, Q3 N9 n4 ^
11.   */
    8 F0 A- m& [. Y- G+ I( y) c% k
12.   switch(info)
    , Q6 E* u; b8 v; @' x
13.   {
    
14.      case 1:          /* 参数为1 */
    + Z; @- R& K0 F2 z
15.       isr_sem_send (&semaphore);     
    % q/ S) t+ O9 k
16.       break;
    5 Z2 d  h+ u+ t+ T
17.    
    
18.      case 2:          /* 参数为2 */
    3 y5 n/ v1 v8 {: r" m3 Q
19.        bsp_LedToggle(1);   
    
20.       break;
    
21.   }
    8 y7 G, U/ H. j
22. }

复制代码

17.4 总结

    本章节主要为大家讲解了软件定时器，对于初学者来说，比较容易掌握。