第14章    信号量

    本章节开始讲解RTX的另一个重要的任务间的同步和资源共享机制，信号量。

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

14.1 信号量

14.2 信号量API函数

14.3 实验例程说明（任务间通信）

14.4 实验例程说明（中断方式通信）

14.5      总结

14.1  信号量
0 \! D5 a- O& x* t' F14.1.1  信号量的概念及其作用

    信号量（semaphores）是20世纪60年代中期EdgserDijkstra发明的。使用信号量的最初目的是为了给共享资源建立一个标志，该标志表示该共享资源被占用情况。这样，当一个任务在访问共享资源之前，就可以先对这个标志进行查询，从而在了解资源被占用的情况之后，再来决定自己的行为。

    实际的应用中，信号量的作用又该如何体现呢？比如有个30人的电脑机房，我们就可以创建信号量的初始化值是30，表示30个可用资源，不理解的初学者表示信号量还有初始值？是的，信号量说白了就是共享资源的数量。另外我们要求一个同学使用一台电脑，这样每有一个同学使用一台电脑，那么信号量的数值就减一，直到30台电脑都被占用，此时信号量的数值就是0。如果此时还有几个同学没有电脑可以使用，那么这几个同学就得等待，直到有同学离开，有一个同学离开，那么信号量的数值就加1，有两个就加2，依次类推。刚才没有电脑用的同学此时就有电脑可以用了，有几个同学用，信号量就减几，直到再次没有电脑可以用，这么一个过程就是使用信号量来管理共享资源的过程。

    平时使用信号量主要实现以下两个功能：

1.  两个任务或者中断函数跟任务之间的同步功能，这个和上章节讲解的事件标志组是类似的。其实就是共享资源为1的时候。

2.  多个共享资源的管理，就像上面举的机房上机的例子。

    实际上信号量还有很多其它用法，而且极具挑战性，可以大大的开拓大家的视野，有兴趣的同学可以阅读一下《The Little Book Of Semaphores》，作者是Allen B.Downy。

1 m0 [! F, X4 K14.1.2  RTX任务间信号量的实现

    任务间信号量的实现是指各个任务之间使用信号量实现任务的同步或者资源共享功能。

    下面我们通过如下的框图来说明一下RTX信号量的实现，让大家有一个形象的认识。

                              

运行条件：

1.  创建2个任务Task1和Task2。

2.   创建信号量可用资源为1。

运行过程描述如下：

1.  任务Task1运行过程中调用函数os_sem_wait获取信号量资源，如果信号量没有被任务Task2占用，Task1将直接获取资源。如果信号被Task2占用，任务Task1将由运行态转到挂起状态，等待资源可用。一旦获取了资源并使用完毕后会通过函数os_sem_send释放掉资源。

2.  任务Task2运行过程中调用函数os_sem_wait获取信号量资源，如果信号量没有被任务Task2占用，Task1将直接获取资源。如果信号被Task2占用，任务Task1将由运行态转到挂起状态，等待资源可以。一旦获取了资源并使用完毕后会通过函数os_sem_send释放掉资源。

上面就是一个简单RTX任务间信号量的使用过程。

14.1.3  RTX中断方式信号量的实现

    RTX中断方式信号量的实现是指中断函数和RTX任务之间使用信号量。信号量的中断方式主要是用于实现任务同步，与上个章节讲解事件标志组中断方式是一样的。

    下面我们通过如下的框图来说明一下RTX中断方式信号量的实现，让大家有一个形象的认识。

运行条件：

1.  创建1个任务Task1和一个串口接收中断。

2.  信号量的初始值为0，串口中断调用函数isr_sem_send释放信号量，任务Task1调用函数os_sem_wait获取信号量资源。

运行过程描述如下：

1.  任务Task1运行过程中调用函数os_sem_wait，由于信号量的初始值是0，没有信号量资源可用，任务Task1由运行态进入到挂起态。

2.  Task1挂起的情况下，串口接收到数据进入到了串口中断服务程序，在串口中断服务程序中调用函数isr_sem_send释放信号量资源，信号量数值加1，此时信号量计数值为1，任务Task1由挂起态进入到就绪态，在调度器的作用下由就绪态又进入到运行态，任务Task1获得信号量后，信号量数值减1，此时信号量计数值又变成了0。

3.  再次循环执行时，任务Task1调用函数os_sem_wait由于没有资源可用再次进入到挂起态，等待串口释放信号量资源，如此往复循环。

3 {' B7 o3 I" I' a) V4 m

上面就是一个简单RTX中断方式信号量同步过程。实际应用中，中断方式的消息机制切记注意以下四个个问题：

1.  中断函数的执行时间越短越好，防止其它低于这个中断优先级的异常不能得到及时响应。

2.  实际应用中，建议不要在中断中实现消息处理，用户可以在中断服务程序里面发送消息通知任务，在任务中实现消息处理，这样可以有效的保证中断服务程序的实时响应。同时此任务也需要设置为高优先级，以便退出中断函数后任务可以得到及时执行。

3.  中断服务程序中一定要调用专用于中断的信号量设置函数isr_sem_send。

4.  在RTX操作系统中实现中断函数和裸机编程是一样的。

     （1）另外强烈推荐用户将Cortex-M3内核的STM32F103和Cortex-M4内核的STM32F407的NVIC优先级分组设置为4,即：NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);这样中断优先级的管理将非常方便。

     （2）用户要在RTX多任务开启前就设置好优先级分组，一旦设置好切记不可再修改。

3 Q8 Q3 \! [& W2 J1 S

14.2 信号量API函数

使用如下4个函数可以实现RTX的信号量：

os_sem_init

os_sem_send

isr_sem_send

os_sem_wait

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

                              

下面我们对这四个函数依次进行讲解：

2 [8 A  Q4 y4 S6 U: m3 s7 E0 Q) Z14.2.1  函数os_sem_init

函数原型：

1. void os_sem_init (
   ( p- Q4 u7 {/ j) w# e  e7 t
2.     OS_ID semaphore,        /* os_sem类型变量 */
   ; T3 Y' m. e! @5 D. ]! H7 C
3.     U16   token_count );    /* 信号量初始值 */

复制代码

函数描述：

函数os_sem_init用于信号量的初始化并设置初始值

1.  第1个参数填写数据类型为OS_SEM的变量，同时也作为ID标识

2.  第2个参数是信号量初始值，也就是可用资源个数。

使用举例：

1. #include <rtl.h>
   , W5 U0 [3 T( p2 @; @
2. 
   4 F! p2 e4 j2 r% t1 Q5 h. X0 T( F
3. OS_SEM semaphore;
   
4. 
   2 ~# C; ?" b( j# p% w+ E
5. static void AppObjCreate (void)
   
6. {
   - w8 Z9 G; B' L* ~" y- ]1 I+ O
7. /* 创建信号量计数值是0, 用于任务同步 */
     ?/ }6 j5 h- f) i4 o" m
8. os_sem_init (&semaphore, 0);
   
9. }

复制代码

- m4 H% \6 y( x. O

    细心的读者可能发现，上面的初始化函数为什么不是这么写：os_sem_init(semaphore, 0)，而是在变量semaphore前面加一个取地址符&，实际上这两种写法都是可以的，RTX的手册里面默认都是前面加上个取地址符，大家使用的时候也可以都加上，方便区分。

    为什么两种写法都可以呢，因为OS_SEM是这么定义的：typedef U32 OS_SEM[2]，对应上面的函数举例就是 U32 semaphore[2]，定义了一个32位数组，数组里面有两个元素。所以os_sem_init的第一个参数填semaphore或者&semaphore都是这个数组的首地址。

14.2.2 函数os_sem_send

函数原型：

1. OS_RESULT os_sem_send (
   
2.     OS_ID semaphore );    /* OS_SEM类型变量 */

复制代码

函数描述：

函数os_sem_send用于释放信号量，调用后信号量计数值加1。

1.  第1个参数参数填写数据类型为OS_SEM的变量，同时也作为ID标识。

2.  返回值永远是OS_R_OK。

使用这个函数要注意以下问题：

1.     使用此函数前一定要调用函数os_sem_init进行初始化。

使用举例：

1. #include <rtl.h>
   ) D; M7 z0 a* Z' Q2 }: N) `$ P
2. 
   * o- D, S9 H! l5 E- }* |
3. OS_SEM semaphore;
   
4. 
   - {- g% z! \# K/ {$ L
5. __task void task1 (void) {
   + q, M! E3 Q# w6 b: `
6.    ..
   ) y7 g4 b* V2 q- x' g; g
7.   os_sem_init (&semaphore, 0);
   - F' N3 |9 @, p* m
8.   os_sem_send (&semaphore);
   
9.    ..
   
10. }

复制代码

! H/ W: N+ ^0 V8 m+ ?
/ c, Q. `* T5 a' l14.2.3 函数isr_sem_send

函数原型：

1. void isr_sem_send (
   2 D, w4 Y4 z+ _
2.     OS_ID semaphore );    /* OS_SEM类型变量 */

复制代码

函数描述：

函数isr_sem_send用于释放信号量，调用后信号量计数值加1。

1.  第1个参数参数填写数据类型为OS_SEM的变量，同时也作为ID标识。

使用这个函数要注意以下问题：

1.     使用此函数前一定要调用函数os_sem_init进行初始化。

使用举例：

1. #include <rtl.h>
   
2. 
   
3. OS_SEM semaphore;
   . J- p& u# O( \& |- D
4. 
   
5. void EXTI0_IRQHandler (void){
   $ S3 w7 `' ]/ c; A: _
6.    ..
   
7.   isr_sem_send (&semaphore1);
   
8.    ..
   # H! d5 P, L" S; D5 n, X& I
9. }

复制代码

, ?  U: p  g2 U
14.2.4 函数os_sem_wait

函数原型：

1. OS_RESULT os_sem_wait (
   
2.     OS_ID semaphore,    /* OS_SEM类型变量 */
   - P4 q# x7 y' u. E0 t
3.     U16   timeout );    /* 超时时间设置 */

复制代码

函数描述：

函数os_sem_wait用于获取信号量，如果当前的信号量计数值大于0，那么调用函数os_sem_wait后可以成功获取信号量，并将信号量的计数值减1。如果信号量计数值等于0，调用此函数的任务将由运行态转到挂起态，等待信号量资源可用，也就是等待信号量计数值大于0。

1.  第1个参数参数填写数据类型为OS_SEM的变量，同时也作为ID标识。

2.  第2个参数表示设置的等待时间，范围0-0xFFFF，当参数设置为0-0xFFFE时，表示等待这么多个时钟节拍，参数设置为0xFFFF时表示无限等待直到有信号量资源可用。

3.  函数返回OS_R_SEM表示函数设置的超时时间范围内收到信号量可用资源。

      函数返回OS_R_TMO表示超时。

      函数返回OS_R_OK表示无需等待，立即获得可用信号量资源。

使用这个函数要注意以下问题：

1.     使用此函数前一定要调用函数os_sem_init进行初始化。

使用举例：

1. #include <rtl.h>
   
2. 
   9 C" J" w0 x, x+ [- s
3. OS_SEM semaphore;
   
4. 
   
5. __task void AppTaskMsgPro(void)
   - [1 d" f4 f! @4 r& r
6. {
   3 U. D! J% y/ l' n3 O
7.       OS_RESULT xResult;
   7 ]1 W/ v6 N# A- Y; T& M
8.       const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
   7 X: B. Y# c9 M6 J; @8 O
9. 
   0 ]- m0 u/ b  W$ y' n- R
10.       while(1)
    ' q+ O' C# x4 e" z, m; o; K" U0 ]: l1 T
11.       {
    ( J1 a$ e7 j% q$ h% Q7 _
12.             xResult = os_sem_wait (&semaphore, usMaxBlockTime);
    
13. 
    4 v% k4 x; v, _+ @' x# l: u
14.             switch (xResult)
    
15.             {
    % A/ V$ o: {' u( v
16.                   /* 无需等待接受到信号量同步信号 */
    6 {) a% \, d$ Y) k
17.                   case OS_R_OK:
    4 j% Z7 u3 a3 H5 g5 Y( m
18.                        printf("无需等待接受到信号量同步信号\r\n");
    
19.                        break;
    . y# L' U  p- a) k: g% M  A
20. 
    4 D9 a* C! h: |" F8 X2 b
21.                    /* 信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号 */
    / q- z8 C  N! B6 _8 a
22.                    case OS_R_SEM:
    
23.                        printf("信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号\r\n");
    
24.                        break;
    
25. 
    + _: H. G# O" p1 f+ L
26.                    /* 超时 */
    
27.                    case OS_R_TMO:
    
28.                         bsp_LedToggle(1);
    ; l) P5 @5 V2 k
29.                         bsp_LedToggle(4);
    % o+ |3 j1 U5 I% j" \0 X9 g$ w
30.                         break;
    $ e5 {, q& a% Q
31. 
    0 Z$ D8 }: x5 o; R5 W9 ]9 J
32.                    /* 其他值不处理 */
    2 _) B4 s1 O. o& z$ d
33.                     default:                    
    
34.                         break;
    " D, _7 P& b8 ?3 Z' j4 m9 Q
35. 
    ' ^! J/ _0 ~+ u9 x
36.           }        
    
37. }
    ' ^6 z. k) z# E4 k
38. }

复制代码

; |# O0 z8 j5 U: A5 [! z- l

14.3  实验例程说明(任务间通信)
14.3.1 STM32F103开发板实验

配套例子：

    V4-411_RTX实验_信号量

实验目的：

    1. 学习RTX的信号量

实验内容：

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

    2.     K2键按下，直接发送信号量同步信号给任务AppTaskMsgPro。任务AppTaskMsgPro接收到消息后进行消息处理。

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

    AppTaskUserIF任务   ：按键消息处理。

    AppTaskLED任务     ：LED闪烁。

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

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

RTX配置：

    RTX配置向导详情如下：

                              

Task Configuration

    Number of concurrent running tasks

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

                AppTaskUserIF任务   ：按键消息处理。

                AppTaskLED任务     ：LED闪烁。

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

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

    Number of tasks with user-provided stack

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

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. /*
   % b% t; ?0 s( Z
2. *********************************************************************************************************
   ) E) m2 p: T4 u# @& n
3. *    函 数 名: main
   
4. *    功能说明: 标准c程序入口。
   2 l) t9 h: p+ b1 S
5. *    形    参: 无
   
6. *    返 回 值: 无
   / j* l1 }3 d" u6 c, F: E
7. *********************************************************************************************************
   
8. */
   
9. int main (void)
   $ A! M3 |9 |, C( k6 b8 h' O
10. {   
    
11.      /* 初始化外设 */
    
12.      bsp_Init();
    
13.    
    
14.      /* 创建启动任务 */
    " x6 B+ i* K4 ?( s
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    ' w" H' h* F* U1 i6 ]/ @
16.                        4,                        /* 任务优先级 */
    
17.                        &AppTaskStartStk,         /* 任务栈 */
    ; a; ~$ d% A6 P, ?
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    ( p' @; N* u" _- x1 o5 L* R  s& Y
19.      while(1);
    & L5 B! e+ K% n: y4 a; Q
20. }

复制代码

; Q0 @! M/ F, v: E

RTX任务创建：

1. /*
   
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskCreate
   
4. *    功能说明: 创建应用任务
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   4 F, p4 e- l$ c: M
7. *********************************************************************************************************
   8 A' z, j6 M! ?3 P! r3 w# F# E3 Y
8. */
   1 p. H1 d' j' `4 z& b# a
9. static void AppTaskCreate (void)
   2 }/ q2 }* ~% B% g" ~
10. {
    
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    
12.                                            1,                         /* 任务优先级 */
    4 W/ }8 i4 O6 ?- r  f
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    9 P! y7 U- W1 p9 ~+ Z" q
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    
15.    
    & R3 V1 ^# G; ]% u0 V: G+ C4 `
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    
17.                                         2,                       /* 任务优先级 */
    # r" E9 E, E& b4 s# X3 C. t0 D
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    6 X3 n/ N, z4 l! B
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    " o% @+ K& E4 N! O- T( T, F
20.    
    
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    
22.                                            3,                         /* 任务优先级 */
    / T4 s- _% `2 h6 m
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    
25. }

复制代码

创建信号量：

1. static OS_SEM semaphore;
   / e5 C5 h/ p& \* C4 @- U
2. /*
   / n% }# p+ A+ c! v9 a) e1 U
3. *********************************************************************************************************
   
4. *    函 数 名: AppObjCreate
   ) x+ s* Q7 ]5 d" p
5. *    功能说明: 创建任务通信机制
   
6. *    形    参: 无
   8 {( U* E& |/ h% h0 I
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   5 ^: L- k2 n, R6 L. w; e+ v, V* F1 H
9. */
   
10. static void AppObjCreate (void)
    
11. {
    
12.      /* 创建信号量计数值是0, 用于任务同步 */
    % y, j* b$ }5 ^( m; _; I
13.      os_sem_init (semaphore, 0);
    5 J0 B0 }, ~4 A; `
14. }

复制代码

四个RTX任务的实现：

1. /*
   ! j/ Y" g9 ]2 ]+ l
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskUserIF
   
4. *    功能说明: 按键消息处理     
   8 o, e$ F. ?" a: D* L8 _$ j
5. *    形    参: 无
   9 L( g' n: {. Y) H
6. *    返 回 值: 无
   4 H* n. g6 [& v( D) S( l
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   
8. *********************************************************************************************************
   
9. */
   
10. __task void AppTaskUserIF(void)
    
11. {
    * C( ]% ^5 o+ @# {: F8 H
12.      uint8_t ucKeyCode;
    
13. 
    
14.     while(1)
    
15.     {
    % T) H4 \2 i* r8 t
16.          ucKeyCode = bsp_GetKey();
    ( F2 k: s; u, ~4 q- D
17.         
    * R3 E, ?  ^  c3 e- m3 Z: y; H
18.          if (ucKeyCode != KEY_NONE)
    / v. ?  w1 I! W% N! N
19.          {
    9 W2 H% Z" f' Y0 `. O
20.               switch (ucKeyCode)
    
21.               {
    
22.                    /* K1键按下，打印调试说明 */
    
23.                    case KEY_DOWN_K1:
    
24.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    7 U, T. ~8 l3 m5 l1 O  h) l: U
25.                        break;  
    ! ]; P3 N/ `& U5 {6 X
26. 
    
27.                    /* K2键按下，直接发送信号量同步信号给任务AppTaskMsgPro */
    5 P$ C. L  [4 U* J
28.                    case KEY_DOWN_K2:
    0 K) h% n! e. ^0 N% M- h- k
29.                        printf("K2键按下，直接发送信号量同步信号给任务AppTaskMsgPro\r\n");
    
30.                        os_sem_send (&semaphore);
    
31.                        break;
    
32. 
    
33.                    /* 其他的键值不处理 */
    
34.                    default:                    
    % Z# P) E5 M% t5 Z; `( ?6 O
35.                        break;
    % v) c7 j3 D1 U; l1 h& b
36.               }
    5 T* E* N" L7 F4 P
37.          }
    % o& h- E- j4 o$ R
38.         
    
39.          os_dly_wait(20);
    
40.      }
    7 m9 c; y4 F5 v) K( @2 r
41. }
    # @, z$ r# C$ c( i
42. 
    
43. /*
    
44. *********************************************************************************************************
    
45. *    函 数 名: AppTaskLED
    # s8 q3 Y" {7 S: m5 @
46. *    功能说明: LED闪烁。
    . f3 x  }$ t2 v& R6 X7 W% \( Z. b
47. *    形    参: 无
    
48. *    返 回 值: 无
    
49. *   优 先 级: 2
    , G1 I, y0 S0 V: n! `  Y
50. *********************************************************************************************************
    
51. */
    $ Q  |6 u6 Q( D
52. __task void AppTaskLED(void)
    4 J# ]0 J, U) N' o: ^* Q" y
53. {
    
54.      const uint16_t usFrequency = 200; /* 延迟周期 */
    
55.    
    
56.      /* 设置延迟周期 */
    2 s  d. m4 s* X
57.      os_itv_set(usFrequency);
    
58.    
    . c6 v2 z& Y' [
59.     while(1)
    
60.     {
    1 B: t: g" o; K' g0 T2 q
61.          bsp_LedToggle(2);
    6 W4 g" o6 y$ P$ Q3 D% j* s6 v
62.          bsp_LedToggle(3);
    6 A) }7 W  _% @  v# w
63. 
    1 i# x4 g& M1 b9 K! T5 I$ L# p
64.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    ) o* {! r; n7 d/ d2 l' ]2 w
65.          os_itv_wait();
    
66.     }
    
67. }
    
68. 
    7 s$ a3 N# K) I. p  U( J
69. /*
    ( g1 o' r6 C) u3 G
70. *********************************************************************************************************
    
71. *    函 数 名: AppTaskMsgPro
    
72. *    功能说明: 消息处理，等待任务AppTaskUserIF发来的信号量同步信号
    
73. *    形    参: 无
    
74. *    返 回 值: 无
    / x+ ~5 J  |6 ]' a
75. *   优 先 级: 3
    
76. *********************************************************************************************************
    
77. */
    
78. __task void AppTaskMsgPro(void)
    " c8 z8 I: J' m0 [' `( V1 B+ s
79. {
    " P3 `8 V+ _& \5 `0 `2 @% ]0 l
80.      OS_RESULT xResult;
    
81.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
    - L, w$ e0 M( }* Y3 _, e" Y, z( G
82. 
    " d6 @5 z5 Y5 l. p" h' H3 o
83.      while(1)
    3 a; Z% l  N/ K& _. {, M
84.      {
    
85.          xResult = os_sem_wait (&semaphore, usMaxBlockTime);
    
86. 
    
87.          switch (xResult)
    
88.          {
    
89.               /* 无需等待接受到信号量同步信号 */
    # G- v/ i5 R7 @" Y$ G
90.               case OS_R_OK:
    - a& ^5 n* a! |* B5 f& B4 H8 f
91.                    printf("无需等待接受到信号量同步信号\r\n");
    
92.                    break;  
    
93. 
    + u( {, R' O" J. g) [$ r! {8 e" W
94.               /* 信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号 */
    
95.               case OS_R_SEM:
    * @3 \% Q) O, z# y7 g- A+ x" w
96.                    printf("信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号\r\n");
    * w& o4 F' L6 Y, ^" I
97.                    break;
    9 R5 F" l; \. @
98. 
    * i. T' O( }7 E
99.               /* 超时 */
    ; ]/ M' n& ?  i+ b' C
100.               case OS_R_TMO:
     
101.                    bsp_LedToggle(1);
     # Z+ v! `% i0 Y+ e
102.                    bsp_LedToggle(4);
     ( M. V; L6 I8 ?- M' G2 G& s( O
103.                    break;
     + f- H3 [7 K6 a: ^0 }& _. p
104. 
     1 e3 x2 _+ ]: M5 H' _' I6 y  [
105.               /* 其他值不处理 */
     ; N5 s3 f5 Z: H8 e+ J/ ?; C
106.               default:                    
     " d: w. ?/ T, J1 _# C8 T* y! j
107.                    break;
     ! B! R) v7 b% J
108.          }   
     6 {  A: i: ?. f' `! Z# ^* ^& ^8 n
109.      }
     ! b1 j$ e4 x# x8 D7 Y
110. }
     
111. 
     % f" ^( J8 L" O* F- G
112. /*
     2 y& \3 O' h. o2 P8 E; m* q! z
113. *********************************************************************************************************
     & T7 M% I) ^! F2 N% I  n  W) T! _
114. *    函 数 名: AppTaskStart
     3 b& }: f: _6 r, |
115. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     # p2 Z; d, h) u) V# h
116. *    形    参: 无
     6 m' [6 J& \$ ^' ]* A: c
117. *    返 回 值: 无
     , p( A% s. o4 r& B* R7 J
118. *   优 先 级: 4
     
119. *********************************************************************************************************
     & Y# ^1 X; l3 L2 C
120. */
     
121. __task void AppTaskStart(void)
     
122. {
     6 `) F% L; [) G9 C6 a# X: ^
123.      /* 创建任务 */
     $ M. g" O5 K- C+ ~' |- f
124.      AppTaskCreate();
     
125.    
     : Q% ^$ k5 s) x. U+ Q
126.      /* 创建任务通信机制 */
     ! P: Z  Q: u  k4 L  W; |
127.      AppObjCreate();
     9 }) Z1 H7 n. D. S9 g; {, z% Z
128.    
     
129.     while(1)
     
130.     {
     
131.          /* 按键扫描 */
     
132.          bsp_KeyScan();
     
133.         os_dly_wait(10);
     6 v5 z# h) r- M- p( f
134.     }
     
135. }

复制代码

14.3.2   STM32F407开发板实验

配套例子：

    V5-411_RTX实验_信号量

实验目的：

    1. 学习RTX的信号量

实验内容：

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

    2. K2键按下，直接发送信号量同步信号给任务AppTaskMsgPro。

      任务AppTaskMsgPro接收到消息后进行消息处理。

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

    AppTaskUserIF任务   ：按键消息处理。

    AppTaskLED任务     ：LED闪烁。

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

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

RTX配置：

    RTX配置向导详情如下：

                              

Task Configuration

    Number of concurrent running tasks

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

                AppTaskUserIF任务   ：按键消息处理。

                AppTaskLED任务     ：LED闪烁。

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

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

    Number of tasks with user-provided stack

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

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. *********************************************************************************************************
   ( z) E! r3 E8 [6 e5 U' f5 e
3. *    函 数 名: main
   / o* {2 d5 r" Z
4. *    功能说明: 标准c程序入口。
     s' o; b6 a9 s) E% [
5. *    形    参: 无
   ' h# P! t! H/ x; v( X; c$ R
6. *    返 回 值: 无
   4 [! v4 v6 e& w: U1 ]. S
7. *********************************************************************************************************
   " W) ]) z; o+ a- s( b4 B" x
8. */
   
9. int main (void)
   2 b: f& f2 l  M5 _, h
10. {   
    
11.      /* 初始化外设 */
    
12.      bsp_Init();
    & {3 p0 Z3 j. M# f# v9 N
13.    
    
14.      /* 创建启动任务 */
    + A( k0 r" m+ L' w/ o6 _( H
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    % e- l; H; T, p+ N' k
16.                        4,                        /* 任务优先级 */
    * Y5 w. W( b# n" _4 J+ n/ S
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    # n1 c0 S. S. b& ^
19.      while(1);
    # O9 l7 }( v6 L* r7 C9 T5 k% `
20. }

复制代码

) x) f. K3 y; \2 R: A" x

RTX任务创建：

1. /*
   1 e$ H/ v( M* g) z. t8 d& Y
2. *********************************************************************************************************
   ( o5 {6 ~. ^& [5 z: _( I
3. *    函 数 名: AppTaskCreate
   6 J  a6 X3 P5 V6 M! p. Y, b! b& @3 n1 U
4. *    功能说明: 创建应用任务
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   ( t/ d8 \- x. T: R5 ?  y
7. *********************************************************************************************************
   
8. */
   
9. static void AppTaskCreate (void)
   + n( L" }9 h9 l5 o
10. {
    
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    & b- a( V& k, W
12.                                            1,                         /* 任务优先级 */
    1 E  e7 C- ]; W0 B; h
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    
15.    
    
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    
17.                                         2,                       /* 任务优先级 */
    6 M1 X6 t3 S' v$ h8 |0 l% `! e, z
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    0 f5 n4 [. ?! ^, l
20.    
    8 m. y# J" P7 C( y& X
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    - z* W# ?+ o' E: C
22.                                            3,                         /* 任务优先级 */
    
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    
25. }

复制代码

* N7 {" G7 `  `0 ~( U

* n) S! \6 ?& \7 m, `0 x8 r( K

创建信号量：

1. static OS_SEM semaphore;
   
2. /*
     ~" G0 Q' x3 w4 x
3. *********************************************************************************************************
   
4. *    函 数 名: AppObjCreate
   $ ]  X% S: K% y, }% M
5. *    功能说明: 创建任务通信机制
   - H8 P/ b! u9 Z$ g5 x, ]
6. *    形    参: 无
   ) Y: b+ c. d/ k4 L0 Q- m; l
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. static void AppObjCreate (void)
    7 I; }0 E, u, H9 @( P$ q2 X
11. {
    
12.      /* 创建信号量计数值是0, 用于任务同步 */
    
13.      os_sem_init (semaphore, 0);
    
14. }

复制代码

四个RTX任务的实现：

1. /*
   5 Q% B; a$ b) d
2. *********************************************************************************************************
   
3. *    函 数 名: AppTaskUserIF
   
4. *    功能说明: 按键消息处理     
   
5. *    形    参: 无
   , z0 z6 [3 ~- L
6. *    返 回 值: 无
   
7. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   
8. *********************************************************************************************************
   ' b5 D% E+ G  y& I# T! k
9. */
   
10. __task void AppTaskUserIF(void)
    4 q, d. p0 `+ k: }2 i
11. {
    . q  h* B4 _. k7 ?# C# f
12.      uint8_t ucKeyCode;
    9 m8 C- d5 t+ Q
13. 
    
14.     while(1)
    
15.     {
    
16.          ucKeyCode = bsp_GetKey();
    0 R9 T" f( U1 A7 N; @( u
17.         
    ( D+ z$ V3 b/ P, h( w& S
18.          if (ucKeyCode != KEY_NONE)
    , L/ j  }/ w4 ~& B: U+ G
19.          {
    - e- `% L5 q' n, k
20.               switch (ucKeyCode)
    0 I# R* q$ Q- z4 K
21.               {
    0 o( L! g$ P1 |- \1 E2 p3 C3 H
22.                    /* K1键按下，打印调试说明 */
    $ p) x8 [0 m% u5 z
23.                    case KEY_DOWN_K1:
    
24.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    * C  [% ^. D4 }6 }- ?5 S
25.                        break;  
    
26. 
    ; A9 C( U7 F6 `* d4 n
27.                    /* K2键按下，直接发送信号量同步信号给任务AppTaskMsgPro */
    1 B+ T( T8 `* Z6 g
28.                    case KEY_DOWN_K2:
    
29.                        printf("K2键按下，直接发送信号量同步信号给任务AppTaskMsgPro\r\n");
    
30.                        os_sem_send (&semaphore);
    
31.                        break;
    
32. 
    % _( ^* }* G0 W: _7 a
33.                    /* 其他的键值不处理 */
    
34.                    default:                    
    
35.                        break;
    
36.               }
    , A/ C3 @' J5 L! T  C  ?
37.          }
    & p; J2 D2 s& {7 y1 w" L
38.         
    
39.          os_dly_wait(20);
    * _$ j" m, p4 l3 G9 Z
40.      }
    
41. }
    7 v, v, z- t1 @7 [- T$ t
42. 
    1 P2 L; ?) B+ ?/ b2 ~
43. /*
    
44. *********************************************************************************************************
    
45. *    函 数 名: AppTaskLED
    
46. *    功能说明: LED闪烁。
    
47. *    形    参: 无
    
48. *    返 回 值: 无
    6 [; m. A6 r. n: L$ ^3 s, P
49. *   优 先 级: 2
    6 |$ w. b5 A; J2 |) s1 y6 W& n3 O8 w
50. *********************************************************************************************************
    
51. */
    
52. __task void AppTaskLED(void)
    
53. {
    
54.      const uint16_t usFrequency = 200; /* 延迟周期 */
    . ^2 N; e) J% E  m) H
55.    
    2 i( C/ l% Q3 ?" p
56.      /* 设置延迟周期 */
    
57.      os_itv_set(usFrequency);
    
58.    
    
59.     while(1)
    
60.     {
    
61.          bsp_LedToggle(2);
    
62.          bsp_LedToggle(3);
    
63. 
    / k2 N' D3 S5 k+ s6 y
64.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    ) j1 z( _! A. Q* {
65.           os_itv_wait();
    . {5 l* z* ~. M9 r/ R" ^
66.     }
    
67. }
    
68. 
    2 z! M9 E6 A. R. y  l
69. /*
    4 k/ r3 A, Q5 ?6 u
70. *********************************************************************************************************
    
71. *    函 数 名: AppTaskMsgPro
    0 Y" ^: L- L$ ~5 K& U0 q; [
72. *    功能说明: 消息处理，等待任务AppTaskUserIF发来的信号量同步信号
    - z$ c' |! w; {& ^/ ^
73. *    形    参: 无
    7 P6 ?4 j% K5 |6 b1 W8 J
74. *    返 回 值: 无
    
75. *   优 先 级: 3
    3 m* ~; s1 X$ w9 R- _
76. *********************************************************************************************************
    
77. */
    ; |7 ~1 b2 C0 ?* }& M
78. __task void AppTaskMsgPro(void)
    $ H' K. b3 i2 a( `# N
79. {
    
80.      OS_RESULT xResult;
    
81.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
    7 b% h2 u: i! M  U
82. 
    - Q& n9 O0 ^* W7 ~  H5 ~# z. S  E
83.      while(1)
    
84.      {
    
85.          xResult = os_sem_wait (&semaphore, usMaxBlockTime);
    ; D8 o, y7 ?- Z
86. 
    
87.          switch (xResult)
    
88.          {
    ' P/ X1 I% U1 e  I' L1 @8 V
89.               /* 无需等待接受到信号量同步信号 */
    
90.               case OS_R_OK:
    $ q( [/ i" Z. f. {) @1 P# y
91.                    printf("无需等待接受到信号量同步信号\r\n");
    
92.                    break;  
    
93. 
    ' D! h& ?" y' H$ e3 z6 J+ r
94.               /* 信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号 */
    2 X" L6 o3 g. O: A' D: }
95.               case OS_R_SEM:
    0 d! s# o0 T/ ?$ y  o  @
96.                    printf("信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号\r\n");
    
97.                    break;
    
98. 
    4 V9 z. [; Q1 l8 x: l) D
99.               /* 超时 */
    ; c, o0 z! q/ K; J% Z) X/ d% R& z3 G
100.               case OS_R_TMO:
     * ]) }% h5 f# K# H' V/ Q
101.                    bsp_LedToggle(1);
     
102.                    bsp_LedToggle(4);
     
103.                    break;
     
104. 
     
105.               /* 其他值不处理 */
     7 K2 f9 T$ R( |, {% p6 O0 F
106.               default:                    
     
107.                    break;
     & u; q% I8 J7 R4 `# T
108.          }   
     5 ?- J& |3 P6 d; }7 j$ \0 \7 ?
109.      }
     3 ]5 l9 A3 v% b
110. }
     9 B) _5 M' S8 p. Q
111. 
     
112. /*
     6 l8 P$ I" W& F7 w
113. *********************************************************************************************************
     
114. *    函 数 名: AppTaskStart
     
115. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     & d+ `( w; @$ x% F
116. *    形    参: 无
     
117. *    返 回 值: 无
     " t# c; x4 L; Y
118. *   优 先 级: 4
     
119. *********************************************************************************************************
     
120. */
     * }4 w9 m& S9 {5 k  d$ z
121. __task void AppTaskStart(void)
     ! A9 T, E! _) F
122. {
     
123.      /* 创建任务 */
     7 u2 [0 j( T: J+ B9 g4 r3 g
124.      AppTaskCreate();
     
125.    
       D- C2 z( r& B3 j
126.      /* 创建任务通信机制 */
     : `+ T4 V5 v8 a
127.      AppObjCreate();
     : L" F. \: J8 n
128.    
     
129.     while(1)
     8 F% a: R1 X7 h+ n' A& m
130.     {
     
131.          /* 按键扫描 */
     
132.          bsp_KeyScan();
     ( z- U' N8 v8 N; \  f4 X
133.         os_dly_wait(10);
     
134.     }
     % k' T2 L. \# o( W. a- r# _
135. }

复制代码

# g* H2 ?3 R. x- o/ X

14.4 实验例程说明（中断方式通信）
) B0 K, p/ P* u' _8 S% K& S9 y0 N
9 ~+ L: A, d0 E3 n& {9 Z* A& h14.4.1 STM32F103开发板实验

配套例子：

    V4-412_RTX实验_信号量（中断方式）

实验目的：

    1. 学习RTX的信号量（中断方式）

实验内容：

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

    2. K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送信号量同步信号。任务AppTaskMsgPro接收到消息后进行消息处理。

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

    AppTaskUserIF任务   ：按键消息处理。

    AppTaskLED任务     ：LED闪烁。

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

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

RTX配置：

    RTX配置向导详情如下：

                              

Task Configuration

    Number of concurrent running tasks

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

                AppTaskUserIF任务   ：按键消息处理。

                AppTaskLED任务     ：LED闪烁。

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

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

    Number of tasks with user-provided stack

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

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
   / O8 g, z' b7 \- ~  i& E
4. *    功能说明: 标准c程序入口。
   , K3 R  Z5 t, ~! ]- v1 K
5. *    形    参: 无
   , B, V# ^4 p' V$ K5 _
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ) j9 W5 s! o! J0 N% Z; Y+ k5 _8 l
9. int main (void)
   * f0 a8 b5 d1 Z; h7 n+ q
10. {   
    ) ?  [" T: @. O1 s- d! f
11.      /* 初始化外设 */
      Y6 l$ V5 _  i2 ]: H" O
12.      bsp_Init();
    
13.    
    
14.      /* 创建启动任务 */
    : q$ E; p! p! [, D# c; U& K# O; V
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    
16.                        4,                        /* 任务优先级 */
    2 N9 O+ T+ N. s7 e/ g" R
17.                        &AppTaskStartStk,         /* 任务栈 */
    + W- s8 t, y4 L- U
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    
19.      while(1);
    ' M# V( D6 q3 C0 X
20. }

复制代码

RTX任务创建：

1. /*
   3 q+ r! w2 x9 y- Z4 i3 f/ s
2. *********************************************************************************************************
   # D+ y) a$ c/ f, T* v7 S; l- k
3. *    函 数 名: AppTaskCreate
   . X1 t# s$ K6 [# z* z- C3 `6 M9 o
4. *    功能说明: 创建应用任务
   
5. *    形    参: 无
   # C; _1 D" ]5 H8 I8 g! ^
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   , g. f2 V9 f# I; j
8. */
   ; A; }/ R5 M- E- E: a
9. static void AppTaskCreate (void)
   
10. {
    
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    
12.                                            1,                         /* 任务优先级 */
    9 O* E8 K/ O" N
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    7 [" ?1 H1 O" R9 H+ H' x
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    
15.    
    8 p+ b, H+ b, e% r& ]: v; d
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    ' F& ]/ d- u1 z, S( |2 [7 x
17.                                         2,                       /* 任务优先级 */
      |' j! _9 V8 j
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    8 z+ `$ {) W  ^7 ~8 ~( J/ o
20.    
    
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    & r/ |5 d( V2 D" C5 S8 _
22.                                            3,                         /* 任务优先级 */
    3 I$ _$ X! _. b9 v. h0 |# r/ ~
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    ' _. ?  ^" e4 Z* `
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    2 ?- a$ ]( m& X% I0 Y- B
25. }

复制代码

7 G) M$ y) m( z* R$ u9 e4 `

创建信号量：

1. static OS_SEM semaphore;
   * T, |' G8 }" D; P5 `: L
2. /*
   
3. *********************************************************************************************************
   8 V. N8 \% k1 R; E+ D, G
4. *    函 数 名: AppObjCreate
   
5. *    功能说明: 创建任务通信机制
     e7 s! l7 U' e% J, u# F/ V
6. *    形    参: 无
   * i( n8 \& P  v( [0 a# ?# Q2 Y  w4 n
7. *    返 回 值: 无
   # H) C6 D' S7 J% O
8. *********************************************************************************************************
   
9. */
   
10. static void AppObjCreate (void)
    
11. {
    + E5 t# G7 W9 j1 F
12.      /* 创建信号量计数值是0, 用于任务同步 */
    
13.      os_sem_init (semaphore, 0);
    . o3 g0 F- K% m6 R
14. }

复制代码

* p/ Y& }2 v: y. R! K6 Y# J

四个RTX任务的实现：

1. /*
   5 F" z: m$ z( x) V. v2 F. E$ s
2. /*
     S, R0 G+ c0 m7 o+ a
3. *********************************************************************************************************
   
4. *    函 数 名: AppTaskUserIF
   $ F! i1 c; f" g& ?  {! H
5. *    功能说明: 按键消息处理     
   5 }1 R$ _0 X8 D( }3 j3 f
6. *    形    参: 无
   7 Z8 W' V  Q- I; R
7. *    返 回 值: 无
   3 d' |* E7 t0 S; P
8. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   
9. *********************************************************************************************************
   " i) Z$ W( b2 L6 t$ ^; O7 d) g$ `
10. */
      G* L( O2 e6 U$ o7 \+ |7 P) M
11. __task void AppTaskUserIF(void)
    ( L& }" v* |& f9 o; r
12. {
    3 G  Z( @3 B% E6 f3 @- `) V
13.      uint8_t ucKeyCode;
    
14. 
    
15.     while(1)
    
16.     {
    
17.          ucKeyCode = bsp_GetKey();
    
18.         
    
19.          if (ucKeyCode != KEY_NONE)
    
20.          {
    
21.               switch (ucKeyCode)
    - h' \! ^  y8 R1 _
22.               {
    
23.                   /* K1键按下，打印调试说明 */
    
24.                    case KEY_DOWN_K1:
    
25.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    
26.                        break;  
    
27.                   
    
28.                  /* K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送信号量同步信号 */
    7 H% J5 T- U6 C
29.                    case KEY_DOWN_K2:
    / t0 |0 j* K0 E0 a  e
30.                        printf("K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送信
    4 q0 ^- _" v3 ]+ A. v+ c
31. 号量同步信号\r\n");
    6 K: N7 w; n. }! r) p, H7 Y
32.                        bsp_StartHardTimer(1 ,50000, (void *)TIM_CallBack1);
    
33.                        break;
    - q* W$ \$ R# y- N, @
34. 
    0 m8 D; f4 b2 E# v6 l2 a8 p
35.                    /* 其他的键值不处理 */
    
36.                    default:                    
    0 z) e8 W. U+ c3 n/ E2 F
37.                        break;
    
38.               }
    
39.          }
    ( ~4 X6 @1 O7 p# B+ s" n2 E
40.         
    
41.          os_dly_wait(20);
      T2 u6 D. @: G) e, f+ q
42.      }
    , u% ?% M* z% n; p7 P7 y
43. }
    5 h# ~, b9 H+ `
44. 
    
45. /*
    ! {" n, T4 I! s/ f2 m
46. *********************************************************************************************************
    
47. *    函 数 名: AppTaskLED
    8 j* v! x$ y4 P. |8 D
48. *    功能说明: LED闪烁。
    
49. *    形    参: 无
    + T/ f" f5 Y1 N) j  |% t0 X
50. *    返 回 值: 无
    
51. *   优 先 级: 2
    
52. *********************************************************************************************************
    
53. */
    
54. __task void AppTaskLED(void)
    
55. {
    
56.      const uint16_t usFrequency = 200; /* 延迟周期 */
    ; K& h' m3 l' V- E* r
57.    
      {3 _7 c& J$ Q2 N3 _
58.      /* 设置延迟周期 */
    ! P! l% B" P/ J* b) v
59.      os_itv_set(usFrequency);
    
60.    
    % W- T+ p: e8 \
61.     while(1)
    
62.     {
    4 Q# y# D( d2 c
63.          bsp_LedToggle(2);
    7 Y0 G5 a5 f4 I9 a& `6 g" g2 x- C
64.          bsp_LedToggle(3);
    - Q1 X2 L4 s& w  y% Z0 D. W
65. 
    1 G0 G( M& ]" X9 w
66.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    # u' H& ~$ T# J" S, z4 S: Y
67.           os_itv_wait();
    
68.     }
    
69. }
    $ z& t/ `' D' b7 [0 \
70. 
    
71. /*
    0 d% I  d3 H0 k# T- ~; l! O
72. *********************************************************************************************************
      q$ L8 Z9 c' @5 S$ t
73. *    函 数 名: AppTaskMsgPro
    # `. S+ L' y" M
74. *    功能说明: 消息处理，等待定时器中断发来的信号量同步信号
    
75. *    形    参: 无
    
76. *    返 回 值: 无
    
77. *   优 先 级: 3
    ' x# C' O9 @4 q
78. *********************************************************************************************************
    
79. */
    
80. __task void AppTaskMsgPro(void)
    
81. {
    
82.      OS_RESULT xResult;
    4 x; ^: u$ ~5 @& Z
83.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
    # @: x' I% d) Z3 ^
84.    
    
85.     while(1)
    * }! p9 }. t( e9 j0 e0 B
86.     {
    ' Y: s5 d2 a$ W9 \: \; l$ ], L- B
87.          xResult = os_sem_wait (&semaphore, usMaxBlockTime);
    
88.         
    
89.          switch (xResult)
    4 G' }- q9 ]0 [# I
90.          {
      u) e1 d/ X6 w
91.               /* 无需等待接受到信号量同步信号 */
    - Z2 V% x; `/ K% d& Z8 o/ S$ Y1 n
92.               case OS_R_OK:
    + b, j( V, Y7 J! Z2 w- y5 r+ o, Q( P
93.                    printf("无需等待接受到信号量同步信号\r\n");
    - S- J- q/ R2 F  T
94.                    break;  
    0 F$ J. `; E3 r2 U& W1 _9 V6 |5 Q# O  G
95. 
    ) j4 M6 E# M  K8 h; [
96.               /* 信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号 */
    5 w2 q  ~3 N$ V) H
97.               case OS_R_SEM:
    
98.                    printf("信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号\r\n");
    % q: @/ C6 }2 k2 t
99.                    break;
    
100. 
     
101.               /* 超时 */
     ) X+ V6 ^" V7 Q% H( L0 p1 q
102.               case OS_R_TMO:
     
103.                    bsp_LedToggle(1);
     
104.                    bsp_LedToggle(4);
     
105.                    break;
     
106.             
     " F3 _( [7 d! R2 V1 m9 }! P6 J
107.               /* 其他值不处理 */
     / u; |$ ~$ ^* U% B
108.               default:                    
     
109.                    break;
     
110.          }   
     
111.     }
     * ?, ^  X% ~8 _2 V" T9 g$ O! J( I2 \
112. }
     
113. 
     5 [7 m8 c' u- w# a  r; d  D5 o3 {
114. /*
     
115. *********************************************************************************************************
     & M. C  Z' D- q
116. *    函 数 名: AppTaskStart
     
117. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     
118. *    形    参: 无
     
119. *    返 回 值: 无
     6 `1 G7 f' D6 u/ ^* m) D
120. *   优 先 级: 4
     
121. *********************************************************************************************************
     
122. */
     " p0 h* ~5 M5 s* z
123. __task void AppTaskStart(void)
     1 k0 d# y1 f) ?; k" L  ]
124. {
     
125.      /* 创建任务 */
     * N: y' H0 E& w/ R
126.      AppTaskCreate();
     
127.    
     
128.      /* 创建任务通信机制 */
     7 Z4 o: ?) i* h1 B4 o& b
129.      AppObjCreate();
     0 e" c. i1 F- P( Y! N# o9 N. K0 t
130.    
     
131.     while(1)
     
132.     {
     
133.          /* 按键扫描 */
     
134.          bsp_KeyScan();
     
135.         os_dly_wait(10);
     : H8 |- a. ~# m
136.     }
     
137. }

复制代码

定时器中断回调函数中发送信号量同步信号：

    定时器中断的初始化和中断函数在bsp_timer.c文件中实现，这个不是教程的重点，故不作介绍。这里主要关心RTX的信号量函数在中断服务程序中的使用方法。

1. /*
   
2. /*
   
3. *********************************************************************************************************
   
4. *    函 数 名: TIM_CallBack1
   
5. *    功能说明: 定时器中断的回调函数，此函数被bsp_StartHardTimer所调用。                        
   
6. *    形    参: 无
   * Z1 @- J; B1 o* L8 |0 m) h4 F: M! y! p
7. *    返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   + h6 j8 Y3 j" s5 t
10. static void TIM_CallBack1(void)
    
11. {
    7 @' R' h3 b; R% t* Y& [
12.      /* 发送信号量同步信号 */
    
13.      isr_sem_send (&semaphore);
    
14. }

复制代码

( p/ r5 M) v+ P- |3 L# J

14.4.2   STM32F407开发板实验

配套例子：

    V5-412_RTX实验_信号量（中断方式）

实验目的：

    1. 学习RTX的信号量（中断方式）

实验内容：

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

    2. K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送信号量同步信号。任务AppTaskMsgPro接收到消息后进行消息处理。

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

    AppTaskUserIF任务   ：按键消息处理。

    AppTaskLED任务     ：LED闪烁。

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

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

RTX配置：

    RTX配置向导详情如下：

                              

Task Configuration

    Number of concurrent running tasks

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

                AppTaskUserIF任务   ：按键消息处理。

                AppTaskLED任务     ：LED闪烁。

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

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

    Number of tasks with user-provided stack

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

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. *********************************************************************************************************
   2 M' X/ ~# j, J3 u
3. *    函 数 名: main
   : s" k, `; c: z  J( W
4. *    功能说明: 标准c程序入口。
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   ; p3 {: J  q- [1 R
7. *********************************************************************************************************
   " D" s" G2 z. z: M& i
8. */
   , |7 g9 z) K  a% T6 [7 `2 \6 I
9. int main (void)
   
10. {   
    2 f6 P+ v# ~. j$ {4 I0 G
11.      /* 初始化外设 */
    & x5 _  x' k0 e4 J
12.      bsp_Init();
    
13.    
    8 N" j$ q$ ^1 R% t; X& |/ Y0 T0 N, D
14.      /* 创建启动任务 */
    
15.      os_sys_init_user (AppTaskStart,             /* 任务函数 */
    2 O% u1 y1 s; S8 d: p3 T1 K
16.                        4,                        /* 任务优先级 */
    , b: m0 ~0 }3 Z5 N$ L/ t( X/ f+ z% m
17.                        &AppTaskStartStk,         /* 任务栈 */
    
18.                        sizeof(AppTaskStartStk)); /* 任务栈大小，单位字节数 */
    
19.      while(1);
    
20. }

复制代码

RTX任务创建：

1. /*
   . W0 L& _! ^2 K" g
2. *********************************************************************************************************
   - m" Q7 I2 {7 f" n3 o$ w% k
3. *    函 数 名: AppTaskCreate
   0 K8 l3 V1 V4 T. |" H
4. *    功能说明: 创建应用任务
   
5. *    形    参: 无
   
6. *    返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void AppTaskCreate (void)
   
10. {
      {' f2 q# t2 K3 U% q; i
11.      HandleTaskUserIF = os_tsk_create_user(AppTaskUserIF,             /* 任务函数 */
    
12.                                            1,                         /* 任务优先级 */
    4 g1 E0 b8 _& B3 e
13.                                            &AppTaskUserIFStk,         /* 任务栈 */
    & E* u( i( r  v/ _* F
14.                                            sizeof(AppTaskUserIFStk)); /* 任务栈大小，单位字节数 */
    % v, N1 a8 _" ]2 o  u( ~
15.    
    6 p& l. L6 ^# W2 K7 G# A
16.      HandleTaskLED = os_tsk_create_user(AppTaskLED,              /* 任务函数 */
    " d6 {# W1 c) l" H- Z
17.                                         2,                       /* 任务优先级 */
    
18.                                         &AppTaskLEDStk,          /* 任务栈 */
    
19.                                         sizeof(AppTaskLEDStk));  /* 任务栈大小，单位字节数 */
    
20.    
    . ^5 E& i3 _+ A# d! M" {
21.      HandleTaskMsgPro = os_tsk_create_user(AppTaskMsgPro,             /* 任务函数 */
    - J, ]) V, u+ I( Y- Z( `, z
22.                                            3,                         /* 任务优先级 */
    . ?  @4 m4 R; \( r) D$ M7 i$ c
23.                                            &AppTaskMsgProStk,         /* 任务栈 */
    
24.                                            sizeof(AppTaskMsgProStk)); /* 任务栈大小，单位字节数 */
    
25. }

复制代码

" ~5 g4 ~6 ]6 k( U( N2 w/ L

创建信号量：

1. static OS_SEM semaphore;
   
2. /*
   
3. *********************************************************************************************************
   
4. *    函 数 名: AppObjCreate
   
5. *    功能说明: 创建任务通信机制
   / ^; B0 ?$ W  O  g
6. *    形    参: 无
     S1 ^" v8 I# W* b. O% N+ R! B" Q
7. *    返 回 值: 无
   ' N$ p1 D9 E6 W4 a) l8 R
8. *********************************************************************************************************
   
9. */
   5 q, k& i0 A7 p+ R& U
10. static void AppObjCreate (void)
    3 C' y$ s: I. s# r6 O5 ~
11. {
    
12.      /* 创建信号量计数值是0, 用于任务同步 */
    . n% Y( A- b+ o: Y5 q1 z
13.      os_sem_init (semaphore, 0);
    
14. }

复制代码

1 Y8 r3 V1 O  _6 g4 m, t

四个RTX任务的实现：

1. /*
   
2. /*
   
3. *********************************************************************************************************
   
4. *    函 数 名: AppTaskUserIF
   
5. *    功能说明: 按键消息处理     
   - w+ S# `  m* ~8 e8 Y7 ]9 Y. B
6. *    形    参: 无
   
7. *    返 回 值: 无
   
8. *   优 先 级: 1  (数值越小优先级越低，这个跟uCOS相反)
   
9. *********************************************************************************************************
   
10. */
    & W- o0 H& i& x6 ?8 L
11. __task void AppTaskUserIF(void)
    
12. {
    
13.      uint8_t ucKeyCode;
    
14. 
    
15.     while(1)
    
16.     {
    
17.          ucKeyCode = bsp_GetKey();
    
18.         
    . n5 L. l( B5 F; ^
19.          if (ucKeyCode != KEY_NONE)
    
20.          {
    
21.               switch (ucKeyCode)
    ! _# J9 I, m) h* N2 [; w
22.               {
    
23.                   /* K1键按下，打印调试说明 */
    . O' Y8 o0 Q- p1 C, s6 ^
24.                    case KEY_DOWN_K1:
    
25.                        printf("K1键按下，使用MDK中自带的RTX调试组件，请务必使用MDK4.74版本进行调试\r\n");
    * w8 y0 O* t8 P" F) j
26.                        break;  
    
27.                   
    
28.                  /* K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送信号量同步信号 */
    
29.                    case KEY_DOWN_K2:
    
30.                        printf("K2键按下，启动单次定时器中断，50ms后在定时器中断给任务AppTaskMsgPro发送信
    ; k" n- X( Z$ C3 [5 Y% d' O8 O' ?3 r
31. 号量同步信号\r\n");
    
32.                        bsp_StartHardTimer(1 ,50000, (void *)TIM_CallBack1);
    
33.                        break;
    
34. 
    
35.                    /* 其他的键值不处理 */
    " |1 b# V* m( |( ~4 v1 n
36.                    default:                    
    
37.                        break;
    
38.               }
    5 k$ l) U1 h! L# ^0 j/ i! a# z% S" o
39.          }
    
40.         
    ) k+ n$ K. g" q0 O  Y; w/ d- R
41.          os_dly_wait(20);
    
42.      }
    $ e; l6 c% f0 f8 ]
43. }
    " n! r8 U, o% F# b% J7 h
44. 
    
45. /*
    ) @% w8 D5 S/ H
46. *********************************************************************************************************
    ' `+ a. s/ a0 m8 [
47. *    函 数 名: AppTaskLED
    ) {$ `/ N# }. E6 X& B, \/ [/ k
48. *    功能说明: LED闪烁。
    
49. *    形    参: 无
    8 \: o( t" d6 j( R: a6 _4 T
50. *    返 回 值: 无
    
51. *   优 先 级: 2
    
52. *********************************************************************************************************
    . O% Y/ Z2 Q' ^! f. ]8 X* \+ r/ x
53. */
    * c9 e5 K1 Z( d# s
54. __task void AppTaskLED(void)
    
55. {
    
56.      const uint16_t usFrequency = 200; /* 延迟周期 */
    ) @! H) F1 X8 V7 T9 [- f& I( K
57.    
    
58.      /* 设置延迟周期 */
    / J, w' t% K, c4 x# p
59.      os_itv_set(usFrequency);
    
60.    
    4 m" S( J* w4 \* _' e* z8 i
61.     while(1)
    
62.     {
    ' y3 R3 U( @; O6 q+ b* N) w
63.          bsp_LedToggle(2);
    9 y" |9 G0 o! L5 l: ^
64.          bsp_LedToggle(3);
    6 x3 m2 n( T% C: c. X+ ]# E3 r4 K
65. 
    
66.          /* os_itv_wait是绝对延迟，os_dly_wait是相对延迟。*/
    & Z5 i$ |8 k) |: b5 l$ c8 o/ G
67.           os_itv_wait();
    8 F6 c% x" B) n
68.     }
    
69. }
    
70. 
    
71. /*
    
72. *********************************************************************************************************
    8 S6 b  q# V: C2 W. k  h1 ^
73. *    函 数 名: AppTaskMsgPro
    
74. *    功能说明: 消息处理，等待定时器中断发来的信号量同步信号
    
75. *    形    参: 无
      k+ S2 y8 \2 R( U
76. *    返 回 值: 无
    ( Q* {9 J( Q6 w( [5 R
77. *   优 先 级: 3
    6 I, I; g/ W) r5 h! q; l- }
78. *********************************************************************************************************
    
79. */
    
80. __task void AppTaskMsgPro(void)
    ! Y/ f" F/ W0 i  [; H6 N, k( H
81. {
    ! z7 T0 S2 n* {0 R1 A
82.      OS_RESULT xResult;
    / {7 a& u/ H- Y( V6 E$ V) ?
83.      const uint16_t usMaxBlockTime = 200; /* 延迟周期 */
    ! V/ j$ u8 y8 q" |' s
84.    
    
85.     while(1)
    6 p/ R4 P5 e; D* L3 C
86.     {
      u, U( i2 T) f/ q( |
87.          xResult = os_sem_wait (&semaphore, usMaxBlockTime);
    1 t0 c5 o+ X/ O0 N; G/ ^$ k: z, k- Z
88.         
    & d# r% L( i! A2 W
89.          switch (xResult)
    
90.          {
    ; ]% j" I! x& j4 o# |* h
91.               /* 无需等待接受到信号量同步信号 */
    
92.               case OS_R_OK:
    
93.                    printf("无需等待接受到信号量同步信号\r\n");
    " \2 u. h6 n# g2 ]
94.                    break;  
    
95. 
    
96.               /* 信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号 */
    
97.               case OS_R_SEM:
    6 e2 Z9 o# m) M8 H- _1 @& b6 ~
98.                    printf("信号量不可用，usMaxBlockTime等待时间内收到信号量同步信号\r\n");
    
99.                    break;
    
100. 
     
101.               /* 超时 */
     0 v" r- W( h( c) p, G% P1 }3 S
102.               case OS_R_TMO:
     * U" a! i* P( s
103.                    bsp_LedToggle(1);
     
104.                    bsp_LedToggle(4);
     * h) Q" o; O8 |5 n- P2 l6 }+ w
105.                    break;
     4 U6 l2 N' T7 M" k1 ?1 j# s* V" E
106.             
     
107.               /* 其他值不处理 */
     
108.               default:                    
     
109.                    break;
     
110.          }   
     
111.     }
     2 p2 `/ D1 k5 i( z  W% V" H
112. }
     - P. m! Q! @$ Q/ M
113. 
       P7 L/ Y5 x! {& H
114. /*
     
115. *********************************************************************************************************
     ; H0 b' G  D4 h7 H$ T& q3 ~
116. *    函 数 名: AppTaskStart
     2 `2 \# l- t7 p) I2 I* A
117. *    功能说明: 启动任务，也就是最高优先级任务。这里实现按键扫描。
     . ^) h& U* ?+ [1 t
118. *    形    参: 无
     
119. *    返 回 值: 无
     
120. *   优 先 级: 4
     ' ~2 B3 b3 u! E
121. *********************************************************************************************************
     ( y) N, f+ R! b; i0 |/ v% I- @6 Y
122. */
     . w/ s* O" T" q/ {; @' X7 Q7 n1 ^
123. __task void AppTaskStart(void)
     
124. {
     $ G" @9 X  K& B! T2 d7 ^; k' R; J* X) ]
125.      /* 创建任务 */
     
126.      AppTaskCreate();
     ' ^5 D& i5 J4 v
127.    
     ' v4 r% e" V9 y3 l( v. b
128.      /* 创建任务通信机制 */
     
129.      AppObjCreate();
     
130.    
     
131.     while(1)
     
132.     {
     
133.          /* 按键扫描 */
     
134.          bsp_KeyScan();
     7 ^0 _, P2 W9 y5 ]" p: ?/ d) X5 L, c
135.         os_dly_wait(10);
     5 R2 l  j  F: b) {" l' Q2 }. A
136.     }
     
137. }

复制代码

  m9 d4 l4 t8 m8 E4 Q+ ^9 K  `

定时器中断回调函数中发送信号量同步信号：

    定时器中断的初始化和中断函数在bsp_timer.c文件中实现，这个不是教程的重点，故不作介绍。这里主要关心RTX的信号量函数在中断服务程序中的使用方法。

1. /*
   
2. /*
   + |% ^: @% J4 A; n. m
3. *********************************************************************************************************
   
4. *    函 数 名: TIM_CallBack1
   ( h8 `/ v& J3 N
5. *    功能说明: 定时器中断的回调函数，此函数被bsp_StartHardTimer所调用。                        
   ; L. [1 h. }( X3 L, f8 x
6. *    形    参: 无
   
7. *    返 回 值: 无
   8 i7 i. Y; e- O  P$ _( l. W. k
8. *********************************************************************************************************
   , _( d, C3 c1 O+ Y
9. */
   $ s3 B. O- p9 ]; `+ H
10. static void TIM_CallBack1(void)
    ) N* N& k& ^+ s/ B& C, b
11. {
    # u' }' D! c% e# _9 [. E+ J" j' W) ]
12.      /* 发送信号量同步信号 */
    : Y  s: F; l& b) ?2 b: b8 `
13.      isr_sem_send (&semaphore);
    ; B, e  v3 E1 v4 ?: ^& }( K& J
14. }

复制代码

$ V. C3 O& X0 N+ ]  r

14.5 总结

     本章节主要为大家讲解了另一个重要的任务间的同步和资源共享机制信号量，建议初学者务必将其掌握，因为实际项目中用到信号量的地方很多。

$ o" p6 J# {7 Z% _4 N- p