一、源码处理
; H5 q2 g  O; u/ i# M文件下载
1、官网下载源码

3 }9 M% L6 y' n6 c0 G! I& H2、找到相关的例程

+ [8 w1 i9 o! @, c9 Z3、进入源码文件
" S2 N! }* Z1 b2 v- l' X
& X, E; v6 }  S( A" E1 i$ y

0 v# m' s+ Q9 o' h- M
4、找到相关的文件

6 B- j* G: X( N+ F- b

1 \& @  x7 k: f: c( U) X
keil、RVDS为需要的文件，MemMang为需要的内存文件
8 H+ O) X0 ~+ n0 l3 T1 M8 k
+ k* Q5 Y2 E2 q文件移植
5 {+ n! a( q% y1 }  z1、在之前led灯程序基础上添加文件
注释：在正点原子开源工程里可以下载
) ~1 p; T2 B6 i5 L6 J0 E: g

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

复制代码

( V/ C( K5 c" j5 D% J9 u
3 c" j- `  D* u, M( z  Y
2、将相关.h文件包含进去

! L  |: \8 Y# o7 F

此时编译会报错
5 f! U& s6 ^% j$ X. j继续包含所需要的文件
1 m( k/ g- e% i! w
8 |+ b6 G9 T' I9 B

文件地址：
: \1 i4 ?: e, m. t6 K
( x0 ~2 X+ B. `; C: b/ Z

3、修改相关文件
! Y3 d" e1 v) n' Y" i
& ^; e1 H5 B1 H, c: h注释：正点原子给的工程例程是支持ucos的，所以我们需要把一些oc相关的删除掉
以下是修改之后程序代码：
sys.h

. f0 U3 _- }- ?1 s5 r/ i

usart.c

. A+ U- @$ n  m! l! p* l
2 Q8 i) u: R0 B$ a3 T原来是include.h，需要改成FreePTOS.h

0 M4 l9 w+ k9 J. o# w+ hdelay.c

1:SysTIck_Handler()

1. extern void xPortSysTickHandler(void);
   5 w% U0 c9 h0 Y
2. 
   
3. //systick中断服务函数,使用ucos时用到
   ( ]9 l0 B3 b7 B: w! d
4. void SysTick_Handler(void)
   8 ^9 @% U8 ^! O; Z
5. {        
   4 F( A' f( {) s
6.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
   9 e) z" e$ k- n4 p
7.     {
   
8.         xPortSysTickHandler();        
   
9.     }
   - A& M9 i+ I4 e
10. }

复制代码

2:delay_init

# P' ~% t+ c  f  C/ s! o. L

1. oid delay_init()
   
2. {
   ; D8 t" P8 X1 m8 Y! A) v
3.         u32 reload;
   7 u9 r& O) m5 D6 v, w, u5 `$ [2 m
4.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);//选择外部时钟  HCLK
   
5.         fac_us=SystemCoreClock/1000000;                                //不论是否使用OS,fac_us都需要使用
   
6.         reload=SystemCoreClock/1000000;                                //每秒钟的计数次数 单位为M  
   0 v% `# ~& ?% M: B% U  U  n$ y% h
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. }

复制代码

5 C! _) x# Q, W' D3 t) h0 q3:两个延时函数

1. //延时nus
   
2. //nus:要延时的us数.        
   
3. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                                                              
   * L/ R* v& X- Q/ Z$ f
4. void delay_us(u32 nus)
   
5. {               
   
6.         u32 ticks;
     `. q7 p7 g4 ^+ }7 d
7.         u32 told,tnow,tcnt=0;
   8 ?4 x' B: A. m2 E3 e* [" |6 I
8.         u32 reload=SysTick->LOAD;                                //LOAD的值                     
   ! Z5 ]8 U! ~9 B& I3 K9 {: z
9.         ticks=nus*fac_us;                                                 //需要的节拍数
   " z5 x/ X* Q& B
10.         told=SysTick->VAL;                                        //刚进入时的计数器值
    
11.         while(1)
    
12.         {
    $ I; m4 v& u. j4 W" q
13.                 tnow=SysTick->VAL;        
      F, }0 S. [7 O4 O9 V% r
14.                 if(tnow!=told)
    6 z7 U7 d9 T# m: O, k
15.                 {            
    
16.                         if(tnow<told)tcnt+=told-tnow;        //这里注意一下SYSTICK是一个递减的计数器就可以了.
    ) c* @( ~1 q; y8 J5 i- A( C
17.                         else tcnt+=reload-tnow+told;            
    / s# c* J0 [8 C( D6 Z
18.                         told=tnow;
    4 _/ ~. w) Y- B- K' O* X: g* }
19.                         if(tcnt>=ticks)break;                        //时间超过/等于要延迟的时间,则退出.
    8 l- ?  m# u0 K7 m; M& h
20.                 }  
      v! L% O  S, G' z: s) {' h
21.         };                                                                                    
    + K  t) }' j: s6 l# d
22. }  
    8 U1 w, |' x! H' \& S
23. //延时nms
    
24. //nms:要延时的ms数
    2 v) u3 s7 C- Z  W* c3 U  d
25. //nms:0~65535
    
26. void delay_ms(u32 nms)
    
27. {        
    % d& n# H5 @" d0 A
28.         if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    3 W  b% N0 Y5 Y, g
29.         {               
    7 @2 R7 ?! v* Y! P0 P7 W' J
30.                 if(nms>=fac_ms)                                                //延时的时间大于OS的最少时间周期
    ' q2 \+ C( u+ X/ ?" `5 F8 z
31.                 {
    
32.                            vTaskDelay(nms/fac_ms);                         //FreeRTOS延时
    ; p5 V( Q8 k# l, @% V
33.                 }
    
34.                 nms%=fac_ms;                                                //OS已经无法提供这么小的延时了,采用普通方式延时   
    # F6 d6 a+ Q* k% S$ \# @; @
35.         }
    
36.         delay_us((u32)(nms*1000));                                //普通方式延时
    
37. }
    
38. 
    
39. //延时nms,不会引起任务调度
    2 w) U7 ?! |- x$ Q; {! ^
40. //nms:要延时的ms数
    
41. void delay_xms(u32 nms)
    , q1 k4 O) q+ E$ V8 o9 v0 j
42. {
    ) d9 ]$ F. W1 D
43.         u32 i;
    
44.         for(i=0;i<nms;i++) delay_us(1000);
    
45. }

复制代码

% q9 C3 G& R7 j' `3 \4、屏蔽中断
* Y( `; L$ [( Z: \7 o3 i
$ N# a# H' S" x- ~2 S& e

8 z0 t7 j  _' p1 F5、最后编译一下，就创建成功啦！！！
/ k# P+ v$ y6 {4 w4 u: e
创建任务并执行任务
  y  `2 C  u4 E- ^创建任务分以下步骤:

1. 设置任务优先级
   & n* Y/ ^% z! R* `% r
2. 设置任务堆栈大小
   * w  t/ n4 ]1 e: d  M& g1 s8 e( p
3. 设置任务句柄
   : }9 e" W! v- |" v
4. 设置任务函数

复制代码

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

  k% u, s; N" i- j# X) j" cOLED程序移植相对简单，只需要把相关文件夹进去就行
这是移植所需要的的一些相关文件：

1 \  F+ ^4 U$ Z; a. y3 b
其中NRF24L01.c是无线通信模块的，我还在肝中，有需要请私信我。
主函数：

1. #include "sys.h"
   5 @, @! E% Q7 I  E* R6 N7 |
2. #include "delay.h"
   
3. #include "usart.h"
   ' j, W( D( I7 o" A: a
4. #include "led.h"
   : d. Q0 }3 l8 j9 d, G! u8 i
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   
7. #include "lcd.h"
   3 Y3 d. ~! `* l1 o* y% j! I$ U7 c: |
8. 
   " A5 G- ~: X0 E: y* c/ M
9. //任务优先级
   - v3 y; L9 E6 o+ |' h" V5 w
10. #define START_TASK_PRIO                1
    
11. //任务堆栈大小        
    
12. #define START_STK_SIZE                 128  
    
13. //任务句柄
    5 x! u. k3 d* _5 ^% t$ G
14. TaskHandle_t StartTask_Handler;
    
15. //任务函数
    
16. void start_task(void *pvParameters);
    $ U. k( A' k4 [% E
17. 
    4 G$ X& W1 U! G
18. 
    7 L5 v0 `5 y+ W  v7 m
19. //任务优先级
    
20. #define LED0_TASK_PRIO                2
    : \' R0 b* {0 h* Q1 h. X
21. //任务堆栈大小        
    
22. #define LED0_STK_SIZE                 50  
    4 x( M, F# u/ ]4 Y4 \( S3 u
23. //任务句柄
    / X7 I  r' e0 t' y# C1 j. F
24. TaskHandle_t LED0Task_Handler;
    6 x2 J' J; V* i* E( p# k+ [2 M( B
25. //任务函数
    
26. void led0_task(void *pvParameters);
    
27. 
    
28. //任务优先级
    & q' M& f- c* Q0 U
29. #define USART0_TASK_PRIO                3
    / t% S" f6 T8 h" P* p- D
30. //任务堆栈大小        
    ; K4 P8 j& _9 ]' r$ d. J5 _5 F
31. #define USART0_STK_SIZE                 50  
    
32. //任务句柄
    
33. TaskHandle_t USART0Task_Handler;
    ) W  V0 d2 Z! x
34. //任务函数
    * W* w% p/ s6 w4 e" {& J1 P
35. void usart0_task(void *pvParameters);
    
36. 
    
37. 
    
38. //任务优先级
    2 d; j# T$ |' c
39. #define TEMPER0_TASK_PRIO                4
    
40. //任务堆栈大小        
    1 H7 v1 n. Z8 K+ i- W
41. #define TEMPER0_STK_SIZE                 50  
    9 p, R# k  r! Q
42. TaskHandle_t TEMPER0Task_Handler;
    - {' }/ O$ _+ `1 L
43. //任务函数
    $ S+ E' V5 D- i+ F- Q% s
44. void TEMPER0_task(void *pvParameters);
    
45. 
    - S% _/ [0 g8 B2 [: {- E# K: H
46. 
    * B0 H! a' p7 Y) j
47. //任务优先级
    
48. #define LCD_TO_TASK_PRIO                5
    
49. //任务堆栈大小        
    
50. #define LCD_TO_STK_SIZE                 50  
    
51. //任务句柄
    
52. TaskHandle_t LCD_TOTask_Handler;
    , n+ ~! l6 `4 u- C1 s0 y
53. //任务函数
    
54. 
    4 N/ c2 W1 W+ A7 X: p4 A5 z
55. void LCD_TO_task(void *pvParameters);
    
56. //任务句柄
    : S  J0 Z' R8 j2 m9 P$ N
57. 
    ' k2 z; k* M/ L/ `8 Q* s1 {7 L
58. TaskHandle_t TEMPER0Task_Handler;
    
59. //任务函数
    
60. 
    / {9 b3 i$ ~" G8 H/ d+ l5 }
61. void temper0_task(void *pvParameters);
    " Q5 b  x1 P. W+ v" D$ j
62. int main(void)
    : [, A* o: k! B# R9 L
63. {
    
64.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    # B! H- E! V5 t; l. K
65.         delay_init();                                            //延时函数初始化         
    
66.         uart_init(115200);                                        //初始化串口
    
67.         LED_Init();
    
68.         //初始化LED
    # O; `% d+ I1 Y, u* ^# V
69.         LCD_Init();
    
70.         POINT_COLOR=RED;
    
71.         //初始化LCD
    
72.         
    4 x3 m! L3 T( J4 \7 l& \
73.         //创建开始任务
    
74.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    , T% g1 O2 H; \# ?5 G  {
75.                 (const char*    )"start_task",          //任务名称
    / E) q3 o% u" E  r
76.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
77.                 (void*          )NULL,                  //传递给任务函数的参数
    
78.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
79.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    1 A9 \5 F9 j) h0 |
80.     vTaskStartScheduler();          //开启任务调度
    
81. }
    . f0 W& _+ U  A
82. 
    3 A8 Y0 m+ d, B! z$ a, r
83. //开始任务任务函数
    
84. void start_task(void *pvParameters)
    ! ]( v: P& T, W7 V* R* P9 u/ k
85. {
    3 B( {: H& B  T  X6 ~
86.     taskENTER_CRITICAL();           //进入临界区
    
87.     //创建LED0任务
    $ y5 H; x6 h) `: H4 a; `+ ]  T& D
88.     xTaskCreate((TaskFunction_t )led0_task,            
    " h- f4 a+ \* Q
89.                 (const char*    )"led0_task",           
    
90.                 (uint16_t       )LED0_STK_SIZE,
    2 P! M% C1 A/ ~1 x& G& X
91.                 (void*          )NULL,                                
    6 u$ r5 A  z1 z2 h
92.                 (UBaseType_t    )LED0_TASK_PRIO,        
    
93.                 (TaskHandle_t*  )&LED0Task_Handler);   
    ) g9 g7 r3 ~! ^+ o
94.     //创建usart0任务
    
95.     xTaskCreate((TaskFunction_t )usart0_task,     
    
96.                 (const char*    )"usart0_task",   
    
97.                 (uint16_t       )USART0_STK_SIZE,
    
98.                 (void*          )NULL,
    % j& Y7 k. G7 ~! M6 ]
99.                 (UBaseType_t    )USART0_TASK_PRIO,
    6 ^7 a5 m9 }/ W6 A# {+ T
100.                 (TaskHandle_t*  )&USART0Task_Handler);
     
101.                 //创建temper0任务
     9 l( E5 |8 _1 F) g7 e2 Q
102.     xTaskCreate((TaskFunction_t )temper0_task,     
     
103.                 (const char*    )"temper_task",   
     
104.                 (uint16_t       )TEMPER0_STK_SIZE,
     
105.                 (void*          )NULL,
     : `6 h; ?8 V: S3 b/ M
106.                 (UBaseType_t    )TEMPER0_TASK_PRIO,
     , g+ R1 A; F$ e+ E" ~# D
107.                 (TaskHandle_t*  )&TEMPER0Task_Handler);
     
108.                                 
     
109.         xTaskCreate((TaskFunction_t )LCD_TO_task,     
     / F4 ?4 s' `% u0 ]
110.                 (const char*    )"LCD_TO_task",   
     
111.                 (uint16_t       )LCD_TO_STK_SIZE,
     0 N, `7 N& ^( }
112.                 (void*          )NULL,
     - X6 {+ Y/ i; U
113.                 (UBaseType_t    )LCD_TO_TASK_PRIO,
     ' r. M( }0 j: ]6 C- |
114.                 (TaskHandle_t*  )&LCD_TOTask_Handler);
     , ]( k" J" B* `' }; G6 y
115.                                 
     + k/ O( B5 O* P3 P8 F
116.     vTaskDelete(StartTask_Handler); //删除开始任务
     : G' v$ O  y4 }% T% O& t9 ~% [
117.     taskEXIT_CRITICAL();            //退出临界区
     9 |6 I9 }& y/ J: t: c
118. }
     
119. 
     & r. _; f1 b, @0 _
120. 
     - V' f7 z- Y3 a2 J5 {
121. //LED0任务函数
     5 j. S+ ^9 G' R: D- y. ~# G! v- b- m& C
122. void led0_task(void *pvParameters)
     ; s7 J7 C% D0 ?
123. {
     
124.     while(1)
     7 f% P: Q! |0 Z6 c+ _
125.     {
     6 l( \2 f! U! K* ]$ ]% ]
126.         LED0=~LED0;
     
127.                                 if(LED0==1)
     5 u4 Y5 ~0 E& g& C  t8 y
128.                                         printf("灯灭\r\n");
     
129.                                 else
     
130.                                         printf("灯亮\r\n");
     
131.         vTaskDelay(1000);
     6 G: C8 W' u! W6 ]( w5 R
132.     }
     " S- J5 S' A; b- i$ q% x) @/ r
133. }   
     
134. 
     / V* O, L6 @" g
135. 
     
136. //usart0任务函数
     
137. void usart0_task(void *pvParameters)
     
138. {
     % l3 ]6 P) {' ^. N* f7 n
139.         
     
140.                         while(1)
     
141.                         {        
     
142.                                 printf("hello lee");
     
143.                                 printf("\r\n");
     
144.                                 vTaskDelay(1000);
     
145.                         }
     
146. }
     
147. 
     
148. //temper0任务函数(暂时为LED1翻转)
     
149. void temper0_task(void *pvParameters)
     
150. {
     3 h( A! }4 o( j" p7 X
151.                                        
     : }' T; H: x/ N: l# E( g
152.                         while (1)
     
153.                         {        
     : R" J5 |* \4 r! F% S, |+ Q
154.                                 LED1=~LED1;
     , }( D+ Q0 _& A) m
155.                                 vTaskDelay(1000);                        
     4 M& J  _3 |0 l4 ~' D8 r9 F, g6 Y4 i
156.                         }
     . O1 x. u' @, I; S& p, k4 Z
157. }
     1 d5 m1 R! y( @+ r- V8 d
158. 
     
159. void LCD_TO_task(void *pvParameters)
     
160. {
     % _0 h" ]6 n6 b- E$ H
161.         u8 lcd_id[12];
     
162.         sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);        
     # [- q' M7 |  U
163.         while (1)
     $ Q! [1 _* u* r$ _
164.                 {        
     ( O1 x* T- h% I: ]2 c: S
165.                 LCD_ShowString(30,40,210,24,24,"WarShip STM32 ^_^");
     - O- V3 c8 Y, y3 D- C" P7 A
166.                 LCD_ShowString(30,70,200,16,16,"TFTLCD TEST");
     
167.                 LCD_ShowString(30,90,200,16,16,"DARKSTARS");
     
168.                  LCD_ShowString(30,110,200,16,16,lcd_id);                //显示LCD ID
     " Z) z3 W- P" q; Q9 Q, K. Z! J- l3 _
169.                 LCD_ShowString(30,130,200,12,12,"2020/12/4");
     7 v4 I2 y( h1 F- J
170.                 vTaskDelay(1000);        
     9 y9 s: A! m4 M. T5 x- ?
171.                 }
     8 ?# H( w+ |' a7 P9 R5 D$ h9 P
172. }
     

复制代码

4 `3 L% I4 D4 @  w% k# F; k

6 P' M; q! P  e% r( b9 B3 g

. l3 X/ z0 B$ \6 G; m3 K5 \1 v3 H
" q1 a( n0 ^$ I6 p
2 m$ U8 S" }4 r- O. T总结
通过这次系统的移植，我感受到系统的魅力，有了系统之后，许多程序就能并行运行了，这样我们就能完成更加高效，更加同步的信息处理和信息传输。对于高刷新率的信息处理，移植系统无疑是更好的选择。

& l% o) e1 s; K' c( F

9 t3 `' ?% {. C& y( C
8 m/ c1 o: F: ?" m