1 概述
1.1 资源概述
开发板：正点原子STM32F103 Nano开发板
MDK版本：5.27
主控芯片型号：STM32F103RBT6



1.2 实现功能
本实验在STM32F103开发板上移植了FreeRTOS，版本为V9.0.0。例程中创建了5个任务来测试移植是否成功。
start_task任务创建其他4个测试任务
1 RTC_task：RTC的LCD液晶显示，串口打印任务
2 LED1_task：跑马灯任务函数
3 LED0Toggle_task：LED0闪烁任务函数，键盘扫描任务
4 BEEP_task 串口控制蜂鸣器任务

2 程序源码
在程序中建立5个Task，一个启动Task，4个应用Task。按键扫描使用队列，检测到对应按键时，执行相应的操作。串口通讯使用信号量，检测到字符串后控制LED灯的亮灭。另外有一个任务1S钟一次刷新LCD显示，显示时间。
主要代码借鉴了正点原子的程序，SPI屏幕商家提供的驱动以及最小系统版商家提供的驱动，由于RTOS这种系统的任务具有高内聚的特性。因此很容易将不同的任务移植到一起。

1. #include "led.h"
   
2. #include "delay.h"
   
3. #include "sys.h"
   
4. #include "FreeRTOS.h"
   
5. #include "task.h"
   
6. #include "LCD.h"
   
7. #include "gui.h"
   
8. #include "RTC_Time.h"
   
9. #include "queue.h"
   
10. #include "key.h"
    
11. #include "semphr.h"
    
12. #include "malloc.h"
    
13. 
    
14. 
    
15. 
    
16. //任务优先级
    
17. #define START_TASK_PRIO                1
    
18. //任务堆栈大小        
    
19. #define START_STK_SIZE                 50  
    
20. //任务句柄
    
21. TaskHandle_t StartTask_Handler;
    
22. //任务函数
    
23. void start_task(void *pvParameters);
    
24. 
    
25. //任务优先级
    
26. #define LED0Toggle_task_PRIO                4
    
27. //任务堆栈大小        
    
28. #define LED0Toggle_STK_SIZE                 50
    
29. //任务句柄
    
30. TaskHandle_t LED0ToggleTask_Handler;
    
31. //任务函数
    
32. void LED0Toggle_task(void *pvParameters);
    
33. 
    
34. //任务优先级
    
35. #define LED1_TASK_PRIO                3
    
36. //任务堆栈大小        
    
37. #define LED1_STK_SIZE                 128  
    
38. //任务句柄
    
39. TaskHandle_t LED1Task_Handler;
    
40. //任务函数
    
41. void LED1_task(void *pvParameters);
    
42. 
    
43. //任务优先级
    
44. #define RTC_TASK_PRIO                5
    
45. //任务堆栈大小        
    
46. #define RTC_STK_SIZE                 128  
    
47. //任务句柄
    
48. TaskHandle_t RTCTask_Handler;
    
49. //任务函数
    
50. void RTC_task(void *pvParameters);
    
51. 
    
52. //任务优先级
    
53. #define BEEP_TASK_PRIO                2
    
54. //任务堆栈大小        
    
55. #define BEEP_STK_SIZE                 128  
    
56. //任务句柄
    
57. TaskHandle_t BEEPTask_Handler;
    
58. //任务函数
    
59. void BEEP_task(void *pvParameters);
    
60. 
    
61. QueueHandle_t Key_Queue;                   //按键值消息队列句柄
    
62. #define KEYMSG_Q_NUM    1                  //按键消息队列的数量  
    
63. 
    
64. //二值信号量句柄
    
65. SemaphoreHandle_t BinarySemaphore;        //二值信号量句柄
    
66. 
    
67. //用于命令解析用的命令值
    
68. #define BEEPON        1
    
69. #define BEEPOFF        2
    
70. #define COMMANDERR        0XFF
    
71. 
    
72. //将字符串中的小写字母转换为大写
    
73. //str:要转换的字符串
    
74. //len：字符串长度
    
75. void LowerToCap(u8 *str,u8 len)
    
76. {
    
77.         u8 i;
    
78.         for(i=0;i<len;i++)
    
79.         {
    
80.                 if((96<str<i>)&&(str<i><123))        //小写字母
    
81.                 str<i>=str<i>-32;                                //转换为大写
    
82.         }
    
83. }
    
84. 
    
85. //命令处理函数，将字符串命令转换成命令值
    
86. //str：命令
    
87. //返回值: 0XFF，命令错误；其他值，命令值
    
88. u8 CommandProcess(u8 *str)
    
89. {
    
90.         u8 CommandValue=COMMANDERR;
    
91.         if(strcmp((char*)str,"BEEPON")==0) CommandValue=BEEPON;
    
92.         else if(strcmp((char*)str,"BEEPOFF")==0) CommandValue=BEEPOFF;
    
93.         return CommandValue;
    
94. }
    
95. 
    
96. int main(void)
    
97. {
    
98.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4                  
    
99.         delay_init();                                            //延时函数初始化         
    
100.         uart_init(115200);                                        //初始化串口
     
101.         LED_Init();                                                          //初始化LED
     
102.         KEY_Init();        //按键初始化
     
103.         LCD_Init();           //液晶屏初始化
     
104.     RTC_Init();        //RTC初始化
     
105.         printf("*******************************\r\n");
     
106.         printf("* WKUP_PRES Backward LED\r\n");
     
107.         printf("* KEY0_PRES Forward LED\r\n");
     
108.         printf("* KEY1_PRES ALL LED ON\r\n");
     
109.         printf("* KEY2_PRES ALL LED OFF\r\n");
     
110.         printf("* Uart send “BEEPON”:BEEP ON \r\n");
     
111.         printf("* Uart send “BEEPOFF”:BEEP OFF \r\n");        
     
112.         printf("*******************************\r\n");        
     
113.         //创建开始任务
     
114.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
     
115.                 (const char*    )"start_task",          //任务名称
     
116.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
     
117.                 (void*          )NULL,                  //传递给任务函数的参数
     
118.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
     
119.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
     
120.     vTaskStartScheduler();          //开启任务调度
     
121. }
     
122. 
     
123. //开始任务任务函数
     
124. void start_task(void *pvParameters)
     
125. {
     
126.     taskENTER_CRITICAL();           //进入临界区
     
127.     Key_Queue=xQueueCreate(KEYMSG_Q_NUM,sizeof(u8));        //创建消息Key_Queue
     
128.         //创建二值信号量
     
129.         BinarySemaphore=xSemaphoreCreateBinary();        
     
130.     //创建LED0任务
     
131.     xTaskCreate((TaskFunction_t )LED0Toggle_task,            
     
132.                 (const char*    )"LED0Toggle_task",           
     
133.                 (uint16_t       )LED0Toggle_STK_SIZE,
     
134.                 (void*          )NULL,                                
     
135.                 (UBaseType_t    )LED0Toggle_task_PRIO,        
     
136.                 (TaskHandle_t*  )&LED0ToggleTask_Handler);   
     
137.     //创建LCD任务
     
138.     xTaskCreate((TaskFunction_t )LED1_task,     
     
139.                 (const char*    )"LED1_task",   
     
140.                 (uint16_t       )LED1_STK_SIZE,
     
141.                 (void*          )NULL,
     
142.                 (UBaseType_t    )LED1_TASK_PRIO,
     
143.                 (TaskHandle_t*  )&LED1Task_Handler);
     
144.     xTaskCreate((TaskFunction_t )RTC_task,     
     
145.                 (const char*    )"RTC_task",   
     
146.                 (uint16_t       )RTC_STK_SIZE,
     
147.                 (void*          )NULL,
     
148.                 (UBaseType_t    )RTC_TASK_PRIO,
     
149.                 (TaskHandle_t*  )&RTCTask_Handler);   
     
150.     xTaskCreate((TaskFunction_t )BEEP_task,     
     
151.                 (const char*    )"BEEP_task",   
     
152.                 (uint16_t       )BEEP_STK_SIZE,
     
153.                 (void*          )NULL,
     
154.                 (UBaseType_t    )BEEP_TASK_PRIO,
     
155.                 (TaskHandle_t*  )&BEEPTask_Handler);                                   
     
156.     vTaskDelete(StartTask_Handler); //删除开始任务
     
157.     taskEXIT_CRITICAL();            //退出临界区
     
158. }
     
159. 
     
160. //LED0闪烁任务函数，提示程序正在运行，且为按键扫描程序，像队列发送信息
     
161. void LED0Toggle_task(void *pvParameters)
     
162. {
     
163.         u8 key,i=0;
     
164.     BaseType_t err;
     
165.         printf("LED0Toggle Task Running!\r\n");
     
166.         while(1)
     
167.         {
     
168.                 key=KEY_Scan(0);                    //扫描按键
     
169.         if((Key_Queue!=NULL)&&(key))           //消息队列Key_Queue创建成功,并且按键被按下
     
170.         {
     
171.             err=xQueueSend(Key_Queue,&key,10);
     
172.             if(err==errQUEUE_FULL)           //发送按键值
     
173.             {
     
174.                 printf("队列Key_Queue已满，数据发送失败!\r\n");
     
175.             }
     
176.         }
     
177.         i++;
     
178.         if(i==50)
     
179.         {
     
180.             i=0;
     
181.             LED0=!LED0;
     
182.         }
     
183.         vTaskDelay(10);   //延时10ms，也就是10个时钟节拍        
     
184.         }
     
185. }   
     
186. 
     
187. //跑马灯任务函数，使用按键控制灯的方向，以及控制灯的亮灭
     
188. void LED1_task(void *pvParameters)
     
189. {
     
190.          u8 key=0;
     
191.         printf("LED1 Task Running!\r\n");
     
192.         
     
193.         while(1)
     
194.         {
     
195.         if(Key_Queue!=NULL)
     
196.         {
     
197.             if(xQueueReceive(Key_Queue,&key,portMAX_DELAY))//请求消息Key_Queue
     
198.             {
     
199.                 switch(key)
     
200.                 {
     
201.                     case WKUP_PRES:                //KEY_UP控制流水灯方向，逆向
     
202.                                                 LED1=1;
     
203.                                                 LED7=0;
     
204.                                                 vTaskDelay(200);
     
205.                                                 LED7=1;
     
206.                                                 LED6=0;
     
207.                                                 vTaskDelay(200);
     
208.                                                 LED6=1;
     
209.                                                 LED5=0;
     
210.                                                 vTaskDelay(200);
     
211.                                                 LED5=1;
     
212.                                                 LED4=0;
     
213.                                                 vTaskDelay(200);
     
214.                                                 LED4=1;
     
215.                                                 LED3=0;
     
216.                                                 vTaskDelay(200);
     
217.                                                 LED3=1;
     
218.                                                 LED2=0;
     
219.                                                 vTaskDelay(200);        
     
220.                                                 LED2=1;
     
221.                                                 LED1=0;
     
222.                                                 vTaskDelay(200);
     
223.                         break;
     
224.                     case KEY0_PRES:                //KEY0控制LED灯方向，顺向
     
225.                                                 LED7=1;
     
226.                                                 LED1=0;
     
227.                                                 vTaskDelay(200);
     
228.                                                 LED1=1;
     
229.                                                 LED2=0;
     
230.                                                 vTaskDelay(200);
     
231.                                                 LED2=1;
     
232.                                                 LED3=0;
     
233.                                                 vTaskDelay(200);
     
234.                                                 LED3=1;
     
235.                                                 LED4=0;
     
236.                                                 vTaskDelay(200);
     
237.                                                 LED4=1;
     
238.                                                 LED5=0;
     
239.                                                 vTaskDelay(200);
     
240.                                                 LED5=1;
     
241.                                                 LED6=0;
     
242.                                                 vTaskDelay(200);        
     
243.                                                 LED6=1;
     
244.                                                 LED7=0;
     
245.                                                 vTaskDelay(200);
     
246.                         break;
     
247.                                         case KEY2_PRES:
     
248.                                                 LED1=1;LED2=1;LED3=1;LED4=1;LED5=1;LED6=1;LED7=1;//关闭所有LED灯
     
249.                                                 break;
     
250.                                         case KEY1_PRES:
     
251.                                                 LED1=0;LED2=0;LED3=0;LED4=0;LED5=0;LED6=0;LED7=0;//打开所有LED灯               
     
252.                                                 break;
     
253.                 }
     
254.             }
     
255.         }
     
256.                 vTaskDelay(10);      //延时10ms，也就是10个时钟节拍        
     
257.         }
     
258. }
     
259. //RTC的LCD液晶显示，串口打印任务，并在LCD上进行显示
     
260. void RTC_task(void *pvParameters)
     
261. {
     
262.     printf("RTC Task Running!\r\n");
     
263.         while(1)
     
264.     {
     
265.                 Time_Display();
     
266.                 vTaskDelay(1000);//每一秒钟刷新LED屏幕，显示时间
     
267.     }
     
268. }
     
269. 
     
270. //BEEP任务，通过串口发送数据控制蜂鸣器
     
271. void BEEP_task(void *pvParameters)
     
272. {
     
273.         u8 len=0;
     
274.         u8 CommandValue=COMMANDERR;
     
275.         BaseType_t err=pdFALSE;
     
276.         
     
277.         u8 *CommandStr;
     
278.         POINT_COLOR=BLUE;
     
279.     printf("BEEP Task Running!\r\n");
     
280.         while(1)
     
281.         {
     
282.                 if(BinarySemaphore!=NULL)
     
283.                 {
     
284.                         err=xSemaphoreTake(BinarySemaphore,portMAX_DELAY);        //获取信号量
     
285.                         if(err==pdTRUE)                                                                                //获取信号量成功
     
286.                         {
     
287.                                 len=USART_RX_STA&0x3fff;                                                //得到此次接收到的数据长度
     
288.                                 CommandStr=mymalloc(len+1);                                                //申请内存
     
289.                                 sprintf((char*)CommandStr,"%s",USART_RX_BUF);
     
290.                                 CommandStr[len]='\0';                                                        //加上字符串结尾符号
     
291.                                 LowerToCap(CommandStr,len);                                                //将字符串转换为大写               
     
292.                                 CommandValue=CommandProcess(CommandStr);                //命令解析
     
293.                                 if(CommandValue!=COMMANDERR)
     
294.                                 {
     
295.                                         printf("命令为:%s\r\n",CommandStr);
     
296.                                         switch(CommandValue)                                                //处理命令
     
297.                                         {
     
298.                                                 case BEEPON:
     
299.                                                         BEEP=0;
     
300.                                                         break;
     
301.                                                 case BEEPOFF:
     
302.                                                         BEEP=1;
     
303.                                                         break;
     
304.                                         }
     
305.                                 }
     
306.                                 else
     
307.                                 {
     
308.                                         printf("无效的命令，请重新输入!!\r\n");
     
309.                                 }
     
310.                                 USART_RX_STA=0;
     
311.                                 memset(USART_RX_BUF,0,USART_REC_LEN);                        //串口接收缓冲区清零
     
312.                                 myfree(CommandStr);                                                                //释放内存
     
313.                         }
     
314.                 }
     
315.                 else if(err==pdFALSE)
     
316.                 {
     
317.                         vTaskDelay(10);      //延时10ms，也就是10个时钟节拍        
     
318.                 }
     
319.         }
     
320. }              </i></i></i></i>

复制代码

LCD显示函数Time_Display如下

1. void Time_Display(void)
   
2. {
   
3.    struct tm time;
   
4.    char LCDTemp[100];
   
5.    time = Time_GetCalendarTime();
   
6.    printf("Time: %d-%d-%d   %02d:%02d:%02d \r\n", time.tm_year, \
   
7.                    time.tm_mon+1, time.tm_mday,\
   
8.                    time.tm_hour, time.tm_min, time.tm_sec);//打印到串口
   
9.         
   
10.         sprintf(LCDTemp,"Time: %d-%d-%d   %02d:%02d:%02d \r\n", time.tm_year, \
    
11.                    time.tm_mon+1, time.tm_mday,\
    
12.                    time.tm_hour, time.tm_min, time.tm_sec);//打印到字符串
    
13.         Show_Str(10,80,BLUE,YELLOW,LCDTemp,16,0);//显示字符串
    
14. }

复制代码

3 实验结果
打开串口，显示时间如下，每秒将时间打印到串口



LCD移植后效果图