一、源码处理
文件下载
1、官网下载源码
/ S# j! }  m! h" F
" S0 f# K) g1 Q( t5 R

$ ^. i6 M, f' [6 N& f( _! J
1 [  z- i) Q. f# |2、找到相关的例程
6 e: @9 r  g5 n- {0 X7 X) f

3、进入源码文件

0 s: ^3 s) }7 g, K6 N
& c; i7 X  Z2 }3 D% p; E4、找到相关的文件
4 k' B2 d3 V% D' {2 i+ s3 j
. ?  r4 a. G7 R7 u+ w

keil、RVDS为需要的文件，MemMang为需要的内存文件
. ~/ j1 G1 \+ L1 k( B+ v) P8 ]
文件移植
1、在之前led灯程序基础上添加文件
注释：在正点原子开源工程里可以下载

1. 创建文件并包含以下文件

复制代码

$ Y1 ?+ x, _. t
3 L7 n" O  E5 n, o6 t
2、将相关.h文件包含进去
' x/ q5 ^) r$ J0 N" }/ ?

# U9 C" Q; I& S, d! |2 Z
此时编译会报错
继续包含所需要的文件
. j' j; o1 ~: ?! r9 o9 P
6 Y% C8 S8 `4 \, K8 @' H2 v" m1 F

) n: C) O0 T' x: i
文件地址：
6 M/ b! R3 E: g8 [# i
6 j$ [" T3 q2 n( m

1 c. V/ ^$ q! W% Y) T8 B* C  s
3、修改相关文件

注释：正点原子给的工程例程是支持ucos的，所以我们需要把一些oc相关的删除掉
( @! O- O9 |! v5 f- J以下是修改之后程序代码：
& R; |8 T+ c/ t4 |/ Zsys.h

usart.c
, \: W* y. M4 u9 \( g

9 ?3 O$ }2 Z6 y% N4 I! T
原来是include.h，需要改成FreePTOS.h

  j4 }$ s" Q9 H* C/ odelay.c

1:SysTIck_Handler()

1. extern void xPortSysTickHandler(void);
   ( A  a" w1 P4 \2 i
2. 
   
3. //systick中断服务函数,使用ucos时用到
   # r* x5 k1 M( x; g! g
4. void SysTick_Handler(void)
   # ~0 j5 ]2 K/ H! K/ S
5. {        
   ' j  k  _  p* R( [0 V) P" k
6.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
   " _0 m3 c) o% I6 K* R
7.     {
   
8.         xPortSysTickHandler();        
   4 g; Z8 T7 ~' E! q- h
9.     }
   ! Y8 b# B  B  D( ?  Y9 r
10. }

复制代码

2:delay_init
4 Y8 r7 o9 c! e4 T# j

1. oid delay_init()
   
2. {
   ) \# \, B7 e' r; {* b" R3 G  h8 Z
3.         u32 reload;
   # s3 I! e) ?/ X1 R% O  z) F, i
4.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);//选择外部时钟  HCLK
     K: f' E: A( f5 u. G" D% \
5.         fac_us=SystemCoreClock/1000000;                                //不论是否使用OS,fac_us都需要使用
   8 d) z; P& z, j# _2 m
6.         reload=SystemCoreClock/1000000;                                //每秒钟的计数次数 单位为M  
   
7.         reload*=1000000/configTICK_RATE_HZ;                        //根据configTICK_RATE_HZ设定溢出时间
   
8.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合0.233s左右        
   
9.         fac_ms=1000/configTICK_RATE_HZ;                                //代表OS可以延时的最少单位           
   
10. 
    
11.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
    
12.         SysTick->LOAD=reload;                                                 //每1/configTICK_RATE_HZ秒中断一次        
    
13.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
    
14. }

复制代码

- P, \8 T6 D3 B) N3:两个延时函数
  D" ~9 a1 _/ [0 D9 @7 V. ^/ [

1. //延时nus
   
2. //nus:要延时的us数.        
   . N2 q  W4 ]% D1 a; i/ y, o0 r
3. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                                                              
   
4. void delay_us(u32 nus)
   
5. {               
   
6.         u32 ticks;
   & R, E: o2 h3 ~% `8 Q, J, V- b
7.         u32 told,tnow,tcnt=0;
   
8.         u32 reload=SysTick->LOAD;                                //LOAD的值                     
   2 f3 ^3 k7 [; |' f' h
9.         ticks=nus*fac_us;                                                 //需要的节拍数
   - P) D$ l6 d3 [# |; I
10.         told=SysTick->VAL;                                        //刚进入时的计数器值
    3 A3 I7 e; X" O: n- H. C* d( M$ l
11.         while(1)
    
12.         {
    
13.                 tnow=SysTick->VAL;        
    
14.                 if(tnow!=told)
    
15.                 {            
    * g" K: c3 f4 U! q& }
16.                         if(tnow<told)tcnt+=told-tnow;        //这里注意一下SYSTICK是一个递减的计数器就可以了.
    1 y; K1 t1 {) O2 M
17.                         else tcnt+=reload-tnow+told;            
    5 q* {- F4 r" S5 g; g; R0 \
18.                         told=tnow;
    
19.                         if(tcnt>=ticks)break;                        //时间超过/等于要延迟的时间,则退出.
    ( d' f( m5 f( U9 X8 s( n! j' M  I& y
20.                 }  
    # d9 l8 \2 O- ~- `
21.         };                                                                                    
    , K9 _1 n: I! t  r( c/ a
22. }  
    1 U8 j  ]/ B! a  _# }; X
23. //延时nms
    7 |( I/ x# g, m; \" z
24. //nms:要延时的ms数
    
25. //nms:0~65535
    
26. void delay_ms(u32 nms)
    
27. {        
    & [* x7 h; }. m) Z8 A
28.         if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    ! V$ p" z$ W' ~) K5 a
29.         {               
    
30.                 if(nms>=fac_ms)                                                //延时的时间大于OS的最少时间周期
    
31.                 {
    
32.                            vTaskDelay(nms/fac_ms);                         //FreeRTOS延时
    5 P$ N+ y8 T! x% h5 x
33.                 }
    ) }+ S1 H$ K! d# a4 r( J1 q
34.                 nms%=fac_ms;                                                //OS已经无法提供这么小的延时了,采用普通方式延时   
    
35.         }
    5 V+ v- Q! w8 o6 m' p
36.         delay_us((u32)(nms*1000));                                //普通方式延时
    7 X6 Y8 M8 ^- m
37. }
    8 F: v9 }, y5 f0 x$ _4 e
38. 
    
39. //延时nms,不会引起任务调度
    
40. //nms:要延时的ms数
    
41. void delay_xms(u32 nms)
    & ^% \! o0 I& a/ K! j* i0 o  Y
42. {
    7 t$ ]$ n$ i' f5 J$ \2 [
43.         u32 i;
    9 P. S8 [/ W+ X+ n( J) I
44.         for(i=0;i<nms;i++) delay_us(1000);
    * M5 p( A. `/ K( U
45. }

复制代码

0 Z3 {2 r( f6 u1 y7 h2 C9 Z4、屏蔽中断
. y% A' Y7 a0 }' {$ c$ d" ]7 e  k

5、最后编译一下，就创建成功啦！！！
9 R2 |$ t( f% {4 ^
创建任务并执行任务
0 C$ d8 _0 A, l  ^1 I创建任务分以下步骤:
8 m( A  v7 V5 i. v0 g  D2 H# [

1. 设置任务优先级
   % Y" P) i, g1 C7 L. C
2. 设置任务堆栈大小
   
3. 设置任务句柄
   6 [* \  ]' z# q& l0 |5 _
4. 设置任务函数

复制代码

我创建了一个任务，使得两个灯同时闪烁，以及串口输出Halloword，以及在移植OLED屏幕的程序

! {" O$ J" T. u) @6 V7 cOLED程序移植相对简单，只需要把相关文件夹进去就行
6 s4 x8 J2 p) T. @这是移植所需要的的一些相关文件：
- @8 k5 m9 M3 Q6 ~  J$ A( N# I, y

其中NRF24L01.c是无线通信模块的，我还在肝中，有需要请私信我。
主函数：

1. #include "sys.h"
   
2. #include "delay.h"
   4 b- o; _6 Z2 a, M
3. #include "usart.h"
   
4. #include "led.h"
   2 u* P0 k' ]0 C; b, |
5. #include "FreeRTOS.h"
   & ^. E  p' p+ T9 e* T. E
6. #include "task.h"
   
7. #include "lcd.h"
   
8. 
   7 T) L! m6 v2 Z& u
9. //任务优先级
   
10. #define START_TASK_PRIO                1
    
11. //任务堆栈大小        
    0 M  k% d. Q* t2 Z
12. #define START_STK_SIZE                 128  
    
13. //任务句柄
    5 l1 g# I5 ]. O
14. TaskHandle_t StartTask_Handler;
    9 w9 o( o( [  m
15. //任务函数
    / W9 [9 O0 j4 b
16. void start_task(void *pvParameters);
    ! ~9 Q- e" y0 X
17. 
    ( v# B6 l8 y7 P1 n
18. 
    % I+ d' c+ _/ U& r+ }
19. //任务优先级
    
20. #define LED0_TASK_PRIO                2
    $ k& T1 ]- f& ~- J& p: J) m% o
21. //任务堆栈大小        
    
22. #define LED0_STK_SIZE                 50  
    
23. //任务句柄
    
24. TaskHandle_t LED0Task_Handler;
    # U1 d/ K& S+ d4 m$ |! x
25. //任务函数
    0 ]% R$ C; f6 \/ B4 X& u
26. void led0_task(void *pvParameters);
    
27. 
    
28. //任务优先级
    ! C7 Z& s9 u! l7 ^/ f
29. #define USART0_TASK_PRIO                3
    ' E; j: r9 ~# c! T/ _
30. //任务堆栈大小        
    
31. #define USART0_STK_SIZE                 50  
    1 z1 u9 u# @/ k7 i  ^
32. //任务句柄
    : x3 P3 z: Z5 Z7 |
33. TaskHandle_t USART0Task_Handler;
    
34. //任务函数
    7 _4 l9 [- J0 z! K# C$ @
35. void usart0_task(void *pvParameters);
    
36. 
    
37. 
    1 l9 l+ G0 S6 B' F' d7 C  ?( z
38. //任务优先级
    2 J- @* N0 Y! X" P0 x
39. #define TEMPER0_TASK_PRIO                4
    
40. //任务堆栈大小        
    
41. #define TEMPER0_STK_SIZE                 50  
    
42. TaskHandle_t TEMPER0Task_Handler;
    5 ]3 ]5 j; _" ^$ N# n( G0 e
43. //任务函数
    ' ~9 Q: p2 I0 O) F$ B
44. void TEMPER0_task(void *pvParameters);
    
45. 
    
46. 
    # h5 x8 b# A! g5 x$ K; A$ t* G4 w$ [7 a
47. //任务优先级
    
48. #define LCD_TO_TASK_PRIO                5
    ( i  l$ f* W/ \' c4 O2 c" `: W
49. //任务堆栈大小        
    
50. #define LCD_TO_STK_SIZE                 50  
    
51. //任务句柄
    
52. TaskHandle_t LCD_TOTask_Handler;
    $ p1 [% T3 o4 V9 q! n
53. //任务函数
    
54. 
    
55. void LCD_TO_task(void *pvParameters);
    ) X* Q* X/ e+ f
56. //任务句柄
    % h2 i! P' f) g: h
57. 
    
58. TaskHandle_t TEMPER0Task_Handler;
    9 d& Z2 r8 X% X* D& E% t
59. //任务函数
    
60. 
      K4 `/ Y$ g: I
61. void temper0_task(void *pvParameters);
    2 D; M. w, z2 y% X: r) ]1 l7 n
62. int main(void)
    " ?( F1 Z& l/ p! X* [
63. {
    * C  @3 f  A% z+ a+ W
64.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    $ ?! y' t  }5 `% y3 g) e
65.         delay_init();                                            //延时函数初始化         
    
66.         uart_init(115200);                                        //初始化串口
    
67.         LED_Init();
    
68.         //初始化LED
    
69.         LCD_Init();
    
70.         POINT_COLOR=RED;
    
71.         //初始化LCD
    
72.         
    
73.         //创建开始任务
    
74.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    
75.                 (const char*    )"start_task",          //任务名称
    
76.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
77.                 (void*          )NULL,                  //传递给任务函数的参数
    
78.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
79.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    
80.     vTaskStartScheduler();          //开启任务调度
    ' W8 n% T# E# D7 K' o  n; l. Z
81. }
    
82. 
    / f) i+ k* ^3 G% l% O/ s# H
83. //开始任务任务函数
    ( p, D3 r9 t7 W
84. void start_task(void *pvParameters)
    & ^- J4 \7 c! e5 F6 P& _/ b
85. {
    : N# e* J0 l5 }$ O$ g. i
86.     taskENTER_CRITICAL();           //进入临界区
    " W8 i2 W1 w, i. j9 ^2 a. J( ]
87.     //创建LED0任务
    + ]1 c, o) [, O: Y, c
88.     xTaskCreate((TaskFunction_t )led0_task,            
    
89.                 (const char*    )"led0_task",           
      b) Z2 c; U! w# z- `
90.                 (uint16_t       )LED0_STK_SIZE,
    
91.                 (void*          )NULL,                                
    
92.                 (UBaseType_t    )LED0_TASK_PRIO,        
    ) E$ Z" v3 h& G+ L# E% s: P
93.                 (TaskHandle_t*  )&LED0Task_Handler);   
    
94.     //创建usart0任务
    
95.     xTaskCreate((TaskFunction_t )usart0_task,     
    
96.                 (const char*    )"usart0_task",   
    
97.                 (uint16_t       )USART0_STK_SIZE,
    
98.                 (void*          )NULL,
    
99.                 (UBaseType_t    )USART0_TASK_PRIO,
      i) G1 p1 I0 E6 ]5 |+ y+ F1 P
100.                 (TaskHandle_t*  )&USART0Task_Handler);
     
101.                 //创建temper0任务
     
102.     xTaskCreate((TaskFunction_t )temper0_task,     
     7 I; o  ^+ q) F3 W* D
103.                 (const char*    )"temper_task",   
     
104.                 (uint16_t       )TEMPER0_STK_SIZE,
     
105.                 (void*          )NULL,
     7 P0 n" H, q9 E1 r7 N) @" _
106.                 (UBaseType_t    )TEMPER0_TASK_PRIO,
     
107.                 (TaskHandle_t*  )&TEMPER0Task_Handler);
     . I' `) b% u! c7 u  {
108.                                 
     
109.         xTaskCreate((TaskFunction_t )LCD_TO_task,     
     , @2 u: M* T# s7 S
110.                 (const char*    )"LCD_TO_task",   
     
111.                 (uint16_t       )LCD_TO_STK_SIZE,
     
112.                 (void*          )NULL,
     
113.                 (UBaseType_t    )LCD_TO_TASK_PRIO,
     6 B! p# ?* B/ X8 n( s" ^
114.                 (TaskHandle_t*  )&LCD_TOTask_Handler);
     
115.                                 
     7 K: L/ m( Q0 w
116.     vTaskDelete(StartTask_Handler); //删除开始任务
     
117.     taskEXIT_CRITICAL();            //退出临界区
     6 Q3 x1 G) K; T- m+ W
118. }
     ! Q6 w1 h- o4 o+ i; @
119. 
     4 F, A# m. }( D4 A) t
120. 
     ; z* F% j2 u3 R: E
121. //LED0任务函数
     7 h' K: t1 d3 G% J' o6 `3 Y
122. void led0_task(void *pvParameters)
     
123. {
     : J1 ~6 ?! }3 q# S5 s9 `$ L3 d8 f
124.     while(1)
     : d! e0 g4 G* s: x- ~, m; J
125.     {
     
126.         LED0=~LED0;
     + S& F0 M4 _+ H
127.                                 if(LED0==1)
     / c, l+ \. k9 e; T7 x) \! j: }
128.                                         printf("灯灭\r\n");
     
129.                                 else
     4 o; ^) E# W3 m' S8 }
130.                                         printf("灯亮\r\n");
     8 D. K  R8 u% {% j7 O; c: W
131.         vTaskDelay(1000);
     
132.     }
     
133. }   
     ) _/ W1 T' M# f% {3 N/ f  c
134. 
     ! Y- L* V+ {/ U8 T' X
135. 
     ' H) ^: P0 X% s/ H
136. //usart0任务函数
     7 o2 W% B; F' C: W- ]
137. void usart0_task(void *pvParameters)
     
138. {
     
139.         
     / g7 |- [2 o6 p
140.                         while(1)
       v/ r/ V5 z1 f% N7 n* u0 y; P8 S
141.                         {        
     3 [$ y6 z; T3 X+ W
142.                                 printf("hello lee");
     1 R: r4 L# Q/ ^( a
143.                                 printf("\r\n");
     & w/ K: L+ |4 A( I
144.                                 vTaskDelay(1000);
     
145.                         }
     
146. }
     
147. 
     
148. //temper0任务函数(暂时为LED1翻转)
     ; ~0 T- E" L. r8 C
149. void temper0_task(void *pvParameters)
     2 P1 g! p/ \- g# n  `
150. {
     1 A# F  q8 w: l  h1 ~
151.                                        
     % [, h1 f4 a+ m) V6 \! v. x) z
152.                         while (1)
     
153.                         {        
     : N; g6 L" O8 Q( a* c
154.                                 LED1=~LED1;
     
155.                                 vTaskDelay(1000);                        
     ) k3 w# p# j7 W3 k
156.                         }
     5 O- T1 A% J- g; Q: y- @
157. }
     
158. 
     % g4 O) s. D2 l2 r
159. void LCD_TO_task(void *pvParameters)
     
160. {
     2 k& r2 K: s  `6 L
161.         u8 lcd_id[12];
     
162.         sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);        
     
163.         while (1)
     
164.                 {        
     
165.                 LCD_ShowString(30,40,210,24,24,"WarShip STM32 ^_^");
     
166.                 LCD_ShowString(30,70,200,16,16,"TFTLCD TEST");
     " L$ V6 T- d* |) v+ M1 e. B
167.                 LCD_ShowString(30,90,200,16,16,"DARKSTARS");
     
168.                  LCD_ShowString(30,110,200,16,16,lcd_id);                //显示LCD ID
     
169.                 LCD_ShowString(30,130,200,12,12,"2020/12/4");
     7 z8 A  N8 m; r7 R
170.                 vTaskDelay(1000);        
     ) P3 ~: l  W  W1 Q
171.                 }
     8 [2 Y  z, q0 d
172. }
     ) ~! w/ ~" x" j: @  m; _- f/ I

复制代码

9 _( M" S; {2 n7 ]4 }" C$ j; e

7 `) A! N: o: ~- Y

4 n1 z  e% l3 P, Z" Y' l  R6 [2 Z7 D

, }/ K# M% b* A" D0 N: ^
+ x7 ?4 u4 i) p+ T6 _$ J+ @
: N5 o- D4 q# z2 I- \( A" o总结
通过这次系统的移植，我感受到系统的魅力，有了系统之后，许多程序就能并行运行了，这样我们就能完成更加高效，更加同步的信息处理和信息传输。对于高刷新率的信息处理，移植系统无疑是更好的选择。
2 F* x( e9 o) _$ n- B
5 f- m: r' L; k! X% I5 u, o5 r
+ J7 {: A. t) S- M# q# S+ p

3 F- @& _* Q3 j6 a$ a+ i0 N" u# V