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 "event_groups.h"
   
8. #include <stdio.h>
   
9. #include <string.h>
   
10. 
    
11. /* USER CODE END Includes */
    
12. 
    
13. /* USER CODE BEGIN PV */
    
14. static TaskHandle_t AppTask_Handle = NULL;
    
15. static TaskHandle_t KEY1Task_Handle = NULL;
    
16. static TaskHandle_t KEY2Task_Handle = NULL;
    
17. static TaskHandle_t LEDTask_Handle = NULL;
    
18. 
    
19. static EventGroupHandle_t KeyEventGroup_Handle = NULL;
    
20. 
    
21. static EventBits_t KeyEvent_Counting = 0;
    
22. 
    
23. extern int f_printf(const char *format, ...);
    
24. 
    
25. /* USER CODE END PV */
    
26. 
    
27. /* Private function prototypes -----------------------------------------------*/
    
28. void SystemClock_Config(void);
    
29. /* USER CODE BEGIN PFP */
    
30. 
    
31. static void AppTaskCreate(void);
    
32. static void Key1TaaskCreate(void);
    
33. static void Key2TaskCreate(void);
    
34. static void LedTaskCreate(void);
    
35. 
    
36. /* USER CODE END PFP */
    
37. 
    
38. int main()
    
39. {
    
40.   /*
    
41.    *
    
42.   */
    
43.   /* USER CODE BEGIN WHILE */
    
44.   UBaseType_t xReturn = xTaskCreate((TaskFunction_t)AppTaskCreate,
    
45.                                     (const char *) "APPTASKCREATE",
    
46.                                     (uint16_t)     128,
    
47.                                     (void *)       NULL,
    
48.                                     (UBaseType_t)  1,
    
49.                                     (TaskHandle_t*)&AppTask_Handle);
    
50.   if(xReturn != NULL)
    
51.         {
    
52.                 f_printf("APPTASK CREATE PASS.\r\n");
    
53.                 vTaskStartScheduler();
    
54.         }
    
55. 
    
56.   while (1)
    
57.   {
    
58.     /* USER CODE END WHILE */
    
59. 
    
60.     /* USER CODE BEGIN 3 */
    
61.   }
    
62.   /* USER CODE END 3 */
    
63. }
    
64. 
    
65. 
    
66. /* USER CODE BEGIN 4 */
    
67. static void AppTaskCreate(void)
    
68. {
    
69.         UBaseType_t xReturn = NULL;
    
70.         
    
71.         while(1)
    
72.         {               
    
73.                
    
74.       /* The event group must be created first, otherwise the task cannot be executed.*/
    
75.                 KeyEventGroup_Handle = xEventGroupCreate();
    
76. 
    
77.         xReturn = xTaskCreate((TaskFunction_t)Key1TaaskCreate,
    
78.                           (const char *)  "KEY1TASKCREATE",
    
79.                           (uint16_t)      128,
    
80.                           (void *)        NULL,
    
81.                           (UBaseType_t)   3,
    
82.                           (TaskHandle_t *)&KEY1Task_Handle);
    
83.         if(xReturn != NULL)
    
84.                         f_printf("KEY1TASK CREATE PASS.\r\n");
    
85.                
    
86.                 xReturn = xTaskCreate((TaskFunction_t)Key2TaskCreate,
    
87.                           (const char *)  "KEY2TASKCREATE",
    
88.                           (uint16_t)      128,
    
89.                           (void *)        NULL,
    
90.                           (UBaseType_t)   4,
    
91.                           (TaskHandle_t *)&KEY2Task_Handle);
    
92.         if(xReturn != NULL)
    
93.           f_printf("KEY2TASK CREATE PASS.\r\n");
    
94.                
    
95.                 xReturn = xTaskCreate((TaskFunction_t)LedTaskCreate,
    
96.                           (const char *)  "LEDTASKCREATE",
    
97.                           (uint16_t)      128,
    
98.                           (void *)        NULL,
    
99.                           (UBaseType_t)   1,
    
100.                           (TaskHandle_t *)&LEDTask_Handle);
     
101.                
     
102.         if(KeyEventGroup_Handle != NULL)
     
103.                 {
     
104.                         f_printf("KEY EVENTGROUP CREATE PASS.\r\n");
     
105.                         vTaskDelete((TaskHandle_t)AppTask_Handle);
     
106.                 }               
     
107.         }
     
108. }
     
109. 
     
110. 
     
111. static void Key1TaaskCreate(void)
     
112. {
     
113.         while(1)
     
114.         {
     
115.                 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     
116.                 {
     
117.                         vTaskDelay(40);
     
118.                         if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0))
     
119.                         {
     
120.                                 xEventGroupSetBits(KeyEventGroup_Handle,0x01);
     
121.                         }
     
122.                 }
     
123.                
     
124.     vTaskDelay(100);
     
125.         }
     
126. }
     
127. static void Key2TaskCreate(void)
     
128. {
     
129.         while(1)
     
130.         {
     
131.                 if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12)==0)
     
132.                 {
     
133.                         vTaskDelay(40);
     
134.                   if(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_12)==0)
     
135.                         {
     
136.                                 xEventGroupSetBits(KeyEventGroup_Handle,0x2);
     
137.                         }
     
138.                 }
     
139.                 vTaskDelay(100);
     
140.         }
     
141. }
     
142. 
     
143. 
     
144. static void LedTaskCreate(void)
     
145. {
     
146.         while(1)
     
147.         {
     
148.                 KeyEvent_Counting = xEventGroupWaitBits ( KeyEventGroup_Handle, 0x1, pdTRUE, pdTRUE, 10);
     
149.                
     
150.                 if((KeyEvent_Counting & 0x01) == 0x01)
     
151.                 {
     
152.                         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,GPIO_PIN_RESET);
     
153.                         vTaskDelay(200);
     
154.                         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,GPIO_PIN_SET);
     
155.                 }
     
156.                 KeyEvent_Counting = xEventGroupWaitBits ( KeyEventGroup_Handle, 0x2, pdTRUE, pdTRUE, 10);
     
157.                 if((KeyEvent_Counting & 0x02)==0x02)
     
158.                 {
     
159.                         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_2,GPIO_PIN_RESET);
     
160.                         vTaskDelay(200);
     
161.                         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_2,GPIO_PIN_SET);
     
162.                 }
     
163.                 KeyEvent_Counting = xEventGroupWaitBits ( KeyEventGroup_Handle, 0x3, pdTRUE, pdTRUE, 10);
     
164.                 if((KeyEvent_Counting &0x03)==0x03)
     
165.                 {
     
166.                         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_2|GPIO_PIN_1,GPIO_PIN_RESET);
     
167.                         vTaskDelay(200);
     
168.                         HAL_GPIO_WritePin(GPIOB,GPIO_PIN_2|GPIO_PIN_1,GPIO_PIN_SET);
     
169.                         xEventGroupClearBits(KeyEventGroup_Handle,0x03);
     
170.                 }
     
171.                
     
172.                 vTaskDelay(50);
     
173.         }
     
174. }
     
175. 
     
176. /* USER CODE END 4 */

复制代码

————————————————
版权声明：SCCELE