一、源码处理
文件下载
1、官网下载源码
4 C- _9 N. s5 ]3 z
' q& X: p5 A0 c% P

2、找到相关的例程

) k( Q2 t' V+ a. I- e
6 N6 D) ^8 w- a1 `3、进入源码文件

  \. u- `, N& }4 k; N/ c# O+ I7 @
2 k& H$ c( \- a4、找到相关的文件
5 u. Y5 l9 C. P8 k+ ]( M
3 o, L0 A8 w( Q  ^( J% C/ G

keil、RVDS为需要的文件，MemMang为需要的内存文件
9 P) z8 H; _- O
文件移植
" v3 A: J* Z' X. m: a- N" j1、在之前led灯程序基础上添加文件
# t8 |. M8 R3 z7 ]0 r+ [5 `注释：在正点原子开源工程里可以下载
+ C- G# F  b* D( x

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

复制代码

9 S4 y; Q) L" Q/ C2、将相关.h文件包含进去

- `7 V6 H) V- Y" a

) O2 q( F, ~7 G& P此时编译会报错
2 f5 z  |& G- n9 u  q% g继续包含所需要的文件

/ b6 Z4 _7 I. ?: `4 [. `/ ~: w
文件地址：

3、修改相关文件
8 D5 u9 W6 w9 t& H( I" s; G
% _9 B4 r# ?+ o: w4 e. f7 w; P! q注释：正点原子给的工程例程是支持ucos的，所以我们需要把一些oc相关的删除掉
( v3 R5 L4 K' P  D- c以下是修改之后程序代码：
6 z% J% c4 p" ]9 X& _# ]$ A4 Usys.h
& b( v6 g( p: {1 y! F( D3 c+ k

usart.c

; x& _7 w5 [3 `9 _7 A
' D+ \% A' T% Z: _" F2 `原来是include.h，需要改成FreePTOS.h
% I' b, P0 Y. `/ {: w6 l
delay.c

  H: Q7 s" m$ j6 L0 U1 y1:SysTIck_Handler()

1. extern void xPortSysTickHandler(void);
   
2. 
   
3. //systick中断服务函数,使用ucos时用到
   6 M$ p1 Q; ]. P
4. void SysTick_Handler(void)
   
5. {        
   4 f+ J0 W( i7 @( y8 j
6.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
   
7.     {
   
8.         xPortSysTickHandler();        
   
9.     }
   
10. }

复制代码

2:delay_init

1 F# E6 R1 w; ]/ Y- k6 |

1. oid delay_init()
   * F0 R* {" b3 k. j; J8 L% {
2. {
   ' M2 q2 P  w; L: x
3.         u32 reload;
   , S2 e! e9 h* b6 }1 B* n: @* S! S
4.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);//选择外部时钟  HCLK
   ; {) s6 c: [/ }- R8 n
5.         fac_us=SystemCoreClock/1000000;                                //不论是否使用OS,fac_us都需要使用
   ; U  U: F1 n8 {
6.         reload=SystemCoreClock/1000000;                                //每秒钟的计数次数 单位为M  
   
7.         reload*=1000000/configTICK_RATE_HZ;                        //根据configTICK_RATE_HZ设定溢出时间
   # T  S4 W4 x- V1 _0 \  E5 y5 D# u/ w
8.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合0.233s左右        
   - P/ V* T  k& f- g4 j- V4 z
9.         fac_ms=1000/configTICK_RATE_HZ;                                //代表OS可以延时的最少单位           
   
10. 
    6 Y# X+ \: V5 F
11.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
    
12.         SysTick->LOAD=reload;                                                 //每1/configTICK_RATE_HZ秒中断一次        
    % V' L3 x1 x. K7 B4 B/ m0 ]$ I
13.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
    
14. }

复制代码

3:两个延时函数

1. //延时nus
   
2. //nus:要延时的us数.        
   0 D- u) |1 W2 M- a2 F4 n
3. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                                                              
   
4. void delay_us(u32 nus)
   
5. {               
   % `1 W6 ~: R( u" B7 i
6.         u32 ticks;
   
7.         u32 told,tnow,tcnt=0;
   
8.         u32 reload=SysTick->LOAD;                                //LOAD的值                     
   
9.         ticks=nus*fac_us;                                                 //需要的节拍数
   
10.         told=SysTick->VAL;                                        //刚进入时的计数器值
    ) i; G6 t: p" V5 c$ v6 b9 ]3 f
11.         while(1)
    - L" ]* W  b* D, h
12.         {
    , D$ C/ @+ s: N9 S! i' b; C
13.                 tnow=SysTick->VAL;        
    
14.                 if(tnow!=told)
    
15.                 {            
    ! c/ ^1 h2 P0 Y; R7 \
16.                         if(tnow<told)tcnt+=told-tnow;        //这里注意一下SYSTICK是一个递减的计数器就可以了.
    
17.                         else tcnt+=reload-tnow+told;            
    3 W3 K- l5 |+ |  X
18.                         told=tnow;
    . M) M7 H! w% p8 q/ w( h
19.                         if(tcnt>=ticks)break;                        //时间超过/等于要延迟的时间,则退出.
    
20.                 }  
      _/ q% y7 e* A1 V3 q6 v7 Z9 S
21.         };                                                                                    
    ! d) |" r5 F2 T+ j
22. }  
    
23. //延时nms
    ; R  X% D( {. b7 U! M1 b
24. //nms:要延时的ms数
    % w1 k3 H! W% _  k7 H' v
25. //nms:0~65535
    6 S1 c2 y. N( y' s4 W
26. void delay_ms(u32 nms)
    
27. {        
    
28.         if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    0 }& t. t& U. r" P3 D
29.         {               
      ^  P2 e, ]+ _" E
30.                 if(nms>=fac_ms)                                                //延时的时间大于OS的最少时间周期
    * G) n9 t3 n" a5 y- Y3 r
31.                 {
    5 a; C$ d2 L" V. T* O
32.                            vTaskDelay(nms/fac_ms);                         //FreeRTOS延时
    
33.                 }
    
34.                 nms%=fac_ms;                                                //OS已经无法提供这么小的延时了,采用普通方式延时   
    + x8 h; j, Z7 l2 S0 f$ F
35.         }
    5 M# a# @$ m! \0 D$ S1 M
36.         delay_us((u32)(nms*1000));                                //普通方式延时
    
37. }
    
38. 
    - l- ], n4 G! B) I2 }
39. //延时nms,不会引起任务调度
    
40. //nms:要延时的ms数
    0 O, P: O" {# M, X8 U4 {
41. void delay_xms(u32 nms)
    1 l# X& b' X, b1 R  H8 t
42. {
    * U& i3 G$ q" ]' a: N/ S) t
43.         u32 i;
    
44.         for(i=0;i<nms;i++) delay_us(1000);
    
45. }

复制代码

4、屏蔽中断
) D" g; w2 g, F* g
+ X  x$ \/ |0 c5 a3 T

9 L! |7 C; q  d- k/ S0 o$ ^& [5、最后编译一下，就创建成功啦！！！
9 B1 N( e$ s8 @( d! ~
创建任务并执行任务
创建任务分以下步骤:

1. 设置任务优先级
   
2. 设置任务堆栈大小
   4 F, i3 ]& ~# l: n7 \, f
3. 设置任务句柄
   8 e7 `3 v  f6 E( W
4. 设置任务函数

复制代码

我创建了一个任务，使得两个灯同时闪烁，以及串口输出Halloword，以及在移植OLED屏幕的程序
5 p+ Y& D) N4 _, f( V0 O$ c" L' {* h* P  ~
0 F& s: {0 G5 b/ [9 l3 J7 ?- {' `OLED程序移植相对简单，只需要把相关文件夹进去就行
这是移植所需要的的一些相关文件：

" a8 j1 y; R. v% J' N
其中NRF24L01.c是无线通信模块的，我还在肝中，有需要请私信我。
主函数：

  I& Z# k+ s$ T

1. #include "sys.h"
   ' U1 W9 b' }  M( p0 z3 S( E3 l
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   0 G( Y+ d6 h. P; D7 s) b
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   , v) |* U" |. D
7. #include "lcd.h"
   4 }4 j8 e6 n, c( x# {/ b6 T
8. 
   ( ~+ R2 f' g$ V! ^7 e3 z
9. //任务优先级
   
10. #define START_TASK_PRIO                1
      N" Y# H9 W$ ^, m8 A
11. //任务堆栈大小        
    # I! E- _# n2 o
12. #define START_STK_SIZE                 128  
    
13. //任务句柄
    + V" |0 f9 C3 R. h0 h4 x5 X: i9 `; Y
14. TaskHandle_t StartTask_Handler;
    
15. //任务函数
    6 A, m% e/ \- v4 J) K/ ]. \
16. void start_task(void *pvParameters);
    
17. 
    * r7 u. S8 s, f: g  ]  S% d
18. 
    
19. //任务优先级
    8 W$ B% D- T7 I2 U8 @
20. #define LED0_TASK_PRIO                2
    
21. //任务堆栈大小        
    
22. #define LED0_STK_SIZE                 50  
    4 `, x. t; n# Z& y1 o" @" D- ^
23. //任务句柄
    ! Y2 P# D8 N1 F" F3 l
24. TaskHandle_t LED0Task_Handler;
    
25. //任务函数
    
26. void led0_task(void *pvParameters);
    . W# |- {1 e, e" q3 V
27. 
    & c; B$ P& ]1 z+ |5 u
28. //任务优先级
    
29. #define USART0_TASK_PRIO                3
    
30. //任务堆栈大小        
    
31. #define USART0_STK_SIZE                 50  
    
32. //任务句柄
    
33. TaskHandle_t USART0Task_Handler;
    
34. //任务函数
    - C' U6 H+ X1 ^+ S- X& T& f; g
35. void usart0_task(void *pvParameters);
    
36. 
    
37. 
      f& {5 r  r4 V# S8 w0 q
38. //任务优先级
    $ k3 y- F# C8 q1 ~9 X4 d
39. #define TEMPER0_TASK_PRIO                4
    
40. //任务堆栈大小        
    + s+ S& b! U& W
41. #define TEMPER0_STK_SIZE                 50  
    ( k/ U! Z2 G& j0 \4 m
42. TaskHandle_t TEMPER0Task_Handler;
    
43. //任务函数
    
44. void TEMPER0_task(void *pvParameters);
    
45. 
    
46. 
    
47. //任务优先级
    
48. #define LCD_TO_TASK_PRIO                5
    
49. //任务堆栈大小        
    
50. #define LCD_TO_STK_SIZE                 50  
    
51. //任务句柄
    
52. TaskHandle_t LCD_TOTask_Handler;
    % `# U) }% t7 f5 r
53. //任务函数
    
54. 
    
55. void LCD_TO_task(void *pvParameters);
    
56. //任务句柄
    ( M$ f; N) e! F1 _9 l2 k
57. 
    9 F3 H7 q# [- E& I! o# Z5 \9 b
58. TaskHandle_t TEMPER0Task_Handler;
    / w$ Q" F- h* \- W# y3 K3 L7 [
59. //任务函数
    
60. 
    
61. void temper0_task(void *pvParameters);
    , F" L) ]* B( Q
62. int main(void)
    
63. {
    
64.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    
65.         delay_init();                                            //延时函数初始化         
    . w2 ~8 M. ^' ]& X/ m$ S6 u4 {
66.         uart_init(115200);                                        //初始化串口
    - f6 X9 b- K$ q% f
67.         LED_Init();
    . ?( `( L  w5 W4 F" Q! _
68.         //初始化LED
    
69.         LCD_Init();
    
70.         POINT_COLOR=RED;
    9 i: @( @% m& r% ]
71.         //初始化LCD
    
72.         
    8 A$ J% o- A7 e
73.         //创建开始任务
    # j$ i5 n3 |6 y7 y3 |- r. _
74.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    
75.                 (const char*    )"start_task",          //任务名称
    
76.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
77.                 (void*          )NULL,                  //传递给任务函数的参数
    3 G' f! q6 y: _! x2 _+ x. `
78.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
79.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    + [- C, j) j* p) B. Z4 v9 w2 l
80.     vTaskStartScheduler();          //开启任务调度
    4 u% g6 ~: p; s3 l- z: g; L9 v
81. }
    
82. 
    
83. //开始任务任务函数
    
84. void start_task(void *pvParameters)
    
85. {
    
86.     taskENTER_CRITICAL();           //进入临界区
    / G2 u, v5 b0 _* u: k- Q
87.     //创建LED0任务
    - g" |/ ^8 ?$ i1 n$ J0 v* s
88.     xTaskCreate((TaskFunction_t )led0_task,            
    7 f+ K) X4 Y; l' n
89.                 (const char*    )"led0_task",           
    
90.                 (uint16_t       )LED0_STK_SIZE,
    
91.                 (void*          )NULL,                                
    ! c" Z" c. ?- P5 S3 L; W) {5 {( @
92.                 (UBaseType_t    )LED0_TASK_PRIO,        
    7 c6 {4 _, ?5 X
93.                 (TaskHandle_t*  )&LED0Task_Handler);   
    + ]4 ]8 _5 n) x+ t' Y* Q4 \7 P
94.     //创建usart0任务
    / a2 N! |& i, y' X# Z
95.     xTaskCreate((TaskFunction_t )usart0_task,     
    
96.                 (const char*    )"usart0_task",   
    ( C4 V  U6 Q9 M; T, c
97.                 (uint16_t       )USART0_STK_SIZE,
    
98.                 (void*          )NULL,
    / y% B- y9 L' v% Q, E8 z
99.                 (UBaseType_t    )USART0_TASK_PRIO,
    ! M8 k5 Z: K2 @+ g8 _- [
100.                 (TaskHandle_t*  )&USART0Task_Handler);
     
101.                 //创建temper0任务
       t& \" m4 B1 C7 j. u$ ~
102.     xTaskCreate((TaskFunction_t )temper0_task,     
     ) S* `4 H& s, ?& Z6 a& }: Q
103.                 (const char*    )"temper_task",   
     + X2 C) g# i- l
104.                 (uint16_t       )TEMPER0_STK_SIZE,
     : Q6 o; [" S6 k4 w
105.                 (void*          )NULL,
     1 m4 Q! h: [0 L  a, C
106.                 (UBaseType_t    )TEMPER0_TASK_PRIO,
     
107.                 (TaskHandle_t*  )&TEMPER0Task_Handler);
     
108.                                 
     6 |4 H/ ~+ k3 ~* h. U7 ?1 b
109.         xTaskCreate((TaskFunction_t )LCD_TO_task,     
     
110.                 (const char*    )"LCD_TO_task",   
     6 t# }# S# O+ z* N' ?! g! X5 F# ^0 l
111.                 (uint16_t       )LCD_TO_STK_SIZE,
       `, A  X7 I4 m+ w  P# x
112.                 (void*          )NULL,
     
113.                 (UBaseType_t    )LCD_TO_TASK_PRIO,
     
114.                 (TaskHandle_t*  )&LCD_TOTask_Handler);
     
115.                                 
     * f, U4 r0 h5 \: p! t/ {
116.     vTaskDelete(StartTask_Handler); //删除开始任务
     
117.     taskEXIT_CRITICAL();            //退出临界区
     : t/ p, N; G9 R0 U3 h
118. }
     
119. 
     
120. 
     
121. //LED0任务函数
     7 w  W$ `7 L& {) q
122. void led0_task(void *pvParameters)
     
123. {
     
124.     while(1)
     ; O" ~) B9 ^6 o0 S- \) t
125.     {
     
126.         LED0=~LED0;
     : y) t) G# x: {) a/ V0 G
127.                                 if(LED0==1)
     
128.                                         printf("灯灭\r\n");
     $ t* l. H% h0 e9 c7 \0 q
129.                                 else
     $ ?) C9 V2 q3 ?5 x8 p
130.                                         printf("灯亮\r\n");
     
131.         vTaskDelay(1000);
     
132.     }
     
133. }   
     
134. 
     & k( P0 P8 S) k) ~. P, D# t6 Q; L
135. 
     & m0 O! Q) P/ \$ ?/ i  _
136. //usart0任务函数
     : h3 q% q; X5 [2 D( W' b. g
137. void usart0_task(void *pvParameters)
     1 t. a8 a* W; ?7 P" Y$ R7 _6 r
138. {
     & U- _) @  T4 o1 m
139.         
     9 ^1 o7 r6 \( \# B1 C# T$ o3 U
140.                         while(1)
     
141.                         {        
     
142.                                 printf("hello lee");
     
143.                                 printf("\r\n");
     
144.                                 vTaskDelay(1000);
     $ E; {! j2 U0 B9 b3 q
145.                         }
     
146. }
     
147. 
     % c( L6 _7 @$ E. [% d6 t
148. //temper0任务函数(暂时为LED1翻转)
     1 E3 ?( Y8 j1 y
149. void temper0_task(void *pvParameters)
     
150. {
     
151.                                        
     
152.                         while (1)
     
153.                         {        
     + w# b4 y9 i" ^8 j
154.                                 LED1=~LED1;
     ( u; y' q/ X( u. }6 \, w
155.                                 vTaskDelay(1000);                        
     ( Q; I; q2 Y. q: W; {
156.                         }
     , y% A0 l& f  R7 Z) l& A) I
157. }
     8 M+ p' {0 N# C3 Z7 P5 W' \
158. 
     ! o! w) D* Y8 r$ a8 ~
159. void LCD_TO_task(void *pvParameters)
     " q( o1 {3 n! D
160. {
     3 W  v# i# U0 k% M9 L+ {$ Q7 ?
161.         u8 lcd_id[12];
     & u; L% M8 _4 a- J, [/ t- ~
162.         sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);        
     , U# f; F2 t. w% n, e; S$ j
163.         while (1)
     
164.                 {        
     , l2 Z; a9 B5 [3 |& S9 A
165.                 LCD_ShowString(30,40,210,24,24,"WarShip STM32 ^_^");
     
166.                 LCD_ShowString(30,70,200,16,16,"TFTLCD TEST");
     ( t1 F2 h" W( I1 A( n+ Y, a
167.                 LCD_ShowString(30,90,200,16,16,"DARKSTARS");
     1 ~3 P) r1 {& X. N9 Y* M  ?
168.                  LCD_ShowString(30,110,200,16,16,lcd_id);                //显示LCD ID
     
169.                 LCD_ShowString(30,130,200,12,12,"2020/12/4");
     4 e+ Q" T+ l8 m" e8 [
170.                 vTaskDelay(1000);        
     7 t# E0 m  V$ U* e( A5 h
171.                 }
     ( X5 z2 G  q9 c7 \" y3 v
172. }
     

复制代码

- R" C. r3 ?' M2 n" y9 S

9 P) `4 S0 e3 Z# V5 {! |  F

# Y& u4 U" x- k( D) s- T
总结
通过这次系统的移植，我感受到系统的魅力，有了系统之后，许多程序就能并行运行了，这样我们就能完成更加高效，更加同步的信息处理和信息传输。对于高刷新率的信息处理，移植系统无疑是更好的选择。



% V) |2 ?% p. H