二值信号量的用法示例
1.创建好带有printf-stdarg.c的FreeRTOS的工程
+ y5 f' Y- J; C, M. A% R5 R
2.修改main.c文件
8 L, ~4 w' w3 r
0 k7 D1 Z! m$ {; L# ]

1. /* USER CODE BEGIN Includes */
   % d" T+ J  s4 @$ b
2. 
   
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   
5. #include "queue.h"
     C2 b* j- l5 \7 Q$ R9 n$ j; K
6. #include "semphr.h"
   
7. #include <stdio.h>
   0 G* ^$ w4 I& m, \1 n5 R
8. #include <string.h>
   
9. 
   
10. /* USER CODE END Includes */
    " B7 _4 t7 o, U# O
11. /* USER CODE BEGIN PV */
    8 i& ]) }" \" B) p5 L! C9 y
12. 
    
13. static TaskHandle_t AppTaskCreate_Handle = NULL;
    
14. static TaskHandle_t KeyTask_Handle = NULL;
    - n" H' Z  s. D# N6 |
15. static TaskHandle_t Led1Task_Handle = NULL;
    
16. 
    : b3 J9 O) i1 R4 [! X
17. /*Create a binary semaphore handle*/
    
18. static SemaphoreHandle_t Binary_Handle = NULL;
    
19. 
    0 M0 g8 f( h# I
20. extern int f_printf(const char *format, ...);
    + O4 z* A! H# Y7 F( K! [7 j
21. 
    4 w2 w$ F# g; h* S+ k8 Y
22. /* USER CODE END PV */
    5 A( k4 z% A9 U3 ?/ a2 W
23. /* USER CODE BEGIN PFP */
    1 s+ S5 U; [7 ~
24. 
    ' P4 ?+ q# m+ ~7 k
25. /*Create a task function*/
    1 P9 n1 [4 h7 p3 T3 S
26. static void AppTaskCreate(void);
    
27. static void KeyTaskCreate(void);
    , N$ u5 w9 T2 L5 H+ q7 y+ t" W
28. static void Led1TaskCreate(void);
    
29. 
    2 ~/ G4 a4 w& R8 C2 Q: I
30. /* USER CODE END PFP */
    # @+ ?. Y; Z3 S! q$ S: u0 B
31. 
    5 w) K# o' f1 }5 q
32. int main()
    5 X$ p" n$ @! e( {
33. {
    " d; ]4 E/ @, _% Q
34.   /*
    $ A2 y7 Z; J$ [) D7 Q/ c9 a
35.   *
    + Y! @+ J* x; K5 c! C  G
36.   */
    $ g7 u# u) Z5 M# b' J1 W
37.   /* USER CODE BEGIN WHILE */
    ( |# b8 z, w! F' \) K
38.   UBaseType_t xReturn = pdPASS;
    
39.         
    
40.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
41.                               (const char *) "APPTASKCREATE",
    
42.                                                   (uint16_t)     128,
    
43.                                                   (void *)       NULL,
    
44.                                                   (UBaseType_t)  2,
    
45.                                                   (TaskHandle_t *)&AppTaskCreate_Handle);
    
46.   if(xReturn ==pdPASS)
    
47.         {
    0 A. ?+ t' ]% v5 G; L' ^
48.                 vTaskStartScheduler();
    
49.                 f_printf("start..\r\n");
    # J/ e+ X7 ~6 {. ^9 Y1 K
50.         }
    9 D4 A. B4 o& e6 X- O
51.   while (1)
    . n$ I$ w2 s( u6 p- V
52.   {
    
53.     /* USER CODE END WHILE */
    * s$ H. K7 h4 q3 J
54. 
    
55.     /* USER CODE BEGIN 3 */
    
56.   }
    . G9 ?* V6 C- q- L: j
57.   /* USER CODE END 3 */
    : n1 d  E8 _4 a# A7 |+ g
58. 
    
59. 
    % o2 ^7 T+ Q5 ]) n0 S  y# H
60. }
    * X+ E/ w, ~* ^  M4 w/ q# j; K
61. 
    2 u9 \& P3 d! o: v+ @
62. 
    
63. /* USER CODE BEGIN 4 */
    
64. static void AppTaskCreate(void)
    # S$ i8 M1 u. M5 t- o
65. {
    - w, t* I+ C5 ~$ i) `
66.   UBaseType_t xReturn = pdPASS;
    " @3 L6 e/ r5 L- k% E
67. 
    
68. 
    
69.   xReturn = xTaskCreate((TaskFunction_t) KeyTaskCreate,
    9 E9 e- N$ N& B. N6 D) Y
70.                              (const char *)   "KEYTASKCREATE",
    
71.                                                  (uint16_t)       128,
    
72.                                                  (void *)         NULL,
    
73.                                                  (UBaseType_t )   2,
    4 r% x! X" G& @5 g  q6 w
74.                                                  (TaskHandle_t *) &KeyTask_Handle);
    - o- E9 R1 ?$ X* W3 S. n- `
75. 
    3 x- m$ e! h6 g1 ], u  {% n6 [4 z
76.   xReturn = xTaskCreate((TaskFunction_t) Led1TaskCreate,
      l7 }1 W3 l+ u: O7 z
77.                                                 (const char *)   "LED1TASKCREATE",
      D+ P& q; _# W% {4 W. \8 c; \
78.                                                 (uint16_t)       128,
    9 @( y) X6 F" o0 @8 L3 k
79.                                                 (void *)         NULL,
      D  v$ @$ j, q" }
80.                                                 (UBaseType_t)    1,
    ; [  g- |1 y. H! J! ~& `3 i2 v9 N
81.                                                 (TaskHandle_t *)&Led1Task_Handle);
    
82.         
    ' \* E0 u+ _1 Q' x$ w
83.     /*Create a binary semaphore*/
    4 \: E) K# U1 e+ n3 h3 D1 k# _
84.         Binary_Handle = xSemaphoreCreateBinary();
    ; x3 ~0 G) `- b/ F! ?
85.         if(Binary_Handle !=NULL)
    
86.                 f_printf("Create Semph_Binary PASS.\r\n");
      m' y. X7 N: M3 @+ [- R
87.         
      X9 W5 c; J8 `3 V# k
88.         if(xReturn == pdPASS)
    ' U' I5 Y% a* Q/ P. Z
89.     vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);               
    
90. }
    
91. 
    6 s* o- j: t8 G/ C9 a. G
92. static void KeyTaskCreate(void)
    
93. {
    
94.   while(1)
    
95.         {
    
96.                 UBaseType_t xReturn = pdPASS;
    ( z2 n3 E9 D; o3 W) F
97.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    . o* `# K8 h" @( c( D0 z. k# F2 J% b
98.                 {
    
99.                         f_printf("KEY TASK PASS.\r\n");
    ! I/ l$ o# X- x1 T8 k- F' p' l' _
100.                         vTaskDelay(100);
     
101.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     7 w+ ^" O6 c7 S# t
102.                         {
     
103.                                 xReturn = xSemaphoreGive(Binary_Handle);
     6 T( c- S& p9 [: F: @" K& @- N5 k
104.                                 if(xReturn == pdPASS)
     
105.                                         f_printf("GIVE BINARY PASS.\r\n");
     4 {: i' I3 v3 K
106.                                 else if(xReturn == errQUEUE_FULL)
     1 E  J! a& ?7 o/ a  S4 H; P! W- V
107.                                         f_printf("QUEUE IS FULL.\r\n");
     
108.                         }
     % s$ V, ?: a; l/ f
109.                 }
     4 @2 H$ A: W# Y" u7 m  G: B  z
110.                
     
111.     vTaskDelay(100);
     
112.         }
     ; _; m! ?6 q& D7 d: c/ V: c8 z
113. 
     
114. }
     : P6 Z+ ?  I+ @9 T; e# f
115. static void Led1TaskCreate(void)
     6 T( G* ?6 E  m& G! ~0 G
116. {
     
117.   while(1)
     
118.         {
     ( x9 V! m) W" Z/ e' h. u# a
119.                 UBaseType_t xReturn = pdPASS;
     * I$ y) W" }+ N) j! `1 Y
120.                
     
121.                 xReturn = xSemaphoreTake(Binary_Handle, portMAX_DELAY);
     
122.                 if(xReturn == pdPASS)
     8 ^* {7 C! v$ l3 O) g0 ~( L
123.                 {
     
124.                         f_printf("TAKE BINARY PASS.\r\n");
     
125.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     
126.                 }
     ) }( M  W1 `- T; `1 X+ c
127.                
     
128.           vTaskDelay(100);
     
129.         }
     
130. }
     # Q# A" E; a; u3 A& w
131. 
     ! m$ \( ^8 b7 ~5 ?, S! ~
132. /* USER CODE END 4 */

复制代码

! a# R# ?0 Q  b4 S计数信号量的用法示例
" v) _! V. a% e; Q2 A: h3 z7 j1.创建好带有printf-stdarg.c的FreeRTOS的工程
" N3 Q9 x; L6 n; W
' f/ G/ ]/ G* r! u, J2.修改main.c文件
! H) v8 \, F, C7 i! ^& t! `4 g
+ J9 B- ~2 w9 l

1. /* USER CODE BEGIN Includes */
   
2. 
   6 x* k7 s8 M% x- r* F- e
3. #include "FreeRTOS.h"
   ' J- n! N. ]3 g/ d. F' C; f) Q" `
4. #include "task.h"
   3 G+ e2 T3 a# m7 k+ N! o) z$ c8 O
5. #include "queue.h"
   
6. #include "semphr.h"
   
7. #include <stdio.h>
   
8. #include <string.h>
   , w/ A( C. [- T9 u# z
9. 
   
10. /* USER CODE END Includes */
    
11. /* USER CODE BEGIN PV */
    5 a5 \- A" J( r7 d- y5 T6 T3 W/ x
12. static TaskHandle_t AppTaskCreate_Handle = NULL;
    7 A! ?8 t8 D- S/ e& b% L
13. static TaskHandle_t KeyTask_Handle = NULL;
    
14. static TaskHandle_t Led1_Handle = NULL;
    
15. 
    
16. SemaphoreHandle_t SemaphCount_Handle = NULL;
    $ l! l, V4 R: j4 U
17. 
    
18. extern int f_printf(const char *format, ...);
    ' C% n5 K* j9 [) y8 P
19. 
    
20. /* USER CODE END PV */
    
21. 
    
22. /* USER CODE BEGIN PFP */
    
23. 
    
24. static void AppTaskCreate(void);
    
25. static void KeyTaskCreate(void);
    
26. static void LED1TaskCreate(void);
    
27. 
    
28. /* USER CODE END PFP */
    9 r* `$ ^/ {2 j+ n: T1 ^
29. 
    
30. int main()
    % Q$ P  u% u' h# \
31. {
    
32.   ***
    
33. 
    ; O( b  d8 N) h  v, H  T5 B
34.   /* USER CODE BEGIN WHILE */
    7 }0 e! a; t7 {6 {' Y
35. 
    - {- N/ t" s3 {4 z3 U
36.   UBaseType_t xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    0 U# {5 O( O- N  |0 a. p( @8 |
37.                                     (const char *)"APPTASKCREATE",
    
38.                                                                         (uint16_t)    128,
    
39.                                                                         (void *)      NULL,
    ( P! W& ^' U! ?$ q2 d! n- V
40.                                                                         (UBaseType_t) 2,
    ( X# \3 F9 ~3 Q5 ~* y, b' }
41.                                                                         (TaskHandle_t *)&AppTaskCreate_Handle);
    
42.         if(xReturn ==pdPASS)
    9 y1 d/ N6 E/ w" ^2 K* V
43.         {
    
44.                 f_printf("TASK START.\r\n");
    , k- |) |8 \  o3 `% X# q* s
45.                 vTaskStartScheduler();
    ! y5 z+ c& V; J9 ^2 I% s) ]
46.         }
    
47.   while (1)
    
48.   {
    & N9 g" d+ i2 O2 j* \0 ]: {% T$ l
49.     /* USER CODE END WHILE */
    
50. 
    
51.     /* USER CODE BEGIN 3 */
    
52.   }
    
53.   /* USER CODE END 3 */
    ) h, L- a2 c1 P, v  h. I1 q" a7 E
54. }
    7 o, ^) k. d0 q" ?
55. 
    0 K2 H0 l5 T2 B' u/ K1 [5 E6 V& `
56. /* USER CODE BEGIN 4 */
    
57. static void AppTaskCreate(void)
    
58. {
    
59. 
    . ^% J% Q7 W  L, W; n6 I
60.   UBaseType_t xReturn ;
    
61.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
62.                                     (const char *) "KEYTASKCREATE",
    
63.                                     (uint16_t)      128,
    * x) ?/ [- e1 @' ^9 Y$ n# e
64.                                                                         (void *)       NULL,
    ; @- Z+ P8 l3 Y4 q' e$ e
65.                                                                         (UBaseType_t)   2,
    + v, u+ Y" {4 g
66.                                                                         (TaskHandle_t*)&KeyTask_Handle);
    
67.   if(xReturn == pdPASS)
    ! t& Q8 y2 G, d0 `. ]; s
68.                 f_printf("KEY CREATE PASS.\r\n");
    
69. 
    # a6 ?: Y9 W; s, @) J6 E. _) x
70.   xReturn = xTaskCreate((TaskFunction_t)LED1TaskCreate,
    
71.                                                 (const char *)  "LED1TASKCREATE",
    : O; a& [7 q8 w
72.                                                 (uint16_t)      128,
      z$ v5 n' @3 U( }# l5 g
73.                                                 (void *)        NULL,
    # @: X) x6 B0 H
74.                                                 (UBaseType_t)   1,
    $ r3 q3 I0 c* }' f# q2 k/ O' H
75.                                                 (TaskHandle_t*)&Led1_Handle);
    6 c, x# P7 w! f6 k" w( b9 H* C& `/ o* t; U
76. 
    0 c2 [3 f4 I7 h: g* J% {) e1 Z" I
77.         SemaphCount_Handle = xSemaphoreCreateCounting(3,0);
    ) @1 r$ w( _( {1 c* Y8 B: T( n3 [
78.         if(SemaphCount_Handle != NULL)
    
79.                 f_printf("SEMAPHORE COUNT CREATE PASS.\r\n");
    / f7 |( ]0 ^$ v+ E
80.         
    / u% y1 M; y( S' T! w
81.   if(xReturn == pdPASS)
    3 G- h8 I9 K: g' ]
82.         {
    : k! P' J7 |+ p* a
83.                 f_printf("LED CREATE PASS.\r\n");        
    
84.                 vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);
    
85.         }
    ! n9 m2 d" l5 T+ i* r$ ]7 C, W0 \
86. }
    7 }0 x0 }2 a$ \
87. 
    
88. 
    
89. static void KeyTaskCreate(void)
    " X9 ~+ m/ v2 N- B: }
90. {
    4 e2 j( M2 ~- M, x) \1 q4 a
91.   while(1)
    
92.         {
    ( r8 G; H" z) E& _  H! _, H
93.                 UBaseType_t xReturn = pdPASS;
    
94.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
95.                 {
    , g  N& g3 `/ X+ W
96.                         vTaskDelay(100);
    
97.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
98.                         {
    0 ~4 {; V. k0 H# b# W. W
99.                                 f_printf("KEY PRESS.\r\n");
    
100.                                 xReturn = xSemaphoreGive(SemaphCount_Handle);
     
101.                                 if(xReturn == pdPASS)
     ' G0 x! v9 _! Y% c! Y# {
102.                                         f_printf("GIVE COUNTING PASS.\r\n");
     
103.                                 else if(xReturn == errQUEUE_FULL)
     
104.                                         f_printf("QUEUE IS FULL.\r\n");
     
105.                         }
     
106.                 }               
     $ u% I1 |, H2 j5 @) q) u
107.                 vTaskDelay(10);
     5 v' @# T, }; f
108.         }
     
109. }
     
110. static void LED1TaskCreate(void)
     
111. {
     
112.         while(1)
     / D& j& w% U7 B: q
113.         {
     
114.                 UBaseType_t xReturn = pdPASS;
     
115.                
     ' e; p; u* N+ |: a; Q  B3 G5 s
116.                 xReturn = xSemaphoreTake(SemaphCount_Handle,portMAX_DELAY);
     
117.                
     
118.                 if(xReturn == pdTRUE)
     
119.                 {
     
120.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     
121.                         f_printf("Counting Take PASS.\r\n");
     
122.                 }
     . G5 D8 Q1 _. Z
123.                 else if(xReturn == errQUEUE_EMPTY)
       Q/ {, e, C. ]  I" f7 W- b
124.                         f_printf("semaphore is empty.\r\n");
     
125.                 vTaskDelay(2000);
       _$ ], ^7 L1 n
126.         }
     
127. }
     
128. /* USER CODE END 4 */
     
129. 
     

复制代码

; ?% ~+ z. Q& k9 [1 h