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

8 D0 z+ n5 Q. e6 c" t3 K2.修改main.c文件
0 I" v. z# c/ H9 H$ A

1. /* USER CODE BEGIN Includes */
   2 V5 y  T0 j+ G  d  N+ l8 X
2. 
   , [1 }" p1 a& B" E! u* @2 ~
3. #include "FreeRTOS.h"
   4 P( V% y6 }; e( ^2 }
4. #include "task.h"
   
5. #include "queue.h"
   $ H- b; y7 E  g( h/ A, t' E
6. #include "semphr.h"
   $ }$ D  c4 Q$ x. P* ~6 y3 H' v4 o
7. #include <stdio.h>
   # Q- p, {! r( G, y' ?
8. #include <string.h>
   3 v; B+ \, U/ ^7 c7 [# ~% V
9. 
   
10. /* USER CODE END Includes */
    
11. /* USER CODE BEGIN PV */
    
12. 
    
13. static TaskHandle_t AppTaskCreate_Handle = NULL;
    / o0 Z; O- t+ E$ }! c: K
14. static TaskHandle_t KeyTask_Handle = NULL;
    ; l% ?% A% b: Q# w0 L
15. static TaskHandle_t Led1Task_Handle = NULL;
    
16. 
    
17. /*Create a binary semaphore handle*/
    / c3 a; ?" k- M) g2 D8 K, ^
18. static SemaphoreHandle_t Binary_Handle = NULL;
    
19. 
    ! @4 t' c  u1 W
20. extern int f_printf(const char *format, ...);
    6 O. N/ g  n) r$ I
21. 
    
22. /* USER CODE END PV */
    
23. /* USER CODE BEGIN PFP */
    
24. 
    ! O# D8 O4 t3 `8 i+ F9 ~
25. /*Create a task function*/
    
26. static void AppTaskCreate(void);
    9 k; @6 |, c; A( N3 M
27. static void KeyTaskCreate(void);
    % v% x6 Z, O+ u, T8 Z
28. static void Led1TaskCreate(void);
    " ]  \! d$ `# V
29. 
    $ d! t9 Y7 F' C$ T( d
30. /* USER CODE END PFP */
    
31. 
    5 v& `: \4 U- A, a2 r5 K
32. int main()
    * C  S1 K1 U6 _+ E
33. {
    , ]3 H, V0 v) k# b; p
34.   /*
    
35.   *
    
36.   */
    
37.   /* USER CODE BEGIN WHILE */
    
38.   UBaseType_t xReturn = pdPASS;
    4 x; t' e/ P3 G. R1 c" P; c; o
39.         
    ) O6 f3 {- p8 e( Z( l
40.         xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
41.                               (const char *) "APPTASKCREATE",
    
42.                                                   (uint16_t)     128,
    
43.                                                   (void *)       NULL,
    ) r9 N, A. A" P8 f
44.                                                   (UBaseType_t)  2,
    
45.                                                   (TaskHandle_t *)&AppTaskCreate_Handle);
    ! Q" K) [4 ~0 b; Z. Z
46.   if(xReturn ==pdPASS)
    
47.         {
    4 a; [* b, h( W# h2 u5 I- V! U
48.                 vTaskStartScheduler();
    
49.                 f_printf("start..\r\n");
    ! [8 k7 i' H: G
50.         }
    
51.   while (1)
    / M, F9 L8 P8 h9 W
52.   {
    ; N' \6 u' q( V# [/ i9 I1 s
53.     /* USER CODE END WHILE */
    8 h7 _6 v$ _3 c# e0 y2 J
54. 
    
55.     /* USER CODE BEGIN 3 */
    
56.   }
    5 U  i' v& h! l  Y4 c
57.   /* USER CODE END 3 */
    
58. 
    
59. 
    3 [1 Z  C) _7 C) x% F$ ?
60. }
    
61. 
    2 x7 B' A! j& _1 _4 [0 D
62. 
    " {) [  M. I" u) a- c
63. /* USER CODE BEGIN 4 */
    
64. static void AppTaskCreate(void)
    
65. {
    " W3 _  X1 ?. }  s/ E6 \/ Q7 u
66.   UBaseType_t xReturn = pdPASS;
    
67. 
    . r1 T, b5 E) u- c
68. 
    # n! W. P" v3 K
69.   xReturn = xTaskCreate((TaskFunction_t) KeyTaskCreate,
    % `, ~  T) i- q) ^
70.                              (const char *)   "KEYTASKCREATE",
    
71.                                                  (uint16_t)       128,
    
72.                                                  (void *)         NULL,
    , w+ V! V. p4 c3 t% V7 X5 d+ ~. j  q
73.                                                  (UBaseType_t )   2,
    . h8 R& V% g8 ~6 s4 P
74.                                                  (TaskHandle_t *) &KeyTask_Handle);
    
75. 
    $ H6 ?: N0 E$ I$ d7 {1 m
76.   xReturn = xTaskCreate((TaskFunction_t) Led1TaskCreate,
    
77.                                                 (const char *)   "LED1TASKCREATE",
    
78.                                                 (uint16_t)       128,
    
79.                                                 (void *)         NULL,
    , c6 l' L: _" ~' G5 b
80.                                                 (UBaseType_t)    1,
    & x7 e* d) [* o) W$ v
81.                                                 (TaskHandle_t *)&Led1Task_Handle);
    ' V6 t4 w& Y# f
82.         
    
83.     /*Create a binary semaphore*/
      c! q3 Q- J1 }
84.         Binary_Handle = xSemaphoreCreateBinary();
    
85.         if(Binary_Handle !=NULL)
    + S! p+ `/ c. p  b# X& T
86.                 f_printf("Create Semph_Binary PASS.\r\n");
    
87.         
    
88.         if(xReturn == pdPASS)
    ) h! ~8 C& H+ Z. P0 a7 F0 T: Z
89.     vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);               
    
90. }
    
91. 
    - t0 {* i) _& O6 Y+ j
92. static void KeyTaskCreate(void)
    
93. {
    + l' o4 m  j" W# V, E" a2 ^, F
94.   while(1)
    5 N+ G" H. d2 p$ g$ Z  A" i: d
95.         {
    * m- X. {5 a' ~
96.                 UBaseType_t xReturn = pdPASS;
    1 Z% t9 q( ^% z0 R
97.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
98.                 {
    0 f4 `' F9 S7 c- {& o
99.                         f_printf("KEY TASK PASS.\r\n");
    
100.                         vTaskDelay(100);
     
101.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     7 m5 u# g9 R% T) j8 D
102.                         {
     5 [: J+ C7 e4 Z6 L- V5 U
103.                                 xReturn = xSemaphoreGive(Binary_Handle);
     $ @( ]( v, V3 A5 q4 O2 l
104.                                 if(xReturn == pdPASS)
     
105.                                         f_printf("GIVE BINARY PASS.\r\n");
     
106.                                 else if(xReturn == errQUEUE_FULL)
     9 U8 ~: B7 W3 C% Z8 E: ]1 W) ]- C
107.                                         f_printf("QUEUE IS FULL.\r\n");
     . f& C) \+ Y8 Z% m2 T5 M
108.                         }
     
109.                 }
     
110.                
     
111.     vTaskDelay(100);
     : v/ \) F+ ~+ i3 O6 d
112.         }
     
113. 
     
114. }
     ' j' ^1 t) X) I$ w* r
115. static void Led1TaskCreate(void)
     
116. {
     
117.   while(1)
     
118.         {
     
119.                 UBaseType_t xReturn = pdPASS;
     
120.                
     6 C# B0 f; ?( s' S
121.                 xReturn = xSemaphoreTake(Binary_Handle, portMAX_DELAY);
     
122.                 if(xReturn == pdPASS)
     3 }; h6 _8 _5 K; f
123.                 {
     
124.                         f_printf("TAKE BINARY PASS.\r\n");
     
125.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     0 P$ G7 z* O" D- r
126.                 }
       J& M+ m; Z: f( ]
127.                
     
128.           vTaskDelay(100);
     ' E: L) x6 j# X3 U7 P
129.         }
     
130. }
     
131. 
     
132. /* USER CODE END 4 */

复制代码

/ }! P. s. ]7 e) f* Q. X计数信号量的用法示例
1.创建好带有printf-stdarg.c的FreeRTOS的工程
) W" q: u& y4 j$ e  T1 Z
2.修改main.c文件
! ]8 E: w4 h! ~% `  T: X
) k; A5 e( P/ y/ n. t/ c) m0 b2 W

1. /* USER CODE BEGIN Includes */
   . G( X) @4 |6 b2 Q* F3 G' A
2. 
   $ Q1 E9 B7 w0 U) [
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   3 O! t) I8 w1 J8 b2 {5 C
5. #include "queue.h"
   
6. #include "semphr.h"
   
7. #include <stdio.h>
   
8. #include <string.h>
   
9. 
   1 C& U$ [7 q1 W! s7 z
10. /* USER CODE END Includes */
    
11. /* USER CODE BEGIN PV */
    , G0 g, z8 ~( q
12. static TaskHandle_t AppTaskCreate_Handle = NULL;
    
13. static TaskHandle_t KeyTask_Handle = NULL;
    , E5 e; O+ A+ R/ S& e: }# A- p0 R
14. static TaskHandle_t Led1_Handle = NULL;
    
15. 
    
16. SemaphoreHandle_t SemaphCount_Handle = NULL;
    
17. 
    : _9 C$ e! V- S! |9 f: f; l
18. extern int f_printf(const char *format, ...);
    
19. 
    
20. /* USER CODE END PV */
    ! o2 j, e$ F' S) ?
21. 
    
22. /* USER CODE BEGIN PFP */
    ! Y: D9 k7 T5 c) c- [# N  ~
23. 
    : O! X* i' P& O  L  i( }7 E- j
24. static void AppTaskCreate(void);
    
25. static void KeyTaskCreate(void);
    + s. y9 ~- }9 l: [' w  j
26. static void LED1TaskCreate(void);
    
27. 
    ! ?9 E1 ?0 C) p% b3 y& W( e
28. /* USER CODE END PFP */
    
29. 
    
30. int main()
    - p( v7 V) t' k: d
31. {
    & I, r# m# }- B3 d
32.   ***
    * }" K5 L7 f4 H2 w. A
33. 
    
34.   /* USER CODE BEGIN WHILE */
    
35. 
    . b9 ]  n4 M5 s- i  A3 o
36.   UBaseType_t xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    $ W6 M3 O3 e& o( u5 A/ o
37.                                     (const char *)"APPTASKCREATE",
    , s- G9 N7 D$ U
38.                                                                         (uint16_t)    128,
    
39.                                                                         (void *)      NULL,
    
40.                                                                         (UBaseType_t) 2,
    ! J) g% L5 G4 i/ V9 F
41.                                                                         (TaskHandle_t *)&AppTaskCreate_Handle);
    + k, z) U3 A/ \) B& w( R
42.         if(xReturn ==pdPASS)
    
43.         {
    8 u. ]; P# h/ @7 ?1 g7 ]
44.                 f_printf("TASK START.\r\n");
    
45.                 vTaskStartScheduler();
    ) r- D5 W1 P  [# L8 p
46.         }
    ; O9 I+ q0 L/ i9 W, i3 F
47.   while (1)
    : X' T# }( i- H7 |
48.   {
    
49.     /* USER CODE END WHILE */
    
50. 
    
51.     /* USER CODE BEGIN 3 */
    
52.   }
    6 K1 U# g/ z& v+ Z/ s- Y: H
53.   /* USER CODE END 3 */
    
54. }
    
55. 
    
56. /* USER CODE BEGIN 4 */
    
57. static void AppTaskCreate(void)
    
58. {
    * {( ^: V/ k& l3 T! O, r( z
59. 
    2 ~7 a5 a4 w3 T) k: f; S& O* [
60.   UBaseType_t xReturn ;
    
61.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
62.                                     (const char *) "KEYTASKCREATE",
    
63.                                     (uint16_t)      128,
    * l- `% w: ]# B4 w
64.                                                                         (void *)       NULL,
    
65.                                                                         (UBaseType_t)   2,
    
66.                                                                         (TaskHandle_t*)&KeyTask_Handle);
    1 m+ |8 \) c; r4 z9 A1 T1 r8 A; e
67.   if(xReturn == pdPASS)
    
68.                 f_printf("KEY CREATE PASS.\r\n");
    
69. 
    ; D9 P- p5 s; m% h5 m
70.   xReturn = xTaskCreate((TaskFunction_t)LED1TaskCreate,
    
71.                                                 (const char *)  "LED1TASKCREATE",
    
72.                                                 (uint16_t)      128,
    9 X6 x' p7 ]8 N& T
73.                                                 (void *)        NULL,
      U+ @* g- ?- w! T6 l
74.                                                 (UBaseType_t)   1,
    - j# S0 X! M  d$ j* a- E# C
75.                                                 (TaskHandle_t*)&Led1_Handle);
    : h) _7 a3 ?" c
76. 
    " ^; W3 ~; I% h3 S9 Y7 g
77.         SemaphCount_Handle = xSemaphoreCreateCounting(3,0);
      f/ }0 Y# V( v6 P$ S
78.         if(SemaphCount_Handle != NULL)
    
79.                 f_printf("SEMAPHORE COUNT CREATE PASS.\r\n");
    & Y0 k1 [* X7 |" p9 j
80.         
    ( y# F, R( C: `  J1 [! J  D
81.   if(xReturn == pdPASS)
    
82.         {
    ' i( M4 `$ w$ k
83.                 f_printf("LED CREATE PASS.\r\n");        
    
84.                 vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);
    
85.         }
    
86. }
    
87. 
    
88. 
    4 h" F: F% v$ `. Y6 ~
89. static void KeyTaskCreate(void)
    3 r  Z4 r8 }+ M* [# a
90. {
    : q+ {# x) C2 y$ Y9 f8 u
91.   while(1)
      k4 t% o% S& P* s1 L
92.         {
    
93.                 UBaseType_t xReturn = pdPASS;
    ! Q# V5 [: d' L& C% i. r( f* T
94.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
95.                 {
    . l; o* ~' `' J4 S; L
96.                         vTaskDelay(100);
    % [% b& x/ [8 d1 V- H! D' L
97.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
98.                         {
    % B/ s9 L+ z' w. T7 g
99.                                 f_printf("KEY PRESS.\r\n");
    + f1 i3 a1 S/ S$ H
100.                                 xReturn = xSemaphoreGive(SemaphCount_Handle);
     
101.                                 if(xReturn == pdPASS)
     
102.                                         f_printf("GIVE COUNTING PASS.\r\n");
     
103.                                 else if(xReturn == errQUEUE_FULL)
     3 Q9 W( I- E9 `8 V! V/ `
104.                                         f_printf("QUEUE IS FULL.\r\n");
     
105.                         }
     
106.                 }               
     % \3 P1 [7 c( G0 M
107.                 vTaskDelay(10);
     ) Y) H3 h; V6 l  D( a
108.         }
     4 u! z0 a% g) F, b
109. }
     " i4 Z9 a' L3 I& U
110. static void LED1TaskCreate(void)
     3 U! A: t8 ^) `  z+ U
111. {
     & G. ?( ]9 `: t1 Z/ V
112.         while(1)
     
113.         {
     : Z! t3 n* f9 \' ]" L
114.                 UBaseType_t xReturn = pdPASS;
     
115.                
     
116.                 xReturn = xSemaphoreTake(SemaphCount_Handle,portMAX_DELAY);
       a' H3 t+ _9 ?
117.                
     
118.                 if(xReturn == pdTRUE)
     
119.                 {
     ) [5 N$ T  c/ G
120.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_1);
     ' F8 z6 C$ u- N+ N9 b- o
121.                         f_printf("Counting Take PASS.\r\n");
     
122.                 }
     4 {* P  Z# o  E$ T' V4 s
123.                 else if(xReturn == errQUEUE_EMPTY)
     % I4 r1 s5 h1 {
124.                         f_printf("semaphore is empty.\r\n");
     5 W5 f  B. n/ l( g
125.                 vTaskDelay(2000);
     
126.         }
     7 r) i, R& L# O6 v  q$ B/ w
127. }
     
128. /* USER CODE END 4 */
     ( U& z. P# t4 G6 R
129. 
     

复制代码

+ q. q: M' E3 W& ^, l: R! `( y2 B# _