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

2.修改main.c文件

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   
5. #include "queue.h"
   
6. #include "semphr.h"
   
7. #include <stdio.h>
   
8. #include <string.h>
   
9. 
   
10. /* USER CODE END Includes */
    
11. /* USER CODE BEGIN PV */
    
12. 
    
13. static TaskHandle_t AppTaskCreate_Handle = NULL;
    
14. static TaskHandle_t KeyTask_Handle = NULL;
    
15. static TaskHandle_t Led1Task_Handle = NULL;
    
16. 
    
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 */
    
24. 
    
25. /*Create a task function*/
    
26. static void AppTaskCreate(void);
    
27. static void KeyTaskCreate(void);
    
28. static void Led1TaskCreate(void);
    
29. 
    
30. /* USER CODE END PFP */
    
31. 
    
32. int main()
    
33. {
    
34.   /*
    
35.   *
    
36.   */
    
37.   /* USER CODE BEGIN WHILE */
    
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.         {
    
48.                 vTaskStartScheduler();
    
49.                 f_printf("start..\r\n");
    
50.         }
    
51.   while (1)
    
52.   {
    
53.     /* USER CODE END WHILE */
    
54. 
    
55.     /* USER CODE BEGIN 3 */
    
56.   }
    
57.   /* USER CODE END 3 */
    
58. 
    
59. 
    
60. }
    
61. 
    
62. 
    
63. /* USER CODE BEGIN 4 */
    
64. static void AppTaskCreate(void)
    
65. {
    
66.   UBaseType_t xReturn = pdPASS;
    
67. 
    
68. 
    
69.   xReturn = xTaskCreate((TaskFunction_t) KeyTaskCreate,
    
70.                              (const char *)   "KEYTASKCREATE",
    
71.                                                  (uint16_t)       128,
    
72.                                                  (void *)         NULL,
    
73.                                                  (UBaseType_t )   2,
    
74.                                                  (TaskHandle_t *) &KeyTask_Handle);
    
75. 
    
76.   xReturn = xTaskCreate((TaskFunction_t) Led1TaskCreate,
    
77.                                                 (const char *)   "LED1TASKCREATE",
    
78.                                                 (uint16_t)       128,
    
79.                                                 (void *)         NULL,
    
80.                                                 (UBaseType_t)    1,
    
81.                                                 (TaskHandle_t *)&Led1Task_Handle);
    
82.         
    
83.     /*Create a binary semaphore*/
    
84.         Binary_Handle = xSemaphoreCreateBinary();
    
85.         if(Binary_Handle !=NULL)
    
86.                 f_printf("Create Semph_Binary PASS.\r\n");
    
87.         
    
88.         if(xReturn == pdPASS)
    
89.     vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);               
    
90. }
    
91. 
    
92. static void KeyTaskCreate(void)
    
93. {
    
94.   while(1)
    
95.         {
    
96.                 UBaseType_t xReturn = pdPASS;
    
97.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
98.                 {
    
99.                         f_printf("KEY TASK PASS.\r\n");
    
100.                         vTaskDelay(100);
     
101.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     
102.                         {
     
103.                                 xReturn = xSemaphoreGive(Binary_Handle);
     
104.                                 if(xReturn == pdPASS)
     
105.                                         f_printf("GIVE BINARY PASS.\r\n");
     
106.                                 else if(xReturn == errQUEUE_FULL)
     
107.                                         f_printf("QUEUE IS FULL.\r\n");
     
108.                         }
     
109.                 }
     
110.                
     
111.     vTaskDelay(100);
     
112.         }
     
113. 
     
114. }
     
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");
     
125.                         HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_2);
     
126.                 }
     
127.                
     
128.           vTaskDelay(100);
     
129.         }
     
130. }
     
131. 
     
132. /* USER CODE END 4 */

复制代码

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

2.修改main.c文件

1. /* USER CODE BEGIN Includes */
   
2. 
   
3. #include "FreeRTOS.h"
   
4. #include "task.h"
   
5. #include "queue.h"
   
6. #include "semphr.h"
   
7. #include <stdio.h>
   
8. #include <string.h>
   
9. 
   
10. /* USER CODE END Includes */
    
11. /* USER CODE BEGIN PV */
    
12. static TaskHandle_t AppTaskCreate_Handle = NULL;
    
13. static TaskHandle_t KeyTask_Handle = NULL;
    
14. static TaskHandle_t Led1_Handle = NULL;
    
15. 
    
16. SemaphoreHandle_t SemaphCount_Handle = NULL;
    
17. 
    
18. extern int f_printf(const char *format, ...);
    
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 */
    
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,
    
39.                                                                         (void *)      NULL,
    
40.                                                                         (UBaseType_t) 2,
    
41.                                                                         (TaskHandle_t *)&AppTaskCreate_Handle);
    
42.         if(xReturn ==pdPASS)
    
43.         {
    
44.                 f_printf("TASK START.\r\n");
    
45.                 vTaskStartScheduler();
    
46.         }
    
47.   while (1)
    
48.   {
    
49.     /* USER CODE END WHILE */
    
50. 
    
51.     /* USER CODE BEGIN 3 */
    
52.   }
    
53.   /* USER CODE END 3 */
    
54. }
    
55. 
    
56. /* USER CODE BEGIN 4 */
    
57. static void AppTaskCreate(void)
    
58. {
    
59. 
    
60.   UBaseType_t xReturn ;
    
61.         xReturn = xTaskCreate((TaskFunction_t)KeyTaskCreate,
    
62.                                     (const char *) "KEYTASKCREATE",
    
63.                                     (uint16_t)      128,
    
64.                                                                         (void *)       NULL,
    
65.                                                                         (UBaseType_t)   2,
    
66.                                                                         (TaskHandle_t*)&KeyTask_Handle);
    
67.   if(xReturn == pdPASS)
    
68.                 f_printf("KEY CREATE PASS.\r\n");
    
69. 
    
70.   xReturn = xTaskCreate((TaskFunction_t)LED1TaskCreate,
    
71.                                                 (const char *)  "LED1TASKCREATE",
    
72.                                                 (uint16_t)      128,
    
73.                                                 (void *)        NULL,
    
74.                                                 (UBaseType_t)   1,
    
75.                                                 (TaskHandle_t*)&Led1_Handle);
    
76. 
    
77.         SemaphCount_Handle = xSemaphoreCreateCounting(3,0);
    
78.         if(SemaphCount_Handle != NULL)
    
79.                 f_printf("SEMAPHORE COUNT CREATE PASS.\r\n");
    
80.         
    
81.   if(xReturn == pdPASS)
    
82.         {
    
83.                 f_printf("LED CREATE PASS.\r\n");        
    
84.                 vTaskDelete((TaskHandle_t)AppTaskCreate_Handle);
    
85.         }
    
86. }
    
87. 
    
88. 
    
89. static void KeyTaskCreate(void)
    
90. {
    
91.   while(1)
    
92.         {
    
93.                 UBaseType_t xReturn = pdPASS;
    
94.     if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
95.                 {
    
96.                         vTaskDelay(100);
    
97.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
    
98.                         {
    
99.                                 f_printf("KEY PRESS.\r\n");
    
100.                                 xReturn = xSemaphoreGive(SemaphCount_Handle);
     
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");
     
105.                         }
     
106.                 }               
     
107.                 vTaskDelay(10);
     
108.         }
     
109. }
     
110. static void LED1TaskCreate(void)
     
111. {
     
112.         while(1)
     
113.         {
     
114.                 UBaseType_t xReturn = pdPASS;
     
115.                
     
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.                 }
     
123.                 else if(xReturn == errQUEUE_EMPTY)
     
124.                         f_printf("semaphore is empty.\r\n");
     
125.                 vTaskDelay(2000);
     
126.         }
     
127. }
     
128. /* USER CODE END 4 */
     
129. 
     

复制代码