FreeRTOS stm32f103c8t6 keil工程源码与开发手册下载

在STM32F103C8T6上移植FreeRTOSFreertos 移植到stm32F103ct6,参考的是《STM32F103 FreeRTOS开发手册V1.1.pdf》第6章实验2，实验中会创建两个应用任务task1_task和task2_task，当task1_task运行5次之后会删除task2_task，同时实现LED闪烁功能。考虑到C8T6的存储空间有限，未采用正点原子的FreeRTOSConfig.h文件！！

全部资料51hei下载地址：
FreeRTOS_ALL_6-2_180424-2115.rar (532.36 KB, 下载次数: 201)

2018-9-6 11:42 上传

点击文件名下载附件
STM32F103 FreeRTOS开发手册V1.1.pdf.7z (10.68 MB, 下载次数: 184)

2018-9-6 11:42 上传

点击文件名下载附件

单片机源程序如下:

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "timer.h"
   
6. #include "FreeRTOS.h"
   
7. #include "task.h"
   
8. 
   
9. 
   
10. /************************************************
    
11. ************************************************/
    
12. 
    
13. //空闲任务任务堆栈
    
14. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
    
15. //空闲任务控制块
    
16. static StaticTask_t IdleTaskTCB;
    
17. 
    
18. //定时器服务任务堆栈
    
19. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
    
20. //定时器服务任务控制块
    
21. static StaticTask_t TimerTaskTCB;
    
22. 
    
23. //任务优先级
    
24. #define START_TASK_PRIO                1
    
25. //任务堆栈大小       
    
26. #define START_STK_SIZE                 128  
    
27. //任务堆栈
    
28. StackType_t StartTaskStack[START_STK_SIZE];
    
29. //任务控制块
    
30. StaticTask_t StartTaskTCB;
    
31. //任务句柄
    
32. TaskHandle_t StartTask_Handler;
    
33. //任务函数
    
34. void start_task(void *pvParameters);
    
35. 
    
36. //任务优先级
    
37. #define TASK1_TASK_PRIO                2
    
38. //任务堆栈大小       
    
39. #define TASK1_STK_SIZE                 128  
    
40. //任务堆栈
    
41. StackType_t Task1TaskStack[TASK1_STK_SIZE];
    
42. //任务控制块
    
43. StaticTask_t Task1TaskTCB;
    
44. //任务句柄
    
45. TaskHandle_t Task1Task_Handler;
    
46. //任务函数
    
47. void task1_task(void *pvParameters);
    
48. 
    
49. //任务优先级
    
50. #define TASK2_TASK_PRIO                3
    
51. //任务堆栈大小       
    
52. #define TASK2_STK_SIZE                 128
    
53. //任务堆栈
    
54. StackType_t Task2TaskStack[TASK2_STK_SIZE];
    
55. //任务控制块
    
56. StaticTask_t Task2TaskTCB;
    
57. //任务句柄
    
58. TaskHandle_t Task2Task_Handler;
    
59. //任务函数
    
60. void task2_task(void *pvParameters);
    
61. 
    
62. 
    
63. //获取空闲任务地任务堆栈和任务控制块内存，因为本例程使用的
    
64. //静态内存，因此空闲任务的任务堆栈和任务控制块的内存就应该
    
65. //有用户来提供，FreeRTOS提供了接口函数vApplicationGetIdleTaskMemory()
    
66. //实现此函数即可。
    
67. //ppxIdleTaskTCBBuffer:任务控制块内存
    
68. //ppxIdleTaskStackBuffer:任务堆栈内存
    
69. //pulIdleTaskStackSize:任务堆栈大小
    
70. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
    
71.                                                                    StackType_t **ppxIdleTaskStackBuffer,
    
72.                                                                    uint32_t *pulIdleTaskStackSize)
    
73. {
    
74.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    
75.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    
76.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    
77. }
    
78. 
    
79. //获取定时器服务任务的任务堆栈和任务控制块内存
    
80. //ppxTimerTaskTCBBuffer:任务控制块内存
    
81. //ppxTimerTaskStackBuffer:任务堆栈内存
    
82. //pulTimerTaskStackSize:任务堆栈大小
    
83. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
    
84.                                                                         StackType_t **ppxTimerTaskStackBuffer,
    
85.                                                                         uint32_t *pulTimerTaskStackSize)
    
86. {
    
87.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    
88.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    
89.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    
90. }
    
91. 
    
92. 
    
93. int main(void)
    
94. {
    
95.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4                  
    
96.         delay_init();                                            //延时函数初始化          
    
97.         uart_init(115200);                                        //初始化串口
    
98.         LED_Init();                                                          //初始化LED
    
99.        
    
100.          
     
101.     printf("\r\n\r\n");
     
102.     printf("--------------------------------------------------------\r\n");
     
103.     printf("-- Welcome to FreeRTOS                                  \r\n");
     
104.     printf("--------------------------------------------------------\r\n");
     
105.        
     
106.     //创建开始任务
     
107.         StartTask_Handler=xTaskCreateStatic((TaskFunction_t        )start_task,                //任务函数
     
108.                                                                                 (const char*         )"start_task",                //任务名称
     
109.                                                                                 (uint32_t                 )START_STK_SIZE,        //任务堆栈大小
     
110.                                                                                 (void*                           )NULL,                                //传递给任务函数的参数
     
111.                                                                                 (UBaseType_t         )START_TASK_PRIO,         //任务优先级
     
112.                                                                                 (StackType_t*   )StartTaskStack,        //任务堆栈
     
113.                                                                                 (StaticTask_t*  )&StartTaskTCB);        //任务控制块              
     
114.     vTaskStartScheduler();          //开启任务调度
     
115. }
     
116. 
     
117. //开始任务任务函数
     
118. void start_task(void *pvParameters)
     
119. {
     
120.     taskENTER_CRITICAL();           //进入临界区
     
121.     //创建TASK1任务
     
122.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
     
123.                                                                                 (const char*         )"task1_task",               
     
124.                                                                                 (uint32_t                 )TASK1_STK_SIZE,       
     
125.                                                                                 (void*                           )NULL,                               
     
126.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,        
     
127.                                                                                 (StackType_t*   )Task1TaskStack,       
     
128.                                                                                 (StaticTask_t*  )&Task1TaskTCB);       
     
129.     //创建TASK2任务
     
130.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
     
131.                                                                                 (const char*         )"task2_task",               
     
132.                                                                                 (uint32_t                 )TASK2_STK_SIZE,       
     
133.                                                                                 (void*                           )NULL,                               
     
134.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,        
     
135.                                                                                 (StackType_t*   )Task2TaskStack,       
     
136.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
     
137.     vTaskDelete(StartTask_Handler); //删除开始任务
     
138.     taskEXIT_CRITICAL();            //退出临界区
     
139. }
     
140. //task1任务函数
     
141. void task1_task(void *pvParameters)
     
142. {
     
143.         u8 task1_num=0;
     
144.        
     
145.         while(1)
     
146.         {
     
147.                 task1_num++;        //任务执1行次数加1 注意task1_num1加到255的时候会清零！！
     
148.                 LED0=!LED0;
     
149.                 printf("任务1已经执行：%d次\r\n",task1_num);
     
150.                 if(task1_num==5)
     
151.                 {
     
152.                         if(Task2Task_Handler != NULL)                //任务2是否存在？       
     
153.                         {
     
154.                                 vTaskDelete(Task2Task_Handler);        //任务1执行5次删除任务2
     
155.                                 Task2Task_Handler=NULL;                        //任务句柄清零
     
156.                                 printf("任务1删除了任务2!\r\n");
     
157.                         }
     
158.                 }
     
159.                 vTaskDelay(1000);                           //延时1s，也就是1000个时钟节拍       
     
160.         }
     
161. }
     
162. 
     
163. //task2任务函数
     
164. void task2_task(void *pvParameters)
     
165. {
     
166.         u8 task2_num=0;
     
167.        
     
168.         while(1)
     
169.         {
     
170.                 task2_num++;        //任务2执行次数加1 注意task1_num2加到255的时候会清零！！
     
171.     LED1=!LED1;
     
172.                 printf("任务2已经执行：%d次\r\n",task2_num);
     
173.                 vTaskDelay(1000);                           //延时1s，也就是1000个时钟节拍       
     
174.         }
     
175. }
     

复制代码