一、源码处理
文件下载
1、官网下载源码
* f+ y0 B( n/ e% s4 A% E$ R
! u8 v2 ]+ t* P+ P3 I

2、找到相关的例程
9 h5 Y0 r8 Z7 I# B( f; Z* h. w

: A2 ]1 s2 e& `7 W9 J4 K3、进入源码文件

) E0 ~$ W% W% a; _5 v) p2 ?, q- Q$ a

# D& L# m2 B' i; W4、找到相关的文件
" }8 j9 k/ n4 B; o" A

- E" \7 q. J, o2 Skeil、RVDS为需要的文件，MemMang为需要的内存文件

文件移植
1、在之前led灯程序基础上添加文件
注释：在正点原子开源工程里可以下载

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

复制代码

) l. M5 o# n7 z2、将相关.h文件包含进去

3 _1 }: A( }$ H+ y6 _- A此时编译会报错
  g  Q* h$ R( H# p8 v' y继续包含所需要的文件

; D7 j9 G) Q  i0 s. j& D3 o

文件地址：
5 }: j2 w2 h1 {8 {' q* C1 i& \( Z+ X

! C% G4 U" V; A) Q9 x- b5 D
. C% }* u) l6 N; x3、修改相关文件
! g( @6 D$ K# a/ e! @
6 L2 C8 S7 d5 I6 F! q& m注释：正点原子给的工程例程是支持ucos的，所以我们需要把一些oc相关的删除掉
% t, O; j; I2 ?6 L6 h' b' _; y以下是修改之后程序代码：
sys.h
$ a: \6 l5 `; A4 K" c! v

. o4 `  X5 w6 l: A) gusart.c
+ P$ X  D: X6 P: {6 k
4 B/ b+ l: d9 f" W$ x

+ g* D* R$ d; h0 H0 A2 B
原来是include.h，需要改成FreePTOS.h

( P, R! R: ^! V6 @1 Jdelay.c

2 U6 y1 S7 @$ h+ L# e4 G1:SysTIck_Handler()
" G6 N! d0 o. `2 z# b1 C8 j

1. extern void xPortSysTickHandler(void);
   , x" z$ S3 \* d; Q
2. 
   
3. //systick中断服务函数,使用ucos时用到
   - A# E4 G5 b% Y* Z6 R+ Z' s
4. void SysTick_Handler(void)
   ( M1 u) @9 ]  f: U0 ~; x
5. {        
   
6.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
   
7.     {
   
8.         xPortSysTickHandler();        
   , x4 Y: {8 a) D
9.     }
   
10. }

复制代码

2:delay_init
7 f4 Y: Y4 |1 k0 U; k9 T7 `* u

1. oid delay_init()
   - p, y7 [/ V: S0 A
2. {
   - ~: F( N- |: j$ F% w  Q  q3 X1 E5 }
3.         u32 reload;
   ( r" I6 P+ F9 z) k, J. f; e" |
4.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);//选择外部时钟  HCLK
   
5.         fac_us=SystemCoreClock/1000000;                                //不论是否使用OS,fac_us都需要使用
   0 I/ S  W# `0 o/ g* m. _! ]+ _& O
6.         reload=SystemCoreClock/1000000;                                //每秒钟的计数次数 单位为M  
   
7.         reload*=1000000/configTICK_RATE_HZ;                        //根据configTICK_RATE_HZ设定溢出时间
   1 d- e3 c" p8 x5 ?
8.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合0.233s左右        
   8 V0 f% M  D; ~; z
9.         fac_ms=1000/configTICK_RATE_HZ;                                //代表OS可以延时的最少单位           
   $ d$ ]6 \; L+ h! y' K
10. 
    5 @& L, q; o8 j' e4 K
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. }

复制代码

3:两个延时函数
+ m1 ~2 @, O0 k/ \
, u, O% j( Y. Z' r8 x2 z2 Q

1. //延时nus
   % b# `+ D9 ~- b
2. //nus:要延时的us数.        
   
3. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                                                              
     f2 X6 ?7 \; [. `
4. void delay_us(u32 nus)
   
5. {               
   ! Y$ U2 [8 ^  ~: u1 y4 _
6.         u32 ticks;
   
7.         u32 told,tnow,tcnt=0;
   ; Y0 l8 s( D( T! `; u0 }
8.         u32 reload=SysTick->LOAD;                                //LOAD的值                     
   " s: y" L) S, F1 x  X7 n, [
9.         ticks=nus*fac_us;                                                 //需要的节拍数
   
10.         told=SysTick->VAL;                                        //刚进入时的计数器值
    
11.         while(1)
    5 D) r8 q; w9 ]% H8 w7 S
12.         {
    7 \( T  N# T- d! R" Q: Q
13.                 tnow=SysTick->VAL;        
    
14.                 if(tnow!=told)
    
15.                 {            
    
16.                         if(tnow<told)tcnt+=told-tnow;        //这里注意一下SYSTICK是一个递减的计数器就可以了.
    : V3 z6 y1 X) ?; @: J3 V, [
17.                         else tcnt+=reload-tnow+told;            
    
18.                         told=tnow;
    7 r3 _" x" R( ]
19.                         if(tcnt>=ticks)break;                        //时间超过/等于要延迟的时间,则退出.
    
20.                 }  
    & [1 c( B! N/ \' K
21.         };                                                                                    
    
22. }  
    , F: B! w& ]7 r8 v  u, U: w
23. //延时nms
    
24. //nms:要延时的ms数
    
25. //nms:0~65535
    7 E+ H  V5 F8 K% I. _0 V1 a) Y3 L3 O
26. void delay_ms(u32 nms)
    ' m; G- O. d) x
27. {        
    * d7 h: R4 f  d: c* }
28.         if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    ! |! Y1 Y% m& F: ]3 k; R/ k
29.         {               
    
30.                 if(nms>=fac_ms)                                                //延时的时间大于OS的最少时间周期
    
31.                 {
    2 O- Q9 R( b8 ~4 L  l
32.                            vTaskDelay(nms/fac_ms);                         //FreeRTOS延时
    
33.                 }
    
34.                 nms%=fac_ms;                                                //OS已经无法提供这么小的延时了,采用普通方式延时   
    
35.         }
    4 Y3 h7 s; g- D" a6 e7 h) ~
36.         delay_us((u32)(nms*1000));                                //普通方式延时
    
37. }
    
38. 
    
39. //延时nms,不会引起任务调度
    9 F% _8 T4 z: E- T+ V- \
40. //nms:要延时的ms数
    
41. void delay_xms(u32 nms)
    
42. {
    ' f% q, Q7 l  T; @& p
43.         u32 i;
    
44.         for(i=0;i<nms;i++) delay_us(1000);
    , c* Y3 B$ j- Q5 Q. ~
45. }

复制代码

4、屏蔽中断

) ~) u6 ]& {7 u  _
5、最后编译一下，就创建成功啦！！！

创建任务并执行任务
创建任务分以下步骤:

1. 设置任务优先级
   
2. 设置任务堆栈大小
   
3. 设置任务句柄
   
4. 设置任务函数

复制代码

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

OLED程序移植相对简单，只需要把相关文件夹进去就行
0 T" J0 T9 [1 z( ]这是移植所需要的的一些相关文件：

其中NRF24L01.c是无线通信模块的，我还在肝中，有需要请私信我。
主函数：
9 J8 @- K  P" _8 _
; S8 h4 N) p& I+ ?+ P- C

1. #include "sys.h"
   ; |* r& K5 W) ?1 O
2. #include "delay.h"
   
3. #include "usart.h"
   2 y1 b: i9 \$ L  P
4. #include "led.h"
   ! J1 y' Y$ A* I. Y6 N& G' L
5. #include "FreeRTOS.h"
   * D6 e( D' ?4 H( I) P" A# N3 V" s4 u
6. #include "task.h"
   
7. #include "lcd.h"
   
8. 
   
9. //任务优先级
   
10. #define START_TASK_PRIO                1
    
11. //任务堆栈大小        
    & k7 e: F7 x2 K2 Z
12. #define START_STK_SIZE                 128  
    
13. //任务句柄
    
14. TaskHandle_t StartTask_Handler;
    - G* D- x5 D% \- N
15. //任务函数
    
16. void start_task(void *pvParameters);
    
17. 
    
18. 
    2 n$ @4 B" G( ]
19. //任务优先级
    
20. #define LED0_TASK_PRIO                2
    0 B  i) C: X$ Z
21. //任务堆栈大小        
    
22. #define LED0_STK_SIZE                 50  
    
23. //任务句柄
    
24. TaskHandle_t LED0Task_Handler;
    1 X1 i6 v& ^; v* I5 _# \
25. //任务函数
    
26. void led0_task(void *pvParameters);
    7 ?# Z9 J  f6 S; k1 q: b
27. 
    
28. //任务优先级
    
29. #define USART0_TASK_PRIO                3
    ( x" D  ~% x5 x4 P
30. //任务堆栈大小        
    2 e# I7 R2 z6 D) }' J9 `. [
31. #define USART0_STK_SIZE                 50  
    - V- Z2 n! V4 v/ s# q) {
32. //任务句柄
    
33. TaskHandle_t USART0Task_Handler;
    
34. //任务函数
    % _* F% L4 n; l% h5 n; h4 v
35. void usart0_task(void *pvParameters);
    
36. 
    
37. 
    ) B& T8 K8 e+ u7 s2 o4 F/ d2 X
38. //任务优先级
    
39. #define TEMPER0_TASK_PRIO                4
    : _. I! g- k9 p- T# \6 H
40. //任务堆栈大小        
    
41. #define TEMPER0_STK_SIZE                 50  
    
42. TaskHandle_t TEMPER0Task_Handler;
    
43. //任务函数
    
44. void TEMPER0_task(void *pvParameters);
    ( U0 A& x# f' m4 O8 A( k0 a
45. 
    8 M3 g8 a+ N" a; I; c4 I
46. 
    $ S5 h" S$ e, ^+ G3 ~/ n/ Y6 Q
47. //任务优先级
    
48. #define LCD_TO_TASK_PRIO                5
    
49. //任务堆栈大小        
    3 w! I) M) Y/ r6 C( P% g  ~
50. #define LCD_TO_STK_SIZE                 50  
    : u8 ]: b$ u. q- }
51. //任务句柄
    5 @0 g* ?: }0 E& y
52. TaskHandle_t LCD_TOTask_Handler;
    
53. //任务函数
    
54. 
    
55. void LCD_TO_task(void *pvParameters);
    
56. //任务句柄
    
57. 
    
58. TaskHandle_t TEMPER0Task_Handler;
    1 E7 A, H+ e, o4 E
59. //任务函数
    
60. 
    
61. void temper0_task(void *pvParameters);
    
62. int main(void)
    
63. {
    
64.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    
65.         delay_init();                                            //延时函数初始化         
    
66.         uart_init(115200);                                        //初始化串口
    
67.         LED_Init();
    ; L$ F. S" J, U/ k# }8 j1 D# P
68.         //初始化LED
    
69.         LCD_Init();
    4 D7 `2 A. `) w+ v4 n
70.         POINT_COLOR=RED;
    * R$ U( J9 d! e0 W/ ?
71.         //初始化LCD
    
72.         
    
73.         //创建开始任务
    " A- M8 J0 [# U8 ^4 z7 ~
74.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    9 O$ Q6 ]( `1 l4 ^- U
75.                 (const char*    )"start_task",          //任务名称
    3 x2 {" T* b+ F) F  e- l' }$ ~* b3 U
76.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
77.                 (void*          )NULL,                  //传递给任务函数的参数
    & s7 t5 z, s. \! {
78.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
79.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    - W1 c# F& m. n, U+ N* g
80.     vTaskStartScheduler();          //开启任务调度
    
81. }
    
82. 
    
83. //开始任务任务函数
    
84. void start_task(void *pvParameters)
    
85. {
    
86.     taskENTER_CRITICAL();           //进入临界区
    
87.     //创建LED0任务
    
88.     xTaskCreate((TaskFunction_t )led0_task,            
    9 O/ j1 I( D: {; S) ?* O4 y2 O
89.                 (const char*    )"led0_task",           
    
90.                 (uint16_t       )LED0_STK_SIZE,
    
91.                 (void*          )NULL,                                
    
92.                 (UBaseType_t    )LED0_TASK_PRIO,        
    4 q: ^& D% ?# l* e
93.                 (TaskHandle_t*  )&LED0Task_Handler);   
    $ }/ y; T; F+ a6 A3 C2 X8 l; G6 z
94.     //创建usart0任务
    / L- D$ D) f+ i' x" U% |0 P/ P
95.     xTaskCreate((TaskFunction_t )usart0_task,     
    ' U5 d. @" }, K! ?" O
96.                 (const char*    )"usart0_task",   
    
97.                 (uint16_t       )USART0_STK_SIZE,
    
98.                 (void*          )NULL,
    
99.                 (UBaseType_t    )USART0_TASK_PRIO,
    ; r: ?: y) M9 r/ d7 {& O% u, S
100.                 (TaskHandle_t*  )&USART0Task_Handler);
     
101.                 //创建temper0任务
     
102.     xTaskCreate((TaskFunction_t )temper0_task,     
     # i7 Y% |" f; s( j
103.                 (const char*    )"temper_task",   
     
104.                 (uint16_t       )TEMPER0_STK_SIZE,
     
105.                 (void*          )NULL,
     
106.                 (UBaseType_t    )TEMPER0_TASK_PRIO,
     ' H, l' e" p; `- I0 z
107.                 (TaskHandle_t*  )&TEMPER0Task_Handler);
     " `7 S  d+ Y( g8 |. M2 I
108.                                 
     
109.         xTaskCreate((TaskFunction_t )LCD_TO_task,     
     
110.                 (const char*    )"LCD_TO_task",   
     
111.                 (uint16_t       )LCD_TO_STK_SIZE,
     ) K+ ^6 r  t$ f& }% m5 ], l
112.                 (void*          )NULL,
     
113.                 (UBaseType_t    )LCD_TO_TASK_PRIO,
     
114.                 (TaskHandle_t*  )&LCD_TOTask_Handler);
     
115.                                 
     
116.     vTaskDelete(StartTask_Handler); //删除开始任务
     & o( i# a" Q8 D: _, ]
117.     taskEXIT_CRITICAL();            //退出临界区
     
118. }
     
119. 
     
120. 
     
121. //LED0任务函数
     % k, B& D* s  M$ ?5 e
122. void led0_task(void *pvParameters)
     % s! w8 H6 _% J. U+ Z  o
123. {
     9 j0 v7 G. ^# }7 ?
124.     while(1)
     / j4 l1 v. L# \8 a
125.     {
     
126.         LED0=~LED0;
     : j5 A8 l1 J' y/ V' ^' Q( u
127.                                 if(LED0==1)
     
128.                                         printf("灯灭\r\n");
     : I/ n) z7 _5 r1 s4 d, A
129.                                 else
     3 a  W) O! ^% [4 e) l" _$ g" s
130.                                         printf("灯亮\r\n");
     
131.         vTaskDelay(1000);
     
132.     }
     
133. }   
     & @3 G9 h9 g0 y
134. 
     - S; o8 b! k3 v2 x8 A
135. 
     
136. //usart0任务函数
     % q+ \: N9 \. P( E
137. void usart0_task(void *pvParameters)
     8 a; M2 O4 W9 ^3 Y
138. {
     ' D% c1 A! ^7 J# l3 v3 c/ U0 @. c4 V: L
139.         
     4 p( k( ]" _* d
140.                         while(1)
     3 Y( w3 A4 m) t' l$ T1 a+ Y' P/ }2 [* [
141.                         {        
     0 v! ~  b% a/ r  `3 d: B$ O, J0 j
142.                                 printf("hello lee");
     
143.                                 printf("\r\n");
     
144.                                 vTaskDelay(1000);
     % z9 c; Z  v( |# R; m) @  q. {
145.                         }
     
146. }
     
147. 
     
148. //temper0任务函数(暂时为LED1翻转)
     
149. void temper0_task(void *pvParameters)
     4 A5 w0 h) v+ Y, G( {
150. {
     % C/ ]) P$ ]8 T  X: C& |& t% ~
151.                                        
     + [3 n7 c) D) f- {" @1 }
152.                         while (1)
     # T! ]6 d0 Y0 M' @# S0 C
153.                         {        
       X& K& g& Z. ]0 _7 k+ d' Z- y0 p
154.                                 LED1=~LED1;
     
155.                                 vTaskDelay(1000);                        
     & ^; W/ O) Y1 U8 p& z
156.                         }
     
157. }
       i. K% o9 E9 w% Y2 h$ u& g
158. 
     3 g: T' n; m4 f5 O( T, W4 O9 m0 k" b+ D
159. void LCD_TO_task(void *pvParameters)
     ) h- K2 k4 G, T8 O  n) `! n) y
160. {
     
161.         u8 lcd_id[12];
       r9 L; P% `5 [$ ^( d" }
162.         sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);        
     ! O( R4 f! v$ ?# X2 N8 T1 i; L9 {8 _* @
163.         while (1)
     
164.                 {        
     
165.                 LCD_ShowString(30,40,210,24,24,"WarShip STM32 ^_^");
     1 f% Q" x/ {8 p. l6 A3 Q+ n: g( S, U
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
     
169.                 LCD_ShowString(30,130,200,12,12,"2020/12/4");
     
170.                 vTaskDelay(1000);        
     
171.                 }
     # l; J% a. C' S  i  L
172. }
     ; V6 y: S/ Y2 x+ [. |# W

复制代码

% _4 F; H4 Y) B9 Z. M

9 e( b. c; p4 b1 p+ [: x


0 ^5 S8 d% D% _% _
总结
) B  u1 V7 B( T+ P) v2 J! M通过这次系统的移植，我感受到系统的魅力，有了系统之后，许多程序就能并行运行了，这样我们就能完成更加高效，更加同步的信息处理和信息传输。对于高刷新率的信息处理，移植系统无疑是更好的选择。
8 F7 K  U; C& b* I- Z
# _) G5 c- p% I6 W1 V


( f( p! Z" s- q* @