一、源码处理
9 q1 G) x5 Z7 R/ {# g* r文件下载
9 k3 z% m9 D+ b3 r) y6 \1、官网下载源码

8 l6 {1 t2 i4 D4 W% F* \6 _2 g

" |& o8 ~  V, {$ c
. s8 v# G- K4 i% R! Z: A1 W% f2、找到相关的例程

: ~( r+ m+ q( a9 D& @+ F3 {$ R( [
3、进入源码文件
' r0 u( M) `/ Q

( U$ v: |4 [- s1 q# T* }- I4、找到相关的文件

$ n( c+ z. t: Y! Q6 e

keil、RVDS为需要的文件，MemMang为需要的内存文件
1 b9 A. @; Z5 A4 g! h, D: [4 [
! d6 q. _2 C1 Z' h4 L( \! V- |( P文件移植
1、在之前led灯程序基础上添加文件
+ r! _% ^3 _' g, [4 q% S9 f4 M- f) }注释：在正点原子开源工程里可以下载
7 U  {& u3 t5 ?

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

复制代码

: B5 O; A6 M. E1 s7 c: T
2、将相关.h文件包含进去

  \; {4 ]* G/ s; k, f" w. i; k1 s

7 l9 C  C7 k: O此时编译会报错
, z+ X& k5 r& F: x继续包含所需要的文件
* ^6 F8 `- U0 b$ F9 h
: W( L7 n" ?; t

文件地址：
, n7 Z/ W: z- R5 O& Y7 v  C1 O4 r

+ H( |+ T; Q: }# j' ~) w- m7 I8 j
3、修改相关文件
: I  ~/ C1 R' C! i! L2 J  T7 E: L
' Y! b9 b" t  H* `8 n注释：正点原子给的工程例程是支持ucos的，所以我们需要把一些oc相关的删除掉
* ~$ I8 p. A, v5 y7 x以下是修改之后程序代码：
sys.h
/ ?+ b) T, M/ X- _

! `3 g$ ?. x" g, M" a2 ?
usart.c

/ q' z7 o, o1 Q% M+ n原来是include.h，需要改成FreePTOS.h
0 ^" B3 z8 m6 Y2 `: V, G
delay.c

1:SysTIck_Handler()
" E9 R6 k) l* w6 p9 x" `0 e

1. extern void xPortSysTickHandler(void);
   
2. 
   
3. //systick中断服务函数,使用ucos时用到
   
4. void SysTick_Handler(void)
   
5. {        
   
6.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
   
7.     {
   
8.         xPortSysTickHandler();        
   3 S0 \2 R$ v8 M) ]: ]6 j2 D
9.     }
   
10. }

复制代码

" K* L+ d; K# q, }' m2 v/ p2:delay_init
1 e# s1 F. r7 c) P3 M- p  ^
$ t) I1 ?# R5 G: I

1. oid delay_init()
   . ~) G* Z, y: T
2. {
   8 u  a3 f- J* \' I- B0 a. P! S7 o% a
3.         u32 reload;
   
4.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);//选择外部时钟  HCLK
   5 x3 ~  j/ W4 j3 A; E9 r
5.         fac_us=SystemCoreClock/1000000;                                //不论是否使用OS,fac_us都需要使用
   
6.         reload=SystemCoreClock/1000000;                                //每秒钟的计数次数 单位为M  
   7 T3 B* b2 [4 w7 T* d9 K
7.         reload*=1000000/configTICK_RATE_HZ;                        //根据configTICK_RATE_HZ设定溢出时间
   
8.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合0.233s左右        
   
9.         fac_ms=1000/configTICK_RATE_HZ;                                //代表OS可以延时的最少单位           
   2 @- l/ s3 @3 q- _% t
10. 
    0 @; C( V; s; f$ p/ i- F  l- T4 A. N2 \
11.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
    4 M$ z$ S3 p+ A1 Y6 {8 Q/ q
12.         SysTick->LOAD=reload;                                                 //每1/configTICK_RATE_HZ秒中断一次        
    
13.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
    
14. }

复制代码

3:两个延时函数

1. //延时nus
     ?" I3 Z- G$ N  W  [  [
2. //nus:要延时的us数.        
   # s$ L0 E8 u$ }+ X
3. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                                                              
   
4. void delay_us(u32 nus)
   
5. {               
   5 E- n% j  E8 b- z8 J/ n  {
6.         u32 ticks;
   
7.         u32 told,tnow,tcnt=0;
   ! ^. u2 b1 f& `% A  q5 R& L9 j, I9 ~
8.         u32 reload=SysTick->LOAD;                                //LOAD的值                     
   $ V0 y, Y% |' V/ o  i0 r
9.         ticks=nus*fac_us;                                                 //需要的节拍数
   3 F1 [2 S( |0 C3 F7 I) K  n. z
10.         told=SysTick->VAL;                                        //刚进入时的计数器值
    - p- Z) ]7 M5 c. P4 k: d* m$ `
11.         while(1)
    
12.         {
    
13.                 tnow=SysTick->VAL;        
    " I. ~) D+ X2 H: B
14.                 if(tnow!=told)
    # e. P- V. D+ e* ?$ |
15.                 {            
    0 i! ?5 ^& b3 J9 S. t, T9 J/ l
16.                         if(tnow<told)tcnt+=told-tnow;        //这里注意一下SYSTICK是一个递减的计数器就可以了.
    
17.                         else tcnt+=reload-tnow+told;            
    
18.                         told=tnow;
    2 a7 V! i/ O) E: j, F) _% C4 c! B# x
19.                         if(tcnt>=ticks)break;                        //时间超过/等于要延迟的时间,则退出.
    9 B6 Z) a6 ~+ f
20.                 }  
    
21.         };                                                                                    
    ' i8 g4 j" J7 ^3 E% H) x
22. }  
    ! b" Q  M  X3 k& `) h2 g2 i3 f& ^
23. //延时nms
    5 x  ?8 N0 V' i7 n; @5 o  K' J% A" h9 A
24. //nms:要延时的ms数
    0 h% Y8 s# t7 Z+ `6 ?
25. //nms:0~65535
    
26. void delay_ms(u32 nms)
    
27. {        
    
28.         if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    
29.         {               
    6 C2 S- J4 s* U+ A0 M: t
30.                 if(nms>=fac_ms)                                                //延时的时间大于OS的最少时间周期
    
31.                 {
    ( U7 Q, d: Z: v5 M/ W
32.                            vTaskDelay(nms/fac_ms);                         //FreeRTOS延时
    
33.                 }
    , D" r! d. D5 t
34.                 nms%=fac_ms;                                                //OS已经无法提供这么小的延时了,采用普通方式延时   
    # J( \) b3 F2 o
35.         }
    
36.         delay_us((u32)(nms*1000));                                //普通方式延时
    % B& R2 m+ ^9 O2 ^
37. }
    
38. 
    . u* g  }6 W7 V
39. //延时nms,不会引起任务调度
    
40. //nms:要延时的ms数
    
41. void delay_xms(u32 nms)
    
42. {
    
43.         u32 i;
    * A* z; S# \" k/ S
44.         for(i=0;i<nms;i++) delay_us(1000);
    
45. }

复制代码

4、屏蔽中断
( v5 L. d# o1 @& X
# {6 v& W/ E' p

+ c% {' x0 B: o2 h/ j# Q8 G5、最后编译一下，就创建成功啦！！！

% Y7 l: {: x& A8 a6 R2 m7 n: m创建任务并执行任务
创建任务分以下步骤:
3 w  [5 k" y8 Y; S. w% i- a

1. 设置任务优先级
   
2. 设置任务堆栈大小
   / J& }2 v# s: V8 M
3. 设置任务句柄
   
4. 设置任务函数

复制代码

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

- f0 p2 Z+ f9 s6 ?, wOLED程序移植相对简单，只需要把相关文件夹进去就行
这是移植所需要的的一些相关文件：

% p; c+ {/ e$ l! U
其中NRF24L01.c是无线通信模块的，我还在肝中，有需要请私信我。
. x8 U: z( x4 v' x6 c! U7 U主函数：

1. #include "sys.h"
   
2. #include "delay.h"
   0 a! N. K* D' d$ j
3. #include "usart.h"
   : [8 A* E9 t3 S" t( C
4. #include "led.h"
   
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   
7. #include "lcd.h"
   
8. 
   
9. //任务优先级
   
10. #define START_TASK_PRIO                1
    
11. //任务堆栈大小        
    
12. #define START_STK_SIZE                 128  
    
13. //任务句柄
    " z9 }& b+ U) @
14. TaskHandle_t StartTask_Handler;
    - P) W6 {; s; U
15. //任务函数
    5 C0 r  m3 x! p* J1 D9 f
16. void start_task(void *pvParameters);
    5 R$ l5 g' \) d: J! b4 N5 D
17. 
    
18. 
    6 ?' I" l- e8 h2 h
19. //任务优先级
    % i. n/ A/ h" z
20. #define LED0_TASK_PRIO                2
    
21. //任务堆栈大小        
    
22. #define LED0_STK_SIZE                 50  
    + v/ g! m3 l. Q
23. //任务句柄
    ) r- X, n9 V6 {4 Y0 p
24. TaskHandle_t LED0Task_Handler;
    
25. //任务函数
    
26. void led0_task(void *pvParameters);
    
27. 
    
28. //任务优先级
    
29. #define USART0_TASK_PRIO                3
    + M$ R% ]- n4 o, z" F* C5 `
30. //任务堆栈大小        
    
31. #define USART0_STK_SIZE                 50  
    
32. //任务句柄
    
33. TaskHandle_t USART0Task_Handler;
    1 d- u7 n) Z0 O0 _
34. //任务函数
    
35. void usart0_task(void *pvParameters);
    / J1 d5 G" b" G& r' b! a
36. 
    
37. 
    
38. //任务优先级
    
39. #define TEMPER0_TASK_PRIO                4
    , H" X' p, b/ l, ], q8 R
40. //任务堆栈大小        
    : ~* Z) o5 P/ d
41. #define TEMPER0_STK_SIZE                 50  
      _/ `3 ?4 ]" _  Y! m
42. TaskHandle_t TEMPER0Task_Handler;
    
43. //任务函数
    # e+ N2 d8 |- ^; D, [$ e) \
44. void TEMPER0_task(void *pvParameters);
    * x3 O" k0 t& ]/ f6 g- W$ t
45. 
      i1 G6 p, y( |) k4 n
46. 
    2 H6 D5 p0 b3 t0 \" ~/ E8 u8 o
47. //任务优先级
    
48. #define LCD_TO_TASK_PRIO                5
    3 n0 Z! Y, J( z' S
49. //任务堆栈大小        
    ( D& }/ L& E2 U/ N- b& P3 w& V
50. #define LCD_TO_STK_SIZE                 50  
    
51. //任务句柄
    ( M3 `& |" t7 ~0 o" R
52. TaskHandle_t LCD_TOTask_Handler;
    ! A5 ?. ]3 ?; D4 O! {7 d+ e9 [
53. //任务函数
    
54. 
    % f; \( O; S1 c! N3 g& A6 p
55. void LCD_TO_task(void *pvParameters);
    ' `9 E+ c3 r) Q: q, T1 Q
56. //任务句柄
    
57. 
    / u! d* z" ]4 y6 d  o1 Z* X
58. TaskHandle_t TEMPER0Task_Handler;
    . A- v" G9 Q. S
59. //任务函数
    
60. 
    6 n# K4 I! b, k+ t
61. void temper0_task(void *pvParameters);
    
62. int main(void)
      P+ N# [. S- S9 n
63. {
    
64.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    
65.         delay_init();                                            //延时函数初始化         
    
66.         uart_init(115200);                                        //初始化串口
    6 {/ `7 }0 W3 t. Q1 m
67.         LED_Init();
    
68.         //初始化LED
    8 k: f1 {$ S5 p* S4 I7 j4 Q3 V
69.         LCD_Init();
    
70.         POINT_COLOR=RED;
    7 R! W6 I1 I6 \8 h( ]4 S
71.         //初始化LCD
    
72.         
    
73.         //创建开始任务
    
74.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    9 N8 b$ t. V# t( b
75.                 (const char*    )"start_task",          //任务名称
    
76.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
77.                 (void*          )NULL,                  //传递给任务函数的参数
    ; K. ]) K. C( z' k
78.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
79.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    0 b: ?6 W  n1 |) U! m$ C
80.     vTaskStartScheduler();          //开启任务调度
    , @2 m* F- H4 o! b5 S& F# J; L
81. }
    
82. 
    # j0 S4 w! B+ W$ D- F
83. //开始任务任务函数
    
84. void start_task(void *pvParameters)
    
85. {
    
86.     taskENTER_CRITICAL();           //进入临界区
    
87.     //创建LED0任务
    / P) R7 y% ]5 o  Y
88.     xTaskCreate((TaskFunction_t )led0_task,            
    " Q9 g/ l$ I) }( T, m$ {
89.                 (const char*    )"led0_task",           
    * G# }5 M- b6 b" L0 w. }# ^/ r" i
90.                 (uint16_t       )LED0_STK_SIZE,
    
91.                 (void*          )NULL,                                
      ^* e3 r* ~0 a7 c( h) Q
92.                 (UBaseType_t    )LED0_TASK_PRIO,        
    : L5 e- G9 [5 g  g6 D
93.                 (TaskHandle_t*  )&LED0Task_Handler);   
    
94.     //创建usart0任务
    
95.     xTaskCreate((TaskFunction_t )usart0_task,     
    
96.                 (const char*    )"usart0_task",   
    
97.                 (uint16_t       )USART0_STK_SIZE,
    $ ~9 n1 n5 C0 A- x8 o
98.                 (void*          )NULL,
    8 A" m5 R9 Y4 l9 T9 ^3 a' W7 T
99.                 (UBaseType_t    )USART0_TASK_PRIO,
    2 ^; S0 q( [* e8 m- v: u9 u) n
100.                 (TaskHandle_t*  )&USART0Task_Handler);
     
101.                 //创建temper0任务
     
102.     xTaskCreate((TaskFunction_t )temper0_task,     
     ! |0 W+ s+ J; C7 q5 a- t
103.                 (const char*    )"temper_task",   
     ; Q8 k  L! V/ ?6 P7 x. x1 f+ t
104.                 (uint16_t       )TEMPER0_STK_SIZE,
     
105.                 (void*          )NULL,
     
106.                 (UBaseType_t    )TEMPER0_TASK_PRIO,
     # I3 a- q1 n6 L1 `# _2 f7 E
107.                 (TaskHandle_t*  )&TEMPER0Task_Handler);
     
108.                                 
     
109.         xTaskCreate((TaskFunction_t )LCD_TO_task,     
     
110.                 (const char*    )"LCD_TO_task",   
     
111.                 (uint16_t       )LCD_TO_STK_SIZE,
     
112.                 (void*          )NULL,
     / a8 ^. J" @8 x4 p; B
113.                 (UBaseType_t    )LCD_TO_TASK_PRIO,
     5 l5 b) N; v/ _7 R2 P; r+ x, k
114.                 (TaskHandle_t*  )&LCD_TOTask_Handler);
     8 C3 l( C1 [9 _$ C5 Z9 `7 p6 U1 D
115.                                 
     4 @5 p- p- D/ ~: p' }0 {
116.     vTaskDelete(StartTask_Handler); //删除开始任务
     ' W) S0 S3 Y- g" D, W1 L
117.     taskEXIT_CRITICAL();            //退出临界区
     " N/ c# T4 M: p+ q+ @- A
118. }
     
119. 
     
120. 
     ( w) H! G5 u, \% A! ?  |6 g
121. //LED0任务函数
     
122. void led0_task(void *pvParameters)
     
123. {
     
124.     while(1)
     
125.     {
     
126.         LED0=~LED0;
     
127.                                 if(LED0==1)
     
128.                                         printf("灯灭\r\n");
     
129.                                 else
     
130.                                         printf("灯亮\r\n");
     
131.         vTaskDelay(1000);
     0 F6 I. s! c* R8 o" E
132.     }
     
133. }   
     
134. 
     / a3 @2 v, w  U6 t% M/ V9 P) l1 s
135. 
     
136. //usart0任务函数
     , z2 d/ Y4 u4 m2 W! |
137. void usart0_task(void *pvParameters)
       u9 M) ~3 v; O/ w2 `7 {) J
138. {
     
139.         
     
140.                         while(1)
     
141.                         {        
       \, r4 o/ W. ?
142.                                 printf("hello lee");
     - e* B% s5 y5 Q) ]
143.                                 printf("\r\n");
     4 h+ }5 G8 m& E6 \5 F- V
144.                                 vTaskDelay(1000);
     8 z- h0 \' [/ Y
145.                         }
     
146. }
     # c5 F$ y  ?/ d; y- \& x
147. 
     3 z# N( u7 I8 C% L
148. //temper0任务函数(暂时为LED1翻转)
     
149. void temper0_task(void *pvParameters)
     
150. {
     " E: ^, J3 m0 ?0 T3 M9 i3 V) A
151.                                        
     
152.                         while (1)
     
153.                         {        
     
154.                                 LED1=~LED1;
     ' s- c  y. V6 m+ a$ |6 Z
155.                                 vTaskDelay(1000);                        
     
156.                         }
     3 m" a+ u- O' ]0 o$ S; _1 d5 e
157. }
     4 K: ?( j# F1 J+ R
158. 
     
159. void LCD_TO_task(void *pvParameters)
     ( |  M; V/ f0 M" |9 _; b
160. {
     
161.         u8 lcd_id[12];
     $ F6 }' E: w' s; Y
162.         sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);        
     
163.         while (1)
     6 i* M. K/ x8 W( Y
164.                 {        
     # A$ J! G, T8 B* h* P
165.                 LCD_ShowString(30,40,210,24,24,"WarShip STM32 ^_^");
     ' |" J1 L$ c$ b/ Y6 x" W6 J  t6 z
166.                 LCD_ShowString(30,70,200,16,16,"TFTLCD TEST");
     & H! {( H6 O$ k2 L0 z+ Q8 U* @
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");
     / n& F" v  c- q( \/ I6 ?9 A
170.                 vTaskDelay(1000);        
     6 F, Q# d. p1 D" j  Y& N: t
171.                 }
     3 i1 `! n( i9 r4 y
172. }
     9 c+ K9 A+ ^& p" [

复制代码

: x9 T7 I4 g9 `7 D0 Z

" q# Y1 k+ U% e- M' t; O6 i1 S

% T4 v+ I; [2 N8 i, E

5 J. m4 d+ s2 ^1 r, r6 O7 V4 Q


" E/ `  i4 O& T  X" ]- E
总结
通过这次系统的移植，我感受到系统的魅力，有了系统之后，许多程序就能并行运行了，这样我们就能完成更加高效，更加同步的信息处理和信息传输。对于高刷新率的信息处理，移植系统无疑是更好的选择。




2 ]* P# ^7 y' b$ h) C0 M  F# S, g