一、源码处理
文件下载
1、官网下载源码

2、找到相关的例程
) v% q7 r. L- m# K

% _) o6 Q' X/ U4 k+ T3、进入源码文件

+ `8 M$ G4 w2 A

4、找到相关的文件
9 w3 i+ b' V/ P3 h2 j

5 N2 s  @* D/ g: Q* {7 F
1 z/ ]$ {: e- J" a  Mkeil、RVDS为需要的文件，MemMang为需要的内存文件

文件移植
1、在之前led灯程序基础上添加文件
4 N  K2 @" T8 j" z; Y% v: m注释：在正点原子开源工程里可以下载
7 m7 a; [- {! y" w
$ e* C' O: ~! {6 o8 O

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

复制代码

; e3 J" {: g7 i$ j% \, F) X
2、将相关.h文件包含进去

5 k; B# W/ {" Q/ M$ K! U; N

2 n* H9 V: i% n5 D
$ e6 b9 Q; ?1 ]- k此时编译会报错
# d% R+ P. a7 ]2 R8 y2 l4 G! j继续包含所需要的文件
5 ^$ T) L6 Z& S- i9 v! S% n5 J0 X

( o5 I, O7 o/ D/ w& P2 K; F6 _. s9 f文件地址：
) Z- f9 J3 c) A' K( L

9 L7 N# H! Z% ^& W. o! E7 y
3、修改相关文件

' |% M0 D3 K/ u' `+ ~5 a, k注释：正点原子给的工程例程是支持ucos的，所以我们需要把一些oc相关的删除掉
以下是修改之后程序代码：
2 O% M: p0 ]) rsys.h
+ v  U7 @; h& f  B* V$ A( F- `4 l

usart.c
# J' V, y$ N; y, ]$ L

7 ?4 d% L( u+ m) x/ _: h) U7 }原来是include.h，需要改成FreePTOS.h

delay.c
" O3 I$ v2 s( Z2 l' |3 A
1:SysTIck_Handler()
; h, ]: P' `4 f9 M8 `8 a9 U

1. extern void xPortSysTickHandler(void);
   
2. 
   
3. //systick中断服务函数,使用ucos时用到
   
4. void SysTick_Handler(void)
   
5. {        
   
6.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
   ' }, p2 \5 M2 c9 q" O9 J
7.     {
   
8.         xPortSysTickHandler();        
   
9.     }
   
10. }

复制代码

2:delay_init

' l6 i1 z( N! I0 e

1. oid delay_init()
   
2. {
   
3.         u32 reload;
   
4.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);//选择外部时钟  HCLK
   
5.         fac_us=SystemCoreClock/1000000;                                //不论是否使用OS,fac_us都需要使用
   
6.         reload=SystemCoreClock/1000000;                                //每秒钟的计数次数 单位为M  
   2 b( C: o* k; V4 X+ N8 O$ l( e
7.         reload*=1000000/configTICK_RATE_HZ;                        //根据configTICK_RATE_HZ设定溢出时间
   ' o  F+ H" L1 a  k4 g
8.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合0.233s左右        
   
9.         fac_ms=1000/configTICK_RATE_HZ;                                //代表OS可以延时的最少单位           
   
10. 
    
11.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
    ; v6 N( c$ N" e; m2 v2 H: G# W0 ?
12.         SysTick->LOAD=reload;                                                 //每1/configTICK_RATE_HZ秒中断一次        
    
13.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
    
14. }

复制代码

3:两个延时函数
* x# v& C) |  S3 a
' E) X0 n8 q- H! O; K. n' v

1. //延时nus
   
2. //nus:要延时的us数.        
   
3. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                                                              
   1 S5 K4 {$ G' {
4. void delay_us(u32 nus)
   4 h0 A8 g% y0 C
5. {               
   
6.         u32 ticks;
   
7.         u32 told,tnow,tcnt=0;
   8 M5 d& X: g0 t" J$ K
8.         u32 reload=SysTick->LOAD;                                //LOAD的值                     
   
9.         ticks=nus*fac_us;                                                 //需要的节拍数
   + ^+ i6 R* ]( ]- Z
10.         told=SysTick->VAL;                                        //刚进入时的计数器值
    
11.         while(1)
    $ ?& c1 i: s$ ?# a2 E6 s, d% ?
12.         {
    1 r- q1 o2 k( b4 F, Z; U8 \0 A; d! h7 B
13.                 tnow=SysTick->VAL;        
    
14.                 if(tnow!=told)
    $ I  F* e9 U. O; @; _# u
15.                 {            
    ! w8 ?! L5 `6 ?9 Z9 Z/ ?
16.                         if(tnow<told)tcnt+=told-tnow;        //这里注意一下SYSTICK是一个递减的计数器就可以了.
    
17.                         else tcnt+=reload-tnow+told;            
    
18.                         told=tnow;
    
19.                         if(tcnt>=ticks)break;                        //时间超过/等于要延迟的时间,则退出.
    $ A" \' z( ^+ S1 F7 @6 S; H
20.                 }  
    
21.         };                                                                                    
    ( u( h6 B& b2 M6 `0 F) `
22. }  
    8 @5 u6 f% T$ j, l' X
23. //延时nms
    
24. //nms:要延时的ms数
    ) a8 W( |  l5 a5 I% q) k& x, J
25. //nms:0~65535
    $ y9 @) s& Z  b$ S6 H8 o& h
26. void delay_ms(u32 nms)
    + o2 Z3 D$ B2 j( M3 Q5 n
27. {        
    
28.         if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    
29.         {               
    
30.                 if(nms>=fac_ms)                                                //延时的时间大于OS的最少时间周期
    
31.                 {
    
32.                            vTaskDelay(nms/fac_ms);                         //FreeRTOS延时
    1 E, b& U1 d: J( g' u
33.                 }
    
34.                 nms%=fac_ms;                                                //OS已经无法提供这么小的延时了,采用普通方式延时   
    
35.         }
    
36.         delay_us((u32)(nms*1000));                                //普通方式延时
    
37. }
    
38. 
    
39. //延时nms,不会引起任务调度
    
40. //nms:要延时的ms数
    
41. void delay_xms(u32 nms)
      @8 R/ S# w) Z; p
42. {
    ) F: N+ [5 R+ N3 l9 N
43.         u32 i;
    - R+ E  b7 \  H8 D- `
44.         for(i=0;i<nms;i++) delay_us(1000);
    7 Q& Y8 S9 k# n( o( \
45. }

复制代码

  P# Z8 O( P  \% T' c0 o; n4、屏蔽中断
: @& B( @1 c# w( N6 `* W( S: N

2 M$ @6 j6 _& F0 W& }
/ |) {  S" a, L) _5、最后编译一下，就创建成功啦！！！
5 o" v# W: }+ V! D
# `7 S" L! @' i1 r7 V; i. l创建任务并执行任务
创建任务分以下步骤:
1 ^5 l+ p% p5 B7 |8 x& A

1. 设置任务优先级
   
2. 设置任务堆栈大小
   
3. 设置任务句柄
   ; r; q9 }4 f, e" c, `! Y; Q7 E
4. 设置任务函数

复制代码

我创建了一个任务，使得两个灯同时闪烁，以及串口输出Halloword，以及在移植OLED屏幕的程序
1 l: S: ~: @( T: ?* m0 Q6 `# x
OLED程序移植相对简单，只需要把相关文件夹进去就行
这是移植所需要的的一些相关文件：
$ [$ o. j( R' j1 F! \

! w' O% E) U# N) f
' y/ _" w8 O7 {其中NRF24L01.c是无线通信模块的，我还在肝中，有需要请私信我。
主函数：
5 y0 Z4 D! f5 Q8 {

1. #include "sys.h"
   * k7 n( K% @/ [: a
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
     d4 @4 Z1 t" ?
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   
7. #include "lcd.h"
   * O  g+ W! R  h0 j2 ]. X
8. 
   
9. //任务优先级
   - t+ x/ E7 u$ s8 }& F& i
10. #define START_TASK_PRIO                1
    2 W; t7 o6 g* T2 H" V2 a7 R
11. //任务堆栈大小        
    
12. #define START_STK_SIZE                 128  
    $ l: H. P( {! g' |" {1 g
13. //任务句柄
    # G7 u. Z$ O) G4 h5 p$ b1 [5 ]( M
14. TaskHandle_t StartTask_Handler;
    
15. //任务函数
    4 k" d- E9 z5 F
16. void start_task(void *pvParameters);
    
17. 
    
18. 
    
19. //任务优先级
    ( B2 H2 @8 Y' `/ Z- i  e
20. #define LED0_TASK_PRIO                2
    % s/ a% J$ V. q' E4 z0 |& J/ s
21. //任务堆栈大小        
    
22. #define LED0_STK_SIZE                 50  
    ; y# F( A6 s/ O, c- `( I
23. //任务句柄
    
24. TaskHandle_t LED0Task_Handler;
    ; R; C1 S/ @- x' f
25. //任务函数
    ; B# p' A6 i) Z1 |& p
26. void led0_task(void *pvParameters);
    ' E: [% S$ t6 |) a
27. 
    
28. //任务优先级
    
29. #define USART0_TASK_PRIO                3
    0 a, p8 {( }  F7 L: [
30. //任务堆栈大小        
    
31. #define USART0_STK_SIZE                 50  
    + h6 Q2 \# o* I) j( N+ P
32. //任务句柄
    , C/ p: @0 J+ o
33. TaskHandle_t USART0Task_Handler;
    
34. //任务函数
    
35. void usart0_task(void *pvParameters);
    " b  S0 d7 r& _, ]5 ~/ }
36. 
    ' S1 T: ^: C, A* T2 C4 \
37. 
    
38. //任务优先级
    
39. #define TEMPER0_TASK_PRIO                4
    1 j- }2 N# x  w/ l
40. //任务堆栈大小        
    ( ?2 h) F: J2 C: U
41. #define TEMPER0_STK_SIZE                 50  
    
42. TaskHandle_t TEMPER0Task_Handler;
    - q! J- o4 C6 w# `% ?
43. //任务函数
    6 p2 w3 i% }8 H# @
44. void TEMPER0_task(void *pvParameters);
    
45. 
    ) ?2 S+ [0 y7 t
46. 
    $ v# s# b" ?  x4 V6 R6 X3 {6 B
47. //任务优先级
    
48. #define LCD_TO_TASK_PRIO                5
    
49. //任务堆栈大小        
    0 R& n  K, a$ j! D; L" L) n" ~  C
50. #define LCD_TO_STK_SIZE                 50  
    
51. //任务句柄
    $ W" j9 S1 G; u$ l
52. TaskHandle_t LCD_TOTask_Handler;
    $ j3 G0 H; B2 [4 A0 _* _6 O5 q
53. //任务函数
    
54. 
    
55. void LCD_TO_task(void *pvParameters);
    5 S' ~+ P4 N5 L# B/ W8 j6 y  M; o( M9 y
56. //任务句柄
    
57. 
    
58. TaskHandle_t TEMPER0Task_Handler;
    7 S; f+ r% t+ b7 i( C* l
59. //任务函数
    
60. 
    
61. void temper0_task(void *pvParameters);
    
62. int main(void)
    : e' D# w0 G- x' [/ q- {
63. {
    " |' V: d8 C+ d7 Y8 i' D: K
64.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    + m8 ?: M- [: g$ L* l+ @0 i
65.         delay_init();                                            //延时函数初始化         
    8 T" |( a0 w/ S6 Y5 }5 ^) F; k. d
66.         uart_init(115200);                                        //初始化串口
    
67.         LED_Init();
    
68.         //初始化LED
    1 {/ Q2 Z* ^+ S/ m
69.         LCD_Init();
    . U: e5 K( N  v$ G9 q; d6 c3 a' ~& m
70.         POINT_COLOR=RED;
    
71.         //初始化LCD
    / k  v5 A; a8 ~6 p
72.         
    
73.         //创建开始任务
    
74.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    ! c9 @4 q& `) U1 Q8 ]4 M
75.                 (const char*    )"start_task",          //任务名称
    
76.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    # F: D/ D- I4 Y$ }% F
77.                 (void*          )NULL,                  //传递给任务函数的参数
    4 G4 A8 I4 m0 f+ ]) s
78.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
79.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    
80.     vTaskStartScheduler();          //开启任务调度
    
81. }
    0 ]( i4 g  Q. X- U
82. 
    
83. //开始任务任务函数
    . c8 s$ j# b, a4 H
84. void start_task(void *pvParameters)
    
85. {
    
86.     taskENTER_CRITICAL();           //进入临界区
    
87.     //创建LED0任务
    - ~! C: Q, v1 P# ^. ^
88.     xTaskCreate((TaskFunction_t )led0_task,            
    
89.                 (const char*    )"led0_task",           
    
90.                 (uint16_t       )LED0_STK_SIZE,
    , s$ m2 w6 x6 e
91.                 (void*          )NULL,                                
    : M% G0 f5 `1 k( O# d$ Z
92.                 (UBaseType_t    )LED0_TASK_PRIO,        
    & S3 r' |7 a/ @* ~; M
93.                 (TaskHandle_t*  )&LED0Task_Handler);   
      I2 x0 N* P  }/ M
94.     //创建usart0任务
    $ ^- e. n7 j+ l; J3 `
95.     xTaskCreate((TaskFunction_t )usart0_task,     
    
96.                 (const char*    )"usart0_task",   
    
97.                 (uint16_t       )USART0_STK_SIZE,
    1 ^( ^9 P* E# z' i9 @/ x# B
98.                 (void*          )NULL,
    2 E; Q9 ]4 \  z, _# F
99.                 (UBaseType_t    )USART0_TASK_PRIO,
    8 K" F6 u  `: G* b: |% y0 o. i. m
100.                 (TaskHandle_t*  )&USART0Task_Handler);
     
101.                 //创建temper0任务
       L- A. [1 M3 \/ @# ?  T
102.     xTaskCreate((TaskFunction_t )temper0_task,     
     9 \- L1 Q  H: |) y8 j; u
103.                 (const char*    )"temper_task",   
     
104.                 (uint16_t       )TEMPER0_STK_SIZE,
     ) c4 ]7 p- h" {; G7 x
105.                 (void*          )NULL,
       Q5 ^! @( }- w& }
106.                 (UBaseType_t    )TEMPER0_TASK_PRIO,
     0 G" V9 A+ r4 r! D
107.                 (TaskHandle_t*  )&TEMPER0Task_Handler);
     2 Q) K2 Y: S& ?) D9 r, x. H/ Y
108.                                 
     . B. n& E/ C5 @3 w% D4 n. W
109.         xTaskCreate((TaskFunction_t )LCD_TO_task,     
     
110.                 (const char*    )"LCD_TO_task",   
     ; D0 d! v% e5 ~& S  _
111.                 (uint16_t       )LCD_TO_STK_SIZE,
     
112.                 (void*          )NULL,
     
113.                 (UBaseType_t    )LCD_TO_TASK_PRIO,
     
114.                 (TaskHandle_t*  )&LCD_TOTask_Handler);
     + S7 ^: ^. l* F
115.                                 
     : M) [: T+ j+ Q& o
116.     vTaskDelete(StartTask_Handler); //删除开始任务
     
117.     taskEXIT_CRITICAL();            //退出临界区
     ( M+ |3 Y7 d7 F8 r8 @9 z+ f! r
118. }
     # l2 [/ T' ~+ J2 s/ ^6 ?
119. 
     % e4 X3 u% i& j, h4 W$ s
120. 
     % @" [+ A: e' i0 w
121. //LED0任务函数
     
122. void led0_task(void *pvParameters)
     , m1 V2 a1 H! [; h. _9 o  z
123. {
     
124.     while(1)
     
125.     {
     ( c- O3 v" n* U6 P
126.         LED0=~LED0;
     / r6 ?' S/ O, f: I# o
127.                                 if(LED0==1)
     
128.                                         printf("灯灭\r\n");
     
129.                                 else
     9 g0 ^1 Y0 |3 B  m
130.                                         printf("灯亮\r\n");
     
131.         vTaskDelay(1000);
     
132.     }
     + D; r) M1 n# W, Q* c
133. }   
     
134. 
     + F) Q) {% Q) \' \( `! G+ C
135. 
     
136. //usart0任务函数
     
137. void usart0_task(void *pvParameters)
     
138. {
     
139.         
     
140.                         while(1)
     + o- J0 q8 t/ K5 r+ [
141.                         {        
     
142.                                 printf("hello lee");
     
143.                                 printf("\r\n");
     9 ?" Q- b" y2 V) D* C- d
144.                                 vTaskDelay(1000);
     
145.                         }
     
146. }
     / ^; `/ O- t! Y6 y" G$ r
147. 
     5 w4 U1 p0 ]3 k
148. //temper0任务函数(暂时为LED1翻转)
     & c# [) v: V+ b8 u2 p2 @
149. void temper0_task(void *pvParameters)
     
150. {
     * h" A7 ]8 ^- v0 m. B6 h! t
151.                                        
     6 c8 Z% ~4 _3 l6 h3 @! J: F
152.                         while (1)
     
153.                         {        
     ) e$ o9 Z" H+ Q0 V
154.                                 LED1=~LED1;
     + r8 C* _- c  z7 ?+ D' r6 k
155.                                 vTaskDelay(1000);                        
     
156.                         }
     
157. }
     0 Y( T$ D" {" X- n6 l2 a
158. 
     
159. void LCD_TO_task(void *pvParameters)
     
160. {
     3 R5 k% v6 L# \5 W3 f
161.         u8 lcd_id[12];
     
162.         sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);        
     : }9 e2 H( @" ]4 K! i
163.         while (1)
     ! ~# E9 n5 G0 I6 _$ e
164.                 {        
     " X# _- B6 a- u; r
165.                 LCD_ShowString(30,40,210,24,24,"WarShip STM32 ^_^");
     
166.                 LCD_ShowString(30,70,200,16,16,"TFTLCD TEST");
     3 q2 S( b; P1 a# @
167.                 LCD_ShowString(30,90,200,16,16,"DARKSTARS");
     
168.                  LCD_ShowString(30,110,200,16,16,lcd_id);                //显示LCD ID
     * l4 V& B: m! x# ~( [1 a& o
169.                 LCD_ShowString(30,130,200,12,12,"2020/12/4");
     1 @; c: X  ]" t$ k/ m1 v+ w
170.                 vTaskDelay(1000);        
     ( B& Z, @+ y" u, o( ?
171.                 }
     
172. }
     ) w7 ]- y7 V6 o) _" w: ]. m

复制代码

" t6 J5 c* I5 b# {% U8 ?; n  A* t

% f5 I3 m; U: C8 y+ L* M


9 O1 E! a; s, |8 s
/ d0 @% W- K# X总结
通过这次系统的移植，我感受到系统的魅力，有了系统之后，许多程序就能并行运行了，这样我们就能完成更加高效，更加同步的信息处理和信息传输。对于高刷新率的信息处理，移植系统无疑是更好的选择。


) [' \* I/ B1 Y; v4 f6 M

# \0 ]+ Q; r( E