1 概述
1.1 资源概述
# o& }7 h4 N2 P5 E* y  P开发板：正点原子STM32F103 Nano开发板
MDK版本：5.27
主控芯片型号：STM32F103RBT6

+ p: _5 ?3 T, I" v  g( i. N7 p
/ g% b) m" t3 O- B! ?" v9 X+ y( K
7 B( B& U+ M* R8 E/ h  p* d1.2 实现功能
3 X8 W! g, y' a, A- z6 |2 D* y本实验在STM32F103开发板上移植了FreeRTOS，版本为V9.0.0。例程中创建了5个任务来测试移植是否成功。
start_task任务创建其他4个测试任务
4 {& E( }# c2 t' D# K; {1 RTC_task：RTC的LCD液晶显示，串口打印任务
5 h: O6 u9 i8 `5 s. z2 LED1_task：跑马灯任务函数
+ j0 Y4 u, Q/ A2 X+ R3 LED0Toggle_task：LED0闪烁任务函数，键盘扫描任务
4 BEEP_task 串口控制蜂鸣器任务
) S8 Q- C! W" o& u$ g# W6 O
2 程序源码
在程序中建立5个Task，一个启动Task，4个应用Task。按键扫描使用队列，检测到对应按键时，执行相应的操作。串口通讯使用信号量，检测到字符串后控制LED灯的亮灭。另外有一个任务1S钟一次刷新LCD显示，显示时间。
主要代码借鉴了正点原子的程序，SPI屏幕商家提供的驱动以及最小系统版商家提供的驱动，由于RTOS这种系统的任务具有高内聚的特性。因此很容易将不同的任务移植到一起。
) U* Y  x! M! ^
) c- K1 S8 a+ k' W, S" V

1. #include "led.h"
   
2. #include "delay.h"
   
3. #include "sys.h"
   
4. #include "FreeRTOS.h"
   ! r! C0 S& i; g( {5 c/ Y- K
5. #include "task.h"
   
6. #include "LCD.h"
   
7. #include "gui.h"
   
8. #include "RTC_Time.h"
   / F5 D' v+ Y/ M' N
9. #include "queue.h"
   8 ?( ^  l# z6 B% {
10. #include "key.h"
    
11. #include "semphr.h"
    2 X6 ~- `+ p. n: O. E  F2 S
12. #include "malloc.h"
    0 u' D6 P. s+ v) x
13. 
    
14. 
    3 n/ B, M# d, r- t
15. 
    4 \: ~5 y% _3 }  L; U, m% G) U
16. //任务优先级
    ( [4 N+ x/ V2 n
17. #define START_TASK_PRIO                1
    9 T5 E& }7 y. D* b9 f$ |. k
18. //任务堆栈大小        
    
19. #define START_STK_SIZE                 50  
    2 r2 W9 n" f; _$ L
20. //任务句柄
    $ r, x. S0 J' [6 q0 ^' j9 v
21. TaskHandle_t StartTask_Handler;
    . t* z) `/ K2 n& @( l
22. //任务函数
    & g6 V  l4 y2 {' }
23. void start_task(void *pvParameters);
    
24. 
    7 u% Z' a7 Y1 c# t+ T% O
25. //任务优先级
    , d$ s1 C* M3 ]6 z8 k0 g* a8 {
26. #define LED0Toggle_task_PRIO                4
      e% l- ~: g  q8 [! T& E( }
27. //任务堆栈大小        
    & {/ [8 U+ ?) D  x: F, F$ j: s& E
28. #define LED0Toggle_STK_SIZE                 50
    
29. //任务句柄
    1 A' x$ Z6 y: ?5 b8 R" a; x
30. TaskHandle_t LED0ToggleTask_Handler;
    
31. //任务函数
    $ N5 f; X' ^% k5 q
32. void LED0Toggle_task(void *pvParameters);
    
33. 
    
34. //任务优先级
    
35. #define LED1_TASK_PRIO                3
    
36. //任务堆栈大小        
    
37. #define LED1_STK_SIZE                 128  
    - e% m+ ?0 q. V5 \3 ^- s
38. //任务句柄
    9 W/ I) V9 M9 J* {( {1 N1 m) Y
39. TaskHandle_t LED1Task_Handler;
    
40. //任务函数
    
41. void LED1_task(void *pvParameters);
    8 b7 d! b' N5 b
42. 
    
43. //任务优先级
    
44. #define RTC_TASK_PRIO                5
    
45. //任务堆栈大小        
    
46. #define RTC_STK_SIZE                 128  
    
47. //任务句柄
    ( F9 |' p  A& v
48. TaskHandle_t RTCTask_Handler;
    / U" p* X3 G" d- r# \; O
49. //任务函数
    2 @5 V. p* X: C/ F
50. void RTC_task(void *pvParameters);
    / h2 H$ y5 \; a. O" d9 V4 O8 o  b. i  R
51. 
    
52. //任务优先级
    
53. #define BEEP_TASK_PRIO                2
    ; H. G3 w7 B' e
54. //任务堆栈大小        
    3 i; B$ C4 e5 q6 ]' E# [
55. #define BEEP_STK_SIZE                 128  
    $ f) Z0 d1 U" ~5 P5 R* y/ S" W. H, G
56. //任务句柄
    7 b: z7 u! h% D0 |
57. TaskHandle_t BEEPTask_Handler;
    
58. //任务函数
    " p% h0 c8 b: i& k/ V( k( A
59. void BEEP_task(void *pvParameters);
    
60. 
    $ b0 e3 G& v- U$ j
61. QueueHandle_t Key_Queue;                   //按键值消息队列句柄
    6 s# L$ w; t1 u1 u
62. #define KEYMSG_Q_NUM    1                  //按键消息队列的数量  
    + [. D0 m# ]6 [
63. 
    5 ?# W5 j" q0 Z7 E/ a# M
64. //二值信号量句柄
    4 n5 t. U- C9 W  u" ?  J
65. SemaphoreHandle_t BinarySemaphore;        //二值信号量句柄
    
66. 
    
67. //用于命令解析用的命令值
    
68. #define BEEPON        1
    0 [$ ~3 }9 u" O* U' I
69. #define BEEPOFF        2
    : R/ C) v5 E+ d7 o  ^4 f  a
70. #define COMMANDERR        0XFF
    : p9 \4 ]$ E" S) m8 B6 j- F
71. 
    
72. //将字符串中的小写字母转换为大写
    
73. //str:要转换的字符串
    
74. //len：字符串长度
    
75. void LowerToCap(u8 *str,u8 len)
    
76. {
    , f" T. s8 L1 Q: F
77.         u8 i;
    
78.         for(i=0;i<len;i++)
    
79.         {
    2 j; v3 U+ o9 x3 }, g$ C$ W# e7 S
80.                 if((96<str<i>)&&(str<i><123))        //小写字母
    
81.                 str<i>=str<i>-32;                                //转换为大写
    ! L  g' |. {6 [
82.         }
    
83. }
    
84. 
    
85. //命令处理函数，将字符串命令转换成命令值
    8 d/ x: ~) g. _1 ?
86. //str：命令
    . a  a4 |7 A8 g
87. //返回值: 0XFF，命令错误；其他值，命令值
    
88. u8 CommandProcess(u8 *str)
    $ w. b4 q. ^7 j$ V3 v
89. {
    ' d2 }+ q8 H# d5 c9 ^( ~! u  _
90.         u8 CommandValue=COMMANDERR;
    9 B+ m! a! ~0 A, F0 Y. G" Y( b) a
91.         if(strcmp((char*)str,"BEEPON")==0) CommandValue=BEEPON;
    ; _, h3 I# N4 F2 G
92.         else if(strcmp((char*)str,"BEEPOFF")==0) CommandValue=BEEPOFF;
    0 O1 v2 [' Y8 W- I' {
93.         return CommandValue;
    
94. }
    
95. 
    $ B; [, q1 u1 z7 n! X
96. int main(void)
    , G  U* N3 ~9 C" X- M1 i
97. {
    
98.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4                  
    
99.         delay_init();                                            //延时函数初始化         
    ' l! x* s8 S; A- b! X
100.         uart_init(115200);                                        //初始化串口
     # P! {) j: I; B; z' |. H
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");
     % o* H3 J# Q7 T8 p: z- o6 N+ ]
107.         printf("* KEY0_PRES Forward LED\r\n");
     . Z' r# S9 K7 [8 s% ]2 r7 Y' @
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");        
     ( P* N" ~  Y  d; v# e& R
112.         printf("*******************************\r\n");        
     2 p7 P7 G/ N5 x( M" ?5 e5 t" C, L
113.         //创建开始任务
     
114.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
     + t7 {% }/ N3 W( o. p# {6 _# J1 U: x
115.                 (const char*    )"start_task",          //任务名称
     * d& z4 W$ a& E, M& r/ h1 K
116.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
       x& X  x5 q% n  K. T+ \
117.                 (void*          )NULL,                  //传递给任务函数的参数
     - h; b2 [/ B0 ^! P2 J' [
118.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
     - {0 [$ F/ U3 a# v$ c5 x
119.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
     3 a: E& W9 j/ b! Y9 ?+ _
120.     vTaskStartScheduler();          //开启任务调度
     
121. }
     
122. 
     + U; ~( R, y8 X% p
123. //开始任务任务函数
     & j3 [# I5 |* \: m& X4 A
124. void start_task(void *pvParameters)
     " Q, X3 ]+ q9 O3 z1 j
125. {
     0 v6 I% e5 |+ P7 O2 ~
126.     taskENTER_CRITICAL();           //进入临界区
     2 U1 n2 m* _, r5 n" C8 U9 h& l' k3 k
127.     Key_Queue=xQueueCreate(KEYMSG_Q_NUM,sizeof(u8));        //创建消息Key_Queue
     * H8 Q, N% T: H& Z' p6 S( X) W
128.         //创建二值信号量
     
129.         BinarySemaphore=xSemaphoreCreateBinary();        
     9 U3 q( u# }7 F4 z' v3 T" h1 a
130.     //创建LED0任务
     , U6 E$ j! m# m9 |8 z
131.     xTaskCreate((TaskFunction_t )LED0Toggle_task,            
     
132.                 (const char*    )"LED0Toggle_task",           
     
133.                 (uint16_t       )LED0Toggle_STK_SIZE,
     
134.                 (void*          )NULL,                                
     2 ], U- p' s/ U7 a% b' i: N
135.                 (UBaseType_t    )LED0Toggle_task_PRIO,        
     ; F! U! ]) R% Q! }0 B) c2 m
136.                 (TaskHandle_t*  )&LED0ToggleTask_Handler);   
     7 G+ m1 \9 N& W; w
137.     //创建LCD任务
     6 t* e3 F) [! d& q  a! C
138.     xTaskCreate((TaskFunction_t )LED1_task,     
     + @+ ~( Y+ R  D7 T, |! J
139.                 (const char*    )"LED1_task",   
     
140.                 (uint16_t       )LED1_STK_SIZE,
     + W2 \- s( E: N9 M1 R( ~
141.                 (void*          )NULL,
     
142.                 (UBaseType_t    )LED1_TASK_PRIO,
     
143.                 (TaskHandle_t*  )&LED1Task_Handler);
     + ]3 C! B  x/ \2 P
144.     xTaskCreate((TaskFunction_t )RTC_task,     
     
145.                 (const char*    )"RTC_task",   
     0 c" r8 I8 q# ~
146.                 (uint16_t       )RTC_STK_SIZE,
     
147.                 (void*          )NULL,
     
148.                 (UBaseType_t    )RTC_TASK_PRIO,
     
149.                 (TaskHandle_t*  )&RTCTask_Handler);   
     & L8 ?, s$ C, o: C5 m
150.     xTaskCreate((TaskFunction_t )BEEP_task,     
     9 {5 ?, F* x# A+ _" R) {' m) N
151.                 (const char*    )"BEEP_task",   
     ) ^" U0 Z  X( Q" {: s* Z
152.                 (uint16_t       )BEEP_STK_SIZE,
     1 u( D' I  f; I' X
153.                 (void*          )NULL,
     
154.                 (UBaseType_t    )BEEP_TASK_PRIO,
     ( J8 h) }% R" G( P# D( s; r& K
155.                 (TaskHandle_t*  )&BEEPTask_Handler);                                   
     
156.     vTaskDelete(StartTask_Handler); //删除开始任务
     % n3 m# @2 g/ ]6 W9 Y3 R: h
157.     taskEXIT_CRITICAL();            //退出临界区
     8 M- o, }4 X/ R, T0 _, T9 F7 c
158. }
     $ p6 u3 a  m2 A1 X/ l$ r
159. 
     1 W3 V, @" v0 P& c; ]
160. //LED0闪烁任务函数，提示程序正在运行，且为按键扫描程序，像队列发送信息
     : r7 \1 Z& ~- T6 e6 e
161. void LED0Toggle_task(void *pvParameters)
     
162. {
     
163.         u8 key,i=0;
     . M9 [( X6 c" D( f: `0 H* X& ^
164.     BaseType_t err;
     , T1 F9 T- I0 N/ h
165.         printf("LED0Toggle Task Running!\r\n");
     : r$ r# X" V. X/ m  C" r
166.         while(1)
     
167.         {
     
168.                 key=KEY_Scan(0);                    //扫描按键
     0 Y$ u  c; w* x
169.         if((Key_Queue!=NULL)&&(key))           //消息队列Key_Queue创建成功,并且按键被按下
     
170.         {
     
171.             err=xQueueSend(Key_Queue,&key,10);
     ! `; b6 O3 A+ }- \3 H7 i
172.             if(err==errQUEUE_FULL)           //发送按键值
     8 }; H; [% Q  e0 O8 M
173.             {
     " I4 }. j/ U3 }8 D
174.                 printf("队列Key_Queue已满，数据发送失败!\r\n");
     + s0 I1 c' w3 @
175.             }
     5 c4 K5 \, [$ ~
176.         }
     . r! n! G, b) J4 [: Z9 u4 s. w! e
177.         i++;
     + ?6 ?( p; ^" V
178.         if(i==50)
     . H; Z' R7 s: A4 w5 G& M
179.         {
     ) l5 [" F" j' l* D' N6 A
180.             i=0;
     
181.             LED0=!LED0;
     
182.         }
     
183.         vTaskDelay(10);   //延时10ms，也就是10个时钟节拍        
     
184.         }
     
185. }   
     # _- {) ]. _2 K
186. 
     
187. //跑马灯任务函数，使用按键控制灯的方向，以及控制灯的亮灭
     . I# x& u  ^/ f" p
188. void LED1_task(void *pvParameters)
     
189. {
     
190.          u8 key=0;
     # Z" G- `1 ?2 ?" T$ w$ G9 D  @
191.         printf("LED1 Task Running!\r\n");
     
192.         
     
193.         while(1)
     $ ?, `, I# f( l) @, C
194.         {
       T/ N" S7 Y8 i; ~
195.         if(Key_Queue!=NULL)
     ( p$ O: m: ~# }' |( S+ y" B6 }
196.         {
     
197.             if(xQueueReceive(Key_Queue,&key,portMAX_DELAY))//请求消息Key_Queue
     / c0 |7 f2 D9 O$ ]6 m: d
198.             {
     
199.                 switch(key)
     
200.                 {
     
201.                     case WKUP_PRES:                //KEY_UP控制流水灯方向，逆向
     0 `# R! |' z4 s
202.                                                 LED1=1;
     ! g% E$ {2 A& A0 Q+ {0 M; Q% e6 J
203.                                                 LED7=0;
     
204.                                                 vTaskDelay(200);
     - x$ T9 w3 K3 a2 D
205.                                                 LED7=1;
     
206.                                                 LED6=0;
     
207.                                                 vTaskDelay(200);
     
208.                                                 LED6=1;
     * g$ }3 |; x7 b
209.                                                 LED5=0;
     # I1 |& K3 b8 J& X* Z
210.                                                 vTaskDelay(200);
     % H+ a6 S7 [  R$ r5 V
211.                                                 LED5=1;
     + j) B- i/ V; [9 g1 E9 s% W
212.                                                 LED4=0;
     ! r2 R; @. G; `; I) w( n& u
213.                                                 vTaskDelay(200);
     ( |. _% ?6 s, ]! \
214.                                                 LED4=1;
     ! _$ j/ z! \) @. ^5 \& U) G5 T
215.                                                 LED3=0;
     " ~0 [6 x% R8 e
216.                                                 vTaskDelay(200);
     & g! j9 {2 `( N3 \# [; Y
217.                                                 LED3=1;
     
218.                                                 LED2=0;
     ; _% U8 n: y9 a: Y( ]$ S
219.                                                 vTaskDelay(200);        
     
220.                                                 LED2=1;
     
221.                                                 LED1=0;
     + q& p  B$ f. [' l; `
222.                                                 vTaskDelay(200);
     
223.                         break;
     9 X, W  D% ?9 s% y) }
224.                     case KEY0_PRES:                //KEY0控制LED灯方向，顺向
     
225.                                                 LED7=1;
     6 l% w4 A/ k& J" e
226.                                                 LED1=0;
     1 P$ S$ w! p+ \9 _( v! A
227.                                                 vTaskDelay(200);
     
228.                                                 LED1=1;
     ! a+ q  H2 @+ l' o+ g' u
229.                                                 LED2=0;
     # z' x9 ~& r# E$ U; w
230.                                                 vTaskDelay(200);
     3 g) D  p, {" {8 l) q" P' E% }$ Y+ S
231.                                                 LED2=1;
     
232.                                                 LED3=0;
     
233.                                                 vTaskDelay(200);
     
234.                                                 LED3=1;
     
235.                                                 LED4=0;
     
236.                                                 vTaskDelay(200);
     ' Z* }& h. Y, u: w3 o5 ^) U
237.                                                 LED4=1;
     ' b) R! O: v0 d7 M5 P4 `
238.                                                 LED5=0;
     
239.                                                 vTaskDelay(200);
     
240.                                                 LED5=1;
     
241.                                                 LED6=0;
     
242.                                                 vTaskDelay(200);        
     9 W. w$ E) t" L
243.                                                 LED6=1;
     5 N1 |) V" O2 [- `+ F
244.                                                 LED7=0;
     9 Y7 E( Y+ e* `' L/ j9 T
245.                                                 vTaskDelay(200);
     4 k1 l+ ^1 ~. Q8 l. H# f
246.                         break;
     - m7 z% ?( g# F
247.                                         case KEY2_PRES:
     % S2 h, I/ L5 y2 R) J" F
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.             }
     1 z' p, ^  ]/ t4 d; x
255.         }
     - k: j, ^$ L8 y! e, |0 C! d
256.                 vTaskDelay(10);      //延时10ms，也就是10个时钟节拍        
     ! i( W' G- n; o" q3 }; C
257.         }
     , q+ ^, w7 z! f  ^+ Q# j
258. }
     
259. //RTC的LCD液晶显示，串口打印任务，并在LCD上进行显示
     
260. void RTC_task(void *pvParameters)
     8 o+ F- e# x  N9 z' b
261. {
     
262.     printf("RTC Task Running!\r\n");
     # p9 o: E) m& O* d- l& Z
263.         while(1)
     3 @0 e6 f% S( @( M- A
264.     {
     9 h" q& `3 j' q9 x' v: x, q) r# Y
265.                 Time_Display();
     
266.                 vTaskDelay(1000);//每一秒钟刷新LED屏幕，显示时间
     
267.     }
     ; w& z$ Z8 V; g6 t5 F9 B9 \
268. }
     
269. 
     
270. //BEEP任务，通过串口发送数据控制蜂鸣器
     
271. void BEEP_task(void *pvParameters)
     
272. {
     2 Y  w4 ]' ?9 Z* f) u
273.         u8 len=0;
     
274.         u8 CommandValue=COMMANDERR;
     
275.         BaseType_t err=pdFALSE;
     $ j* R/ }9 j% Q6 u$ I/ K
276.         
     
277.         u8 *CommandStr;
     4 q4 ?8 i! A& v2 [
278.         POINT_COLOR=BLUE;
     
279.     printf("BEEP Task Running!\r\n");
     8 l$ @$ w* A$ p; e% ?( ~  B
280.         while(1)
     4 Q' O' G" J- e( P6 r( h
281.         {
     
282.                 if(BinarySemaphore!=NULL)
     & j( [/ E& O0 w0 l9 K8 \
283.                 {
     
284.                         err=xSemaphoreTake(BinarySemaphore,portMAX_DELAY);        //获取信号量
     ) e/ @7 r2 w7 q& \
285.                         if(err==pdTRUE)                                                                                //获取信号量成功
     
286.                         {
     
287.                                 len=USART_RX_STA&0x3fff;                                                //得到此次接收到的数据长度
     
288.                                 CommandStr=mymalloc(len+1);                                                //申请内存
     2 q! n8 {* E6 B: B2 Q5 a
289.                                 sprintf((char*)CommandStr,"%s",USART_RX_BUF);
     ' ^" e5 c5 P" _& E* r
290.                                 CommandStr[len]='\0';                                                        //加上字符串结尾符号
     
291.                                 LowerToCap(CommandStr,len);                                                //将字符串转换为大写               
     
292.                                 CommandValue=CommandProcess(CommandStr);                //命令解析
     , `9 O# ^% S! u1 M3 O6 }
293.                                 if(CommandValue!=COMMANDERR)
     
294.                                 {
     
295.                                         printf("命令为:%s\r\n",CommandStr);
     4 Y- W8 c/ G1 K. E
296.                                         switch(CommandValue)                                                //处理命令
     8 o$ Z, c+ y7 c* Q; O: D7 M' b  l" U
297.                                         {
     : C) j( L, i  r( _4 {) r% I8 |( w
298.                                                 case BEEPON:
     
299.                                                         BEEP=0;
     
300.                                                         break;
     / b9 d' r# H. s# o; ~
301.                                                 case BEEPOFF:
     & C& x( D0 M: B; Y
302.                                                         BEEP=1;
     
303.                                                         break;
     ' A: {5 z# _' S
304.                                         }
     
305.                                 }
     
306.                                 else
     
307.                                 {
     ) i1 R3 k5 P/ u+ v9 R. T
308.                                         printf("无效的命令，请重新输入!!\r\n");
     
309.                                 }
     
310.                                 USART_RX_STA=0;
     
311.                                 memset(USART_RX_BUF,0,USART_REC_LEN);                        //串口接收缓冲区清零
     
312.                                 myfree(CommandStr);                                                                //释放内存
     
313.                         }
     $ J9 i0 `7 D0 V6 d: U/ i
314.                 }
     
315.                 else if(err==pdFALSE)
     7 E9 C3 J  m2 s
316.                 {
     
317.                         vTaskDelay(10);      //延时10ms，也就是10个时钟节拍        
     
318.                 }
     
319.         }
     
320. }              </i></i></i></i>

复制代码

- t9 p5 M: L8 x$ m% r) A7 s. \LCD显示函数Time_Display如下
; G1 F/ w2 W1 l' O5 L  X& j

1. void Time_Display(void)
     [; Y+ d5 E9 F( F) X
2. {
   ' m) T; R! Y- p. S2 \1 M
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.         
   / t6 E. S7 M  z9 G9 i# H
10.         sprintf(LCDTemp,"Time: %d-%d-%d   %02d:%02d:%02d \r\n", time.tm_year, \
    ) B8 ?$ l6 c% S: n
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);//显示字符串
    2 f% O! K' t8 M! r
14. }

复制代码

% M% M/ ?8 g7 c7 n7 l- W0 M
3 实验结果
8 X- ~4 p& _: D" I+ `! }& J) M打开串口，显示时间如下，每秒将时间打印到串口
6 U5 t5 j6 t! J6 c6 ]1 ~

& O* v  J& E- u/ L5 \5 `
$ n; J4 V  G0 t% r& G0 ELCD移植后效果图
0 Z) t2 }. y" c5 n$ b- M0 f