二值信号量的用法示例
8 {5 [# c) q& _5 [& n" ^1.创建好带有printf-stdarg.c的FreeRTOS的工程

2.修改main.c文件
( o4 k4 P( Q% S7 z/ t, k1 u8 L
- V  P: n& m+ S* G1 }

1. /* USER CODE BEGIN Includes */
   ! c: y1 P* k  q, `# w& q- I
2. 
   ; v3 q- W# V2 }: {- T7 `
3. #include "FreeRTOS.h"
   0 m! n5 P7 \! q. q) C' \  l
4. #include "task.h"
   ! a% r" x+ l8 [1 Z8 e, k8 B
5. #include "queue.h"
   
6. #include "semphr.h"
   
7. #include <stdio.h>
   
8. #include <string.h>
   
9. 
   ' p; _& }* b& D, c" n
10. /* USER CODE END Includes */
    
11. /* USER CODE BEGIN PV */
    
12. 
    / F  Q7 O- q( T+ K
13. static TaskHandle_t AppTaskCreate_Handle = NULL;
    6 _1 k4 ]6 l! f/ x: ?9 Z
14. static TaskHandle_t KeyTask_Handle = NULL;
    
15. static TaskHandle_t Led1Task_Handle = NULL;
    5 J# w0 y+ k0 N# ?2 g& T, W3 ]) M! E6 A. I
16. 
    
17. /*Create a binary semaphore handle*/
    5 u6 {; q4 }, x  j: L9 r
18. static SemaphoreHandle_t Binary_Handle = NULL;
    ) W3 j. T, `7 ~, B" @
19. 
    
20. extern int f_printf(const char *format, ...);
    
21. 
    : v* n  Y6 M9 _+ }& e* G7 F  J
22. /* USER CODE END PV */
    . J" T; I1 i' H, w& M1 V& p
23. /* USER CODE BEGIN PFP */
    $ Q. r# Z; K3 Y* j
24. 
    
25. /*Create a task function*/
    ) l% I! W- @2 P5 J9 ^4 n. [
26. static void AppTaskCreate(void);
    
27. static void KeyTaskCreate(void);
    
28. static void Led1TaskCreate(void);
    / Z1 d/ |3 Z. h, Z# c
29. 
    4 D  Y' j1 G3 x
30. /* USER CODE END PFP */
    
31. 
    
32. int main()
    
33. {
    ; h" k5 j8 o! k0 G7 j9 z
34.   /*
    
35.   *
    ) \/ A. d- m/ P* g/ u- F
36.   */
    4 G6 S5 L, V% ~& F& O! c2 h, E
37.   /* USER CODE BEGIN WHILE */
    
38.   UBaseType_t xReturn = pdPASS;
    , X& R* j) N' A' o
39.         
    0 t9 X# V7 T5 [* {! e6 s, M, J" O
40.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    * r" b1 X  K* K. o
41.                               (const char *) "APPTASKCREATE",
    0 j# U! L- a. Y- y
42.                                                   (uint16_t)     128,
    
43.                                                   (void *)       NULL,
    
44.                                                   (UBaseType_t)  2,
    
45.                                                   (TaskHandle_t *)&AppTaskCreate_Handle);
    
46.   if(xReturn ==pdPASS)
    8 y% I0 ~( E. F0 H6 K! o- z  a/ T
47.         {
    % P3 t9 S' l1 \, H8 ~: n
48.                 vTaskStartScheduler();
    
49.                 f_printf("start..\r\n");
    
50.         }
    8 T# ^4 R% S6 f" H+ O
51.   while (1)
    
52.   {
    ; m5 _  x9 t, }5 G6 }
53.     /* USER CODE END WHILE */
    1 |' ?% f! s/ `7 Q& Z
54. 
    . ]- E& N& ]/ s' F
55.     /* USER CODE BEGIN 3 */
    
56.   }
    5 V. T2 q/ ]6 r& w% ?; C& b( K4 G
57.   /* USER CODE END 3 */
    
58. 
    
59. 
    4 B8 v$ z- b; N. Z8 z3 F6 z
60. }
    - B( w6 w/ j9 I  [; c4 H! r
61. 
    
62. 
    
63. /* USER CODE BEGIN 4 */
    ) L7 o7 J# i% [1 n: r: j# Q' y7 h
64. static void AppTaskCreate(void)
    / d; L7 O  }- V
65. {
    4 U& `# r, _+ Q
66.   UBaseType_t xReturn = pdPASS;
      Q( O- s( R3 q% H5 l& {6 r
67. 
    
68. 
    $ q5 _' j/ B% W3 Z- G
69.   xReturn = xTaskCreate((TaskFunction_t) KeyTaskCreate,
    
70.                              (const char *)   "KEYTASKCREATE",
    . U' h& q4 S1 S( P5 j4 l' V. I( L
71.                                                  (uint16_t)       128,
    : Y$ }- j+ L( a+ N: X# U* D
72.                                                  (void *)         NULL,
    
73.                                                  (UBaseType_t )   2,
      }0 |! B7 b4 k# w* R+ _
74.                                                  (TaskHandle_t *) &KeyTask_Handle);
    - A# s8 H; l, ]: z3 a% A
75. 
    
76.   xReturn = xTaskCreate((TaskFunction_t) Led1TaskCreate,
    . I7 A1 t0 K* P2 z3 d: V1 _, U
77.                                                 (const char *)   "LED1TASKCREATE",
    
78.                                                 (uint16_t)       128,
    
79.                                                 (void *)         NULL,
    
80.                                                 (UBaseType_t)    1,
    
81.                                                 (TaskHandle_t *)&Led1Task_Handle);
    7 X; ?. Q) g* L3 Z
82.         
    4 B/ X. X  Z  K
83.     /*Create a binary semaphore*/
    
84.         Binary_Handle = xSemaphoreCreateBinary();
    0 a  q2 `8 N1 u4 X6 T
85.         if(Binary_Handle !=NULL)
    : f  W: W& Y! X& z% O4 {
86.                 f_printf("Create Semph_Binary PASS.\r\n");
    
87.         
    
88.         if(xReturn == pdPASS)
    
89.     vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);               
    9 a( ~+ q  h& i/ Y1 r" j
90. }
    ) {8 V& B; }, v) G- c  t, Q
91. 
    
92. static void KeyTaskCreate(void)
    ' {: u# g1 [, T
93. {
    ) \9 p6 _4 B4 v) P! v9 k' X
94.   while(1)
    
95.         {
    
96.                 UBaseType_t xReturn = pdPASS;
    + r/ ~" z$ a& A$ M6 {
97.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    7 M8 }* S$ d# K% X% \/ p2 Y! s
98.                 {
    
99.                         f_printf("KEY TASK PASS.\r\n");
    
100.                         vTaskDelay(100);
     
101.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     2 c5 R8 l5 ?4 _6 [; a6 \# ~
102.                         {
     
103.                                 xReturn = xSemaphoreGive(Binary_Handle);
     2 \8 Q7 a) x) T
104.                                 if(xReturn == pdPASS)
     & h; x0 R& x2 ^( T7 \
105.                                         f_printf("GIVE BINARY PASS.\r\n");
     8 L: t9 w% [/ N7 E4 V2 ?4 n" o
106.                                 else if(xReturn == errQUEUE_FULL)
     
107.                                         f_printf("QUEUE IS FULL.\r\n");
     ) b9 \; v& s( w4 A& \
108.                         }
     ) D( x9 x7 U3 ?) V+ ~2 v# M
109.                 }
     
110.                
     + R/ ?9 v& m) Q+ }5 ^! I9 n
111.     vTaskDelay(100);
     - D+ V$ d2 r$ B& `
112.         }
     
113. 
     
114. }
     1 \9 I& c' a: W% m% X
115. static void Led1TaskCreate(void)
     
116. {
     
117.   while(1)
     
118.         {
     
119.                 UBaseType_t xReturn = pdPASS;
     
120.                
     
121.                 xReturn = xSemaphoreTake(Binary_Handle, portMAX_DELAY);
     
122.                 if(xReturn == pdPASS)
     
123.                 {
     
124.                         f_printf("TAKE BINARY PASS.\r\n");
     4 R5 s/ B- j% ^7 x) ^- ^7 R, f5 h
125.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     
126.                 }
     
127.                
     
128.           vTaskDelay(100);
     1 u! Y" [6 l% J( e3 l# @6 H. W% U
129.         }
     
130. }
     3 |4 h$ O) _6 i+ z
131. 
     
132. /* USER CODE END 4 */

复制代码

4 M( Q& V3 p& u2 G4 D- C* g( u计数信号量的用法示例
1.创建好带有printf-stdarg.c的FreeRTOS的工程

2.修改main.c文件
2 w  ?. j) T+ `9 e7 Y
, [  |2 o0 I  Y( h2 O

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   
5. #include "queue.h"
   / F1 g+ F8 [" {  {/ A' h! N1 [
6. #include "semphr.h"
   ; s$ L+ z6 c" z* w6 ~+ V
7. #include <stdio.h>
   
8. #include <string.h>
   
9. 
   ( R0 m( c+ L$ ]: d/ ^
10. /* USER CODE END Includes */
    1 q% P; h: q8 m( s& N) f; g# o6 k9 g
11. /* USER CODE BEGIN PV */
    6 R7 F0 j( z" z& {
12. static TaskHandle_t AppTaskCreate_Handle = NULL;
    
13. static TaskHandle_t KeyTask_Handle = NULL;
    
14. static TaskHandle_t Led1_Handle = NULL;
      t* k4 }' o: l0 h
15. 
    ' q+ D- r! q" ^+ A2 T6 T6 B- }
16. SemaphoreHandle_t SemaphCount_Handle = NULL;
      x4 E9 D8 D. q8 `" H
17. 
    
18. extern int f_printf(const char *format, ...);
    
19. 
    
20. /* USER CODE END PV */
    ) w& v# W6 b5 M2 P( m* [3 t
21. 
    
22. /* USER CODE BEGIN PFP */
    ; ~2 M' a' Z0 F* i4 R
23. 
    # m" f) d/ r: V0 R5 w/ n
24. static void AppTaskCreate(void);
    
25. static void KeyTaskCreate(void);
    
26. static void LED1TaskCreate(void);
    
27. 
    7 }+ R1 R) V; T
28. /* USER CODE END PFP */
    
29. 
    
30. int main()
    
31. {
    
32.   ***
    
33. 
    
34.   /* USER CODE BEGIN WHILE */
    
35. 
    
36.   UBaseType_t xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
37.                                     (const char *)"APPTASKCREATE",
    
38.                                                                         (uint16_t)    128,
    ' I8 r6 g/ B2 Q5 j" @* V, f
39.                                                                         (void *)      NULL,
    
40.                                                                         (UBaseType_t) 2,
    
41.                                                                         (TaskHandle_t *)&AppTaskCreate_Handle);
    : b* O) o) B& V% L8 g
42.         if(xReturn ==pdPASS)
    4 ~/ r$ i: |9 T; ]; Y8 W5 Y! D
43.         {
    
44.                 f_printf("TASK START.\r\n");
    
45.                 vTaskStartScheduler();
    
46.         }
      A) `( `( b  l3 G9 X
47.   while (1)
    
48.   {
    $ C6 P% s* V2 o: V
49.     /* USER CODE END WHILE */
    
50. 
    
51.     /* USER CODE BEGIN 3 */
    ! G' F' z/ U' ~2 s5 L1 O
52.   }
    ! M# p8 @: s0 e, R. E& Z+ l
53.   /* USER CODE END 3 */
    
54. }
    ' y& ^5 J0 m- G. w, ]
55. 
    
56. /* USER CODE BEGIN 4 */
    # V% {( [9 g! i: ]6 @+ P( ]0 t
57. static void AppTaskCreate(void)
    
58. {
    
59. 
    , j2 ~, O9 }5 r' Q
60.   UBaseType_t xReturn ;
    0 c$ P9 G# s$ F( s, A+ v3 @- l& C" x
61.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    5 e+ |0 w/ ~! j9 @1 k; s
62.                                     (const char *) "KEYTASKCREATE",
    
63.                                     (uint16_t)      128,
    
64.                                                                         (void *)       NULL,
    
65.                                                                         (UBaseType_t)   2,
    + }+ S/ {% {! U
66.                                                                         (TaskHandle_t*)&KeyTask_Handle);
    
67.   if(xReturn == pdPASS)
    
68.                 f_printf("KEY CREATE PASS.\r\n");
    
69. 
    / W, o' G8 h- u) u* c; f
70.   xReturn = xTaskCreate((TaskFunction_t)LED1TaskCreate,
    
71.                                                 (const char *)  "LED1TASKCREATE",
    
72.                                                 (uint16_t)      128,
    % N4 ~* H$ K! ?
73.                                                 (void *)        NULL,
    ! ?) P' V" I7 X
74.                                                 (UBaseType_t)   1,
    + [2 e) D+ f( `
75.                                                 (TaskHandle_t*)&Led1_Handle);
    
76. 
    
77.         SemaphCount_Handle = xSemaphoreCreateCounting(3,0);
    
78.         if(SemaphCount_Handle != NULL)
    . I3 c; H- I8 B  F) R- V; M
79.                 f_printf("SEMAPHORE COUNT CREATE PASS.\r\n");
    
80.         
    
81.   if(xReturn == pdPASS)
    
82.         {
    / x; J: m9 S- Y5 j0 g+ |" ~) \
83.                 f_printf("LED CREATE PASS.\r\n");        
    
84.                 vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);
    
85.         }
    
86. }
    
87. 
    : ]# V7 G  ^' f/ p8 ^' p! T' \
88. 
    
89. static void KeyTaskCreate(void)
    
90. {
    
91.   while(1)
    
92.         {
    
93.                 UBaseType_t xReturn = pdPASS;
    ) a4 x* b2 k) g1 B) \' G+ d! P
94.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
95.                 {
    
96.                         vTaskDelay(100);
    $ |7 l  C3 F, f0 [8 I- w' z: c3 B! F
97.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
98.                         {
    + M1 t' \% ]! r7 `. B6 ]
99.                                 f_printf("KEY PRESS.\r\n");
    
100.                                 xReturn = xSemaphoreGive(SemaphCount_Handle);
     
101.                                 if(xReturn == pdPASS)
     0 k. _1 o, K4 x% q
102.                                         f_printf("GIVE COUNTING PASS.\r\n");
     6 w5 P( }8 f+ Q. @# e
103.                                 else if(xReturn == errQUEUE_FULL)
     - f  Q' b$ M* |+ ^- x! U% Y6 F
104.                                         f_printf("QUEUE IS FULL.\r\n");
     
105.                         }
     6 ~, K, ?! s% s$ u9 O2 g9 r
106.                 }               
     0 T+ c; d3 B7 D. g
107.                 vTaskDelay(10);
     1 C# ~: s* Q% ]8 j+ F
108.         }
     
109. }
     
110. static void LED1TaskCreate(void)
     ' H% ?: R- k% H
111. {
     2 G% z* G4 @- c5 t  X
112.         while(1)
     
113.         {
     ' h: L) f% A% W+ c5 H
114.                 UBaseType_t xReturn = pdPASS;
     
115.                
     1 c  y" m  C2 {6 Z
116.                 xReturn = xSemaphoreTake(SemaphCount_Handle,portMAX_DELAY);
     
117.                
     6 _' \0 E$ |9 W5 _
118.                 if(xReturn == pdTRUE)
     8 E# {7 j% `/ B' o% g$ C* a
119.                 {
     
120.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     " ~6 y# c4 y' z
121.                         f_printf("Counting Take PASS.\r\n");
     
122.                 }
     & C, T5 }/ b+ L$ |* \
123.                 else if(xReturn == errQUEUE_EMPTY)
     % f9 y' v, F* v/ l5 i
124.                         f_printf("semaphore is empty.\r\n");
     4 ]% e* x( W4 y" \9 E$ l0 M
125.                 vTaskDelay(2000);
     
126.         }
     * ^# g8 ^% r( _8 h
127. }
     : O( H1 f/ {1 N0 @. g3 i
128. /* USER CODE END 4 */
     1 d3 v" f, o' b  h. \* p0 y
129. 
     3 ]# }$ M" }4 |' R" B% K* U

复制代码

& U, u3 \5 A$ b7 r+ Z: U