二值信号量的用法示例
; W( L7 m4 Q$ a, A1.创建好带有printf-stdarg.c的FreeRTOS的工程
+ a$ I9 D* ?7 n6 b0 x  F! q6 ]
" h7 _; w3 c4 @* F/ Y) l2.修改main.c文件

$ t$ [9 |' Y1 u# u  L' \, w! j

1. /* USER CODE BEGIN Includes */
   
2. 
   # b. E0 L1 [5 \0 p6 O' ~
3. #include "FreeRTOS.h"
   7 y4 T' ^0 y0 x) B( _
4. #include "task.h"
   # C; m  R3 s" _
5. #include "queue.h"
   9 J9 x+ d. R- c0 F; c
6. #include "semphr.h"
   
7. #include <stdio.h>
   
8. #include <string.h>
   ; x1 x, k  |/ x8 R" A  i" S  @" n
9. 
   
10. /* USER CODE END Includes */
    
11. /* USER CODE BEGIN PV */
    $ u/ W0 m; ^+ Y9 K$ n! J! L
12. 
    5 T; g! e$ n# H' [+ L4 c
13. static TaskHandle_t AppTaskCreate_Handle = NULL;
    
14. static TaskHandle_t KeyTask_Handle = NULL;
    : ~3 M4 I" v+ r$ b# c6 M6 n
15. static TaskHandle_t Led1Task_Handle = NULL;
    ; L& [+ h! d- e& P6 ]7 \- J0 W
16. 
    8 J1 k5 n) F9 V7 b/ p
17. /*Create a binary semaphore handle*/
    
18. static SemaphoreHandle_t Binary_Handle = NULL;
    
19. 
    
20. extern int f_printf(const char *format, ...);
    
21. 
    
22. /* USER CODE END PV */
    
23. /* USER CODE BEGIN PFP */
    , \9 r. B3 B; q( }7 K3 T8 ~$ u3 Q7 B
24. 
    
25. /*Create a task function*/
      \  [' X* q9 E9 c6 s
26. static void AppTaskCreate(void);
    9 Z8 v  e0 U  m, B( X
27. static void KeyTaskCreate(void);
    7 N1 F7 G: h0 s+ L/ L; Z% |) F
28. static void Led1TaskCreate(void);
    . |0 U* k. j$ m/ q
29. 
    
30. /* USER CODE END PFP */
    % k) ^6 R# q; Z5 A3 K
31. 
    ' [7 d$ x3 E/ K( d# o
32. int main()
    
33. {
    
34.   /*
    ; H, {5 ^  z, a6 _( ^
35.   *
    
36.   */
    
37.   /* USER CODE BEGIN WHILE */
    # K% t. O8 |; a" f9 d/ Q& |
38.   UBaseType_t xReturn = pdPASS;
    1 h- E; @9 d: I5 I( n
39.         
    
40.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    4 X4 x; A. ?" J1 k; M: C) l+ a- r6 ^
41.                               (const char *) "APPTASKCREATE",
    ! X, }0 P, W# n" v$ R+ [9 O
42.                                                   (uint16_t)     128,
    
43.                                                   (void *)       NULL,
    
44.                                                   (UBaseType_t)  2,
    & j1 y; E/ O" G1 F6 p
45.                                                   (TaskHandle_t *)&AppTaskCreate_Handle);
    # ]0 ?% C( k4 H+ [4 F9 B2 l& _
46.   if(xReturn ==pdPASS)
    
47.         {
    
48.                 vTaskStartScheduler();
    , m' l- w/ B/ d
49.                 f_printf("start..\r\n");
    
50.         }
    / b' P# s/ F) _. w" n2 R, r
51.   while (1)
    + ^* [$ x- {+ Y+ s' ?$ {( r: Y9 f
52.   {
    
53.     /* USER CODE END WHILE */
    9 |: f5 K7 q" Y2 P+ Z$ z
54. 
    
55.     /* USER CODE BEGIN 3 */
    8 T, v4 O" y* O- ?
56.   }
    
57.   /* USER CODE END 3 */
    
58. 
    # O3 |8 X& t* u5 o+ F' n
59. 
    # h1 ^2 p* E" D2 G$ \5 B
60. }
    
61. 
    
62. 
    - V0 Q$ ]4 ^8 o# D9 b
63. /* USER CODE BEGIN 4 */
    
64. static void AppTaskCreate(void)
    8 j9 F2 m, Z8 [
65. {
    
66.   UBaseType_t xReturn = pdPASS;
    & V% z5 Y; u+ ^6 o2 L
67. 
    
68. 
    ( O) D( _3 ~4 T% T& [) |
69.   xReturn = xTaskCreate((TaskFunction_t) KeyTaskCreate,
    
70.                              (const char *)   "KEYTASKCREATE",
    2 i2 a% u) Q" a  H
71.                                                  (uint16_t)       128,
    5 s) Q1 k8 ?4 w0 o
72.                                                  (void *)         NULL,
    
73.                                                  (UBaseType_t )   2,
    " v$ v/ y" F( U: i
74.                                                  (TaskHandle_t *) &KeyTask_Handle);
    $ q4 l6 e% `( K- D7 G
75. 
    
76.   xReturn = xTaskCreate((TaskFunction_t) Led1TaskCreate,
    7 g! J' r( R. w- J3 K
77.                                                 (const char *)   "LED1TASKCREATE",
    
78.                                                 (uint16_t)       128,
    " c, X+ ]: u4 `, |
79.                                                 (void *)         NULL,
    
80.                                                 (UBaseType_t)    1,
    
81.                                                 (TaskHandle_t *)&Led1Task_Handle);
    & s' a: |- i9 G2 G, L1 h
82.         
    
83.     /*Create a binary semaphore*/
    
84.         Binary_Handle = xSemaphoreCreateBinary();
    ( |! H$ v' j( R; C- J
85.         if(Binary_Handle !=NULL)
    9 h! W5 \- T4 w4 `7 C  o
86.                 f_printf("Create Semph_Binary PASS.\r\n");
    / [8 ~5 p6 Q- X0 Q3 b' s
87.         
    + S$ [6 p" e+ l) ?% X4 o+ `2 K
88.         if(xReturn == pdPASS)
    + \  X( E7 N. O3 ?, j/ h! D
89.     vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);               
    3 h5 N' z* S9 A6 F$ Y
90. }
    
91. 
    
92. static void KeyTaskCreate(void)
    4 u# J- C- U8 P( G8 |- D7 d
93. {
    
94.   while(1)
    1 g( h! q( h+ `3 m
95.         {
    - z! {& v; c( V. p. _  f* l
96.                 UBaseType_t xReturn = pdPASS;
    
97.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    7 o. Z7 m* D0 Q
98.                 {
    $ P2 |3 Q+ P7 ?6 ]# F7 m8 Z  g) V/ |
99.                         f_printf("KEY TASK PASS.\r\n");
    , V' x7 Q, n0 d6 S  q6 l
100.                         vTaskDelay(100);
     
101.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     & A: g2 C8 N0 ^, w) _
102.                         {
     , w: R7 Q4 [1 l) f3 C4 _
103.                                 xReturn = xSemaphoreGive(Binary_Handle);
     
104.                                 if(xReturn == pdPASS)
     ; L! j9 X+ e4 t6 y# t- ]) D
105.                                         f_printf("GIVE BINARY PASS.\r\n");
     : A% o* V1 a$ C  j# M/ _0 \
106.                                 else if(xReturn == errQUEUE_FULL)
     
107.                                         f_printf("QUEUE IS FULL.\r\n");
     . C# g( Y( S( q! ]
108.                         }
     4 Q+ b; Z( W. a) v7 R& C
109.                 }
     
110.                
     & c1 |5 c, @1 d0 b
111.     vTaskDelay(100);
     ; V( q7 n( b; ]) m5 r5 G* @( k- h
112.         }
     
113. 
     
114. }
     
115. static void Led1TaskCreate(void)
     + v* j& I. y# x8 W$ G' Y$ d
116. {
     8 Q- `# e3 E; `+ \# C2 H
117.   while(1)
     
118.         {
     
119.                 UBaseType_t xReturn = pdPASS;
     
120.                
     0 X& N: |# h4 W; ?, h$ o" q. R
121.                 xReturn = xSemaphoreTake(Binary_Handle, portMAX_DELAY);
     
122.                 if(xReturn == pdPASS)
     
123.                 {
     2 T* V& b+ b! O
124.                         f_printf("TAKE BINARY PASS.\r\n");
     ' K9 Y' u  N, ^% F
125.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     5 g9 t) D$ c0 I( V( i
126.                 }
     ; [% i- ?; H" X  ~
127.                
     5 v: ]' Z9 e" a
128.           vTaskDelay(100);
     + Y+ T3 `7 D# C+ @! \
129.         }
     ! b2 R# a3 Z5 `0 e0 g, x
130. }
     
131. 
     0 U, J2 E& s5 @, b5 q2 V' X! Z% O% v
132. /* USER CODE END 4 */

复制代码

计数信号量的用法示例
1.创建好带有printf-stdarg.c的FreeRTOS的工程

2.修改main.c文件

1. /* USER CODE BEGIN Includes */
     P6 j) C- `- s4 _* r8 D. w
2. 
     j$ T1 w0 {% p- H3 _) b/ K1 r! D' S
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   
5. #include "queue.h"
   9 h( g) |- B$ o
6. #include "semphr.h"
   & ]( G9 c$ y; F- i/ B. h# I4 q" p
7. #include <stdio.h>
   4 m' I3 o% S& [' w2 V% Z
8. #include <string.h>
   
9. 
   
10. /* USER CODE END Includes */
    8 j" r( |& V) ^2 Q1 B. ?
11. /* USER CODE BEGIN PV */
    
12. static TaskHandle_t AppTaskCreate_Handle = NULL;
    / N* c0 K* x  N
13. static TaskHandle_t KeyTask_Handle = NULL;
    
14. static TaskHandle_t Led1_Handle = NULL;
    + c8 ?* F% |# N+ f
15. 
    1 ~, O$ c$ E/ Z: A% I5 K
16. SemaphoreHandle_t SemaphCount_Handle = NULL;
    4 [# q( \' V$ V- ?
17. 
    
18. extern int f_printf(const char *format, ...);
    ) Q; A! K# L! k1 D6 N4 Z0 m
19. 
    ) ~1 j( P* g# f' X* g0 G/ N6 h
20. /* USER CODE END PV */
    
21. 
    ) q# o% l7 ]% k9 w+ C, E
22. /* USER CODE BEGIN PFP */
    
23. 
    
24. static void AppTaskCreate(void);
    
25. static void KeyTaskCreate(void);
    ( s. a. g. h& q: f$ S$ P8 C! p4 ~
26. static void LED1TaskCreate(void);
    : n+ q2 V* J  J9 o9 M# O
27. 
    
28. /* USER CODE END PFP */
    & K, m9 ^$ q: t$ ]" n7 H' H
29. 
    $ n' I) l) h3 ^  ^3 k
30. int main()
    ! n! y' O* f) I/ e
31. {
    , ^9 ?) v. M1 s1 A
32.   ***
    
33. 
    
34.   /* USER CODE BEGIN WHILE */
    
35. 
    - I3 q5 d: F$ a0 J# O, z* \- [7 ^
36.   UBaseType_t xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
37.                                     (const char *)"APPTASKCREATE",
    . M& W  W0 y# v5 f0 d' J, y4 I( U
38.                                                                         (uint16_t)    128,
    5 X8 f( X. `9 s5 f
39.                                                                         (void *)      NULL,
    ; K( g& k1 D( H+ T" ~! s6 |
40.                                                                         (UBaseType_t) 2,
    
41.                                                                         (TaskHandle_t *)&AppTaskCreate_Handle);
    8 m, R# B* g, ~4 q9 ?# {  G
42.         if(xReturn ==pdPASS)
    " {/ w' k$ I6 s7 f$ X2 L
43.         {
    
44.                 f_printf("TASK START.\r\n");
    ' b  s- w2 o  t. S, T* X- m
45.                 vTaskStartScheduler();
    
46.         }
      j/ p: }% b2 {2 ?7 N' u$ u
47.   while (1)
    2 L: h  Y. [8 D+ ~! I/ R
48.   {
    6 I5 K6 [) T* R3 h. j, c! J* x3 S
49.     /* USER CODE END WHILE */
    
50. 
    
51.     /* USER CODE BEGIN 3 */
    5 S# s1 H0 R6 Z4 K
52.   }
    
53.   /* USER CODE END 3 */
    ) a6 M: r5 w/ ]- c5 J1 V
54. }
    . p& Z: |& Q0 }0 X) s' {) M
55. 
    
56. /* USER CODE BEGIN 4 */
    
57. static void AppTaskCreate(void)
    . _% @% L$ u; J; }; G1 y
58. {
    
59. 
    * X8 D3 s' C. c7 i' o% b
60.   UBaseType_t xReturn ;
    
61.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
62.                                     (const char *) "KEYTASKCREATE",
    2 r0 m: \) ?" F5 G4 R+ @% P! m" g
63.                                     (uint16_t)      128,
    
64.                                                                         (void *)       NULL,
    * m# X: Q# l+ |; }/ @0 \+ a
65.                                                                         (UBaseType_t)   2,
    
66.                                                                         (TaskHandle_t*)&KeyTask_Handle);
    0 I1 s' S9 |% O6 p9 q
67.   if(xReturn == pdPASS)
    7 J) u# l1 p6 ^; t: y% q3 T2 T. p
68.                 f_printf("KEY CREATE PASS.\r\n");
    
69. 
    . {! Y- m0 v) K! F) A0 e" R" v
70.   xReturn = xTaskCreate((TaskFunction_t)LED1TaskCreate,
    
71.                                                 (const char *)  "LED1TASKCREATE",
    
72.                                                 (uint16_t)      128,
    ' ]1 `, V+ }& ?6 v* E5 k7 f! B
73.                                                 (void *)        NULL,
    4 f4 f) N' w/ M2 @, _4 r2 i1 V
74.                                                 (UBaseType_t)   1,
    / b" A8 ^9 C- ~% Y0 p) Q! m  V
75.                                                 (TaskHandle_t*)&Led1_Handle);
    
76. 
    ; K) L5 q, J  }% B$ U
77.         SemaphCount_Handle = xSemaphoreCreateCounting(3,0);
    
78.         if(SemaphCount_Handle != NULL)
    , Z7 z' p& e' o2 c% I
79.                 f_printf("SEMAPHORE COUNT CREATE PASS.\r\n");
    + L6 \" c! Z! K; s0 Y" W2 d, g
80.         
    
81.   if(xReturn == pdPASS)
    ! k/ [4 L* Z& h0 O3 z, ?
82.         {
    
83.                 f_printf("LED CREATE PASS.\r\n");        
    0 m4 S, \$ Z# x4 F
84.                 vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);
    
85.         }
    
86. }
    
87. 
    
88. 
    # H* L% c- a' [
89. static void KeyTaskCreate(void)
    
90. {
    
91.   while(1)
    
92.         {
    
93.                 UBaseType_t xReturn = pdPASS;
    " g. {- ]7 @# ?' W- ]
94.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    1 i! `( {9 k2 V, {! v6 h7 i' h
95.                 {
    
96.                         vTaskDelay(100);
    5 }: W6 H$ u: E6 [: |
97.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    $ q7 ?5 s1 c) j1 y: V9 R. L/ V( C
98.                         {
    
99.                                 f_printf("KEY PRESS.\r\n");
    - U8 X8 @  o/ T% k) V% g
100.                                 xReturn = xSemaphoreGive(SemaphCount_Handle);
     ' L" q3 e0 x6 R5 Y* P% r  L
101.                                 if(xReturn == pdPASS)
     
102.                                         f_printf("GIVE COUNTING PASS.\r\n");
     
103.                                 else if(xReturn == errQUEUE_FULL)
     
104.                                         f_printf("QUEUE IS FULL.\r\n");
     : t4 V' u" c% O. ^) z/ W; @
105.                         }
     
106.                 }               
     " [" V2 V: e8 K9 G
107.                 vTaskDelay(10);
     
108.         }
     & |  Z' J. u( b# k7 h' u
109. }
     ! d$ B5 D# j7 @' b% M' P, v/ T
110. static void LED1TaskCreate(void)
     8 d, \4 H% x0 o! i) ^! H/ _
111. {
     5 ?/ G1 |# v7 E! J3 U# ^
112.         while(1)
     2 i$ W% @$ L2 C! S/ c; V2 C
113.         {
     6 G  }% K8 t8 [- w
114.                 UBaseType_t xReturn = pdPASS;
     
115.                
     * b3 D* m$ e1 }( V" I
116.                 xReturn = xSemaphoreTake(SemaphCount_Handle,portMAX_DELAY);
     # m- y7 T* E" m, l
117.                
     
118.                 if(xReturn == pdTRUE)
     
119.                 {
     
120.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     ! R  }0 p2 i- v" X9 j! ~
121.                         f_printf("Counting Take PASS.\r\n");
     ( j0 \1 H! m3 u& T2 C3 {0 \
122.                 }
     ! b2 P) k" l1 b7 X) N
123.                 else if(xReturn == errQUEUE_EMPTY)
     * M8 C: F" G& C3 @6 E# P; r
124.                         f_printf("semaphore is empty.\r\n");
     
125.                 vTaskDelay(2000);
     
126.         }
     " N1 p0 b; u" g2 t, T: z, X
127. }
     
128. /* USER CODE END 4 */
     
129. 
     ( Q. }/ P7 M$ Z: q0 x$ y

复制代码