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

# i; ]6 v3 s; z* P# u/ I. h4 y2、找到相关的例程
' X5 f0 e3 i' c

/ L& o! k% I1 g5 g; v  a/ S
7 V2 \" L" X5 ]1 ]. W4 z  j3、进入源码文件

5 m+ O% W1 K1 t9 r9 n2 h! [
; }8 r1 z/ d& l3 ?9 Q' v7 n7 O4、找到相关的文件

7 a4 x% x+ j3 D2 d) ]

% C# H8 I+ Q) |
" y3 v  ]/ [7 O+ W- F% Fkeil、RVDS为需要的文件，MemMang为需要的内存文件

  e% I  D$ F+ ~- U8 c# ^  M文件移植
( f' L+ r0 p$ R; B1 h% Z! q2 q2 H) p1、在之前led灯程序基础上添加文件
注释：在正点原子开源工程里可以下载
% m, K( w1 h( b, `# h) K
1 H0 N8 z8 c$ n9 \( `4 J

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

复制代码

4 ^) ]& `7 P7 J& x
2、将相关.h文件包含进去
! y! C1 n5 c7 U8 k
: y% o6 |3 l0 S# ~

此时编译会报错
& J+ [' g/ h8 X& ^$ f9 ^7 U继续包含所需要的文件
  Q3 n& k  C7 K& T7 C) @, B
: t( X1 m" ^& i$ p$ D

文件地址：

4 Z7 V% m/ H. W4 o* r/ t
! @. Z1 j, I, K3 `8 [8 U: n( l! N3、修改相关文件
# ~! ?& f6 _6 V
注释：正点原子给的工程例程是支持ucos的，所以我们需要把一些oc相关的删除掉
以下是修改之后程序代码：
4 Y. m; x4 E; n0 m# O  S  Msys.h
" t. N2 y- d  K  S# @. O; f
) y' b5 W7 c& y! m

usart.c

9 G8 J. ^) N0 a( p2 G% L8 V, z! Y3 ]7 N

1 M8 h+ f, t. i
; i- q" J1 P8 _' ~' \" h原来是include.h，需要改成FreePTOS.h

. H+ B3 o0 s5 J0 j/ u8 odelay.c
3 ?5 w# J1 p( |) Z. x5 |' ^( `
: L% M$ v8 n6 T1:SysTIck_Handler()

1. extern void xPortSysTickHandler(void);
   : u/ Y, F# o3 e# ?5 J4 t# V, J+ w
2. 
   9 W. c  H; T8 ~
3. //systick中断服务函数,使用ucos时用到
   
4. void SysTick_Handler(void)
   
5. {        
   + F# K& n6 q2 O: H0 U
6.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
   ) V7 f# N+ ^0 \9 T3 Z
7.     {
   ! R* b, U  K: z4 O& F1 h
8.         xPortSysTickHandler();        
   + }0 A+ C0 g1 k! |8 ^6 H6 c$ s
9.     }
   , P. V* C; A8 a2 G6 _
10. }

复制代码

# ~$ t( p# a. l2:delay_init

* G! ^9 T+ t" B" Q$ b$ G/ Z

1. oid delay_init()
   
2. {
   ) b% n8 K& X$ m- v8 V
3.         u32 reload;
   
4.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);//选择外部时钟  HCLK
   
5.         fac_us=SystemCoreClock/1000000;                                //不论是否使用OS,fac_us都需要使用
   
6.         reload=SystemCoreClock/1000000;                                //每秒钟的计数次数 单位为M  
   
7.         reload*=1000000/configTICK_RATE_HZ;                        //根据configTICK_RATE_HZ设定溢出时间
   # z! H7 X* H% W  W6 M4 Q+ R8 F
8.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合0.233s左右        
   % g9 N% o4 j9 c2 t0 S6 ~, z
9.         fac_ms=1000/configTICK_RATE_HZ;                                //代表OS可以延时的最少单位           
   0 u6 L" S0 M2 i4 _
10. 
    ) u$ e: N0 a6 M/ L4 R
11.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
    # |2 E7 ?* ~) c! R& L
12.         SysTick->LOAD=reload;                                                 //每1/configTICK_RATE_HZ秒中断一次        
    
13.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
    % G1 G/ Z0 m) K% W+ k
14. }

复制代码

3:两个延时函数

1. //延时nus
   
2. //nus:要延时的us数.        
   . \% n+ N; T; `# a5 ?3 n* `
3. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                                                              
   . W2 Z6 T9 k" h" j0 i4 _7 J5 N( O
4. void delay_us(u32 nus)
   
5. {               
   
6.         u32 ticks;
   8 Y* n& N+ s2 ^) r: b
7.         u32 told,tnow,tcnt=0;
     ^% a, S/ U/ ^; \: Z! G
8.         u32 reload=SysTick->LOAD;                                //LOAD的值                     
   8 D7 i) ?# l5 ~* E, N1 k8 m
9.         ticks=nus*fac_us;                                                 //需要的节拍数
   
10.         told=SysTick->VAL;                                        //刚进入时的计数器值
    # s9 B% m. Q6 j
11.         while(1)
    1 l% @# Y* D- K- w* j1 e6 E. \/ K
12.         {
    
13.                 tnow=SysTick->VAL;        
    8 i$ z+ F! U) `6 h1 c$ U8 h
14.                 if(tnow!=told)
    " S  e+ H- a9 N
15.                 {            
    : ?" P0 W. x: H6 w
16.                         if(tnow<told)tcnt+=told-tnow;        //这里注意一下SYSTICK是一个递减的计数器就可以了.
    * w2 d) N0 B) p$ o5 P, f
17.                         else tcnt+=reload-tnow+told;            
    & l+ i% J$ \- U7 Q1 o4 l# @! U
18.                         told=tnow;
    . y3 d$ |; i  X8 u0 y" G* I5 |
19.                         if(tcnt>=ticks)break;                        //时间超过/等于要延迟的时间,则退出.
    
20.                 }  
    
21.         };                                                                                    
    
22. }  
    0 I5 M& g( u! o7 S' ]( ~4 y# p( m3 B  V
23. //延时nms
    
24. //nms:要延时的ms数
    9 h) `" _9 A; K( {  \/ ?. v! s
25. //nms:0~65535
    8 Y+ a3 T" m& v- j8 W$ d+ o
26. void delay_ms(u32 nms)
    % e: R! W7 ~# J- b* q' v
27. {        
    
28.         if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    
29.         {               
    
30.                 if(nms>=fac_ms)                                                //延时的时间大于OS的最少时间周期
    4 p; W* F2 z: J
31.                 {
    ' H& M( f0 O  g; i) V* S4 y$ p
32.                            vTaskDelay(nms/fac_ms);                         //FreeRTOS延时
    3 c/ H- y  B7 `
33.                 }
    1 D5 c" B4 B( T8 Z* p+ F
34.                 nms%=fac_ms;                                                //OS已经无法提供这么小的延时了,采用普通方式延时   
    
35.         }
    
36.         delay_us((u32)(nms*1000));                                //普通方式延时
    
37. }
    
38. 
    
39. //延时nms,不会引起任务调度
    
40. //nms:要延时的ms数
    ! a5 @3 o+ I+ |$ T) d0 P
41. void delay_xms(u32 nms)
    
42. {
    
43.         u32 i;
    
44.         for(i=0;i<nms;i++) delay_us(1000);
    
45. }

复制代码

4、屏蔽中断

5、最后编译一下，就创建成功啦！！！
+ r" g2 S* V1 D- ?9 u# M
创建任务并执行任务
+ U6 m' u( l. N/ q  F  ?. Y创建任务分以下步骤:
7 u7 M: @" N) ]; B% o* ]+ G) n

1. 设置任务优先级
   
2. 设置任务堆栈大小
   
3. 设置任务句柄
   % i& l+ b2 ?: h5 O
4. 设置任务函数

复制代码

我创建了一个任务，使得两个灯同时闪烁，以及串口输出Halloword，以及在移植OLED屏幕的程序
8 S; ^4 C: p- `
1 f- }3 K% {2 IOLED程序移植相对简单，只需要把相关文件夹进去就行
0 G5 \' l3 S- Z8 o& p这是移植所需要的的一些相关文件：

, @9 o+ L. K- y1 ^
; w0 r# b, J) a# o2 A) g其中NRF24L01.c是无线通信模块的，我还在肝中，有需要请私信我。
7 E# c# x; q/ P# Q0 E$ B* M2 r1 E8 ~# A主函数：
% g2 D. v6 d$ a5 H0 B6 F. l* I$ f) y3 V1 h

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   % F0 n8 `1 C' z8 o
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   ) v3 I8 i& F/ ?- r' }
7. #include "lcd.h"
   
8. 
   + P+ Z* z1 W( i8 K0 R
9. //任务优先级
   8 T  g2 k- x# ^$ o5 ^  z
10. #define START_TASK_PRIO                1
    5 Q1 j$ f$ v+ k1 K
11. //任务堆栈大小        
    
12. #define START_STK_SIZE                 128  
    4 ]- W; [; V' q! Z
13. //任务句柄
    
14. TaskHandle_t StartTask_Handler;
    
15. //任务函数
    ! Y8 e( @7 }- o& F6 R
16. void start_task(void *pvParameters);
    
17. 
    
18. 
    
19. //任务优先级
    
20. #define LED0_TASK_PRIO                2
    6 i( j0 u  m/ \) U8 y0 [+ Z
21. //任务堆栈大小        
    % |2 u) Y8 ~0 f" N2 W
22. #define LED0_STK_SIZE                 50  
    
23. //任务句柄
    
24. TaskHandle_t LED0Task_Handler;
    ) Q5 M  W4 a  ~. s0 A
25. //任务函数
    
26. void led0_task(void *pvParameters);
    
27. 
    ' [$ r, @) [7 L0 C7 n
28. //任务优先级
    
29. #define USART0_TASK_PRIO                3
    & N0 c- h" n$ V& h
30. //任务堆栈大小        
    2 g, \8 J2 J, C
31. #define USART0_STK_SIZE                 50  
    ( \2 e6 J. I1 w( R; W9 K" w( \
32. //任务句柄
    # G, I. c* d) ^5 D0 y
33. TaskHandle_t USART0Task_Handler;
    
34. //任务函数
    4 Q% A8 T6 J" @
35. void usart0_task(void *pvParameters);
    6 ~- i. `6 [0 j6 N8 k1 q9 p
36. 
    
37. 
    
38. //任务优先级
    
39. #define TEMPER0_TASK_PRIO                4
    
40. //任务堆栈大小        
    
41. #define TEMPER0_STK_SIZE                 50  
    , u( ~4 N& m* _2 f. d8 g
42. TaskHandle_t TEMPER0Task_Handler;
    
43. //任务函数
    $ |4 l5 \- b4 O
44. void TEMPER0_task(void *pvParameters);
    5 K) M$ _/ k3 A6 Q# m
45. 
    
46. 
    5 S' E# X& }0 L
47. //任务优先级
    ! J& b, G7 T( Q9 |6 O& V" @
48. #define LCD_TO_TASK_PRIO                5
    2 D3 O8 i$ ~! r" a! y6 L. A* v* H- ~
49. //任务堆栈大小        
    : k8 B* V& N( B
50. #define LCD_TO_STK_SIZE                 50  
    $ D. A3 K0 X  h
51. //任务句柄
    $ K* I6 @% x! f8 t  |. `& L7 n
52. TaskHandle_t LCD_TOTask_Handler;
    
53. //任务函数
    , h5 {1 U; O8 C$ i. c$ b
54. 
    # P7 g# e2 a+ t
55. void LCD_TO_task(void *pvParameters);
    $ V; n1 P- n0 {; B# u5 [/ X5 o' I
56. //任务句柄
    
57. 
    
58. TaskHandle_t TEMPER0Task_Handler;
    
59. //任务函数
    5 o! T6 O/ A4 R% w! r" P7 A
60. 
    
61. void temper0_task(void *pvParameters);
    
62. int main(void)
    
63. {
    8 c0 I# n6 O. g, n0 I
64.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    / H7 B6 I! A8 U% F  n
65.         delay_init();                                            //延时函数初始化         
    / o" b9 a: p7 ~9 l3 G) v0 O! l% d
66.         uart_init(115200);                                        //初始化串口
    
67.         LED_Init();
    
68.         //初始化LED
    ; r- ?9 ^. c) N3 T8 o; h3 ~, z$ y
69.         LCD_Init();
    
70.         POINT_COLOR=RED;
    
71.         //初始化LCD
      s5 T* m" [  ?  F! E* ^
72.         
    - C. z. a8 G/ n. C) n
73.         //创建开始任务
    
74.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    1 f  [& J- I8 s
75.                 (const char*    )"start_task",          //任务名称
    6 @8 `; ^( C' V0 }
76.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    0 e, f: S5 J+ ?
77.                 (void*          )NULL,                  //传递给任务函数的参数
    
78.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    ; m8 C0 d. m! c  j% W, f& q
79.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    6 m6 Y1 p0 _6 S4 d
80.     vTaskStartScheduler();          //开启任务调度
    
81. }
    
82. 
    & p7 v3 g' `; h( x
83. //开始任务任务函数
    
84. void start_task(void *pvParameters)
    2 b5 E3 N) R$ Y4 t. @0 X  M
85. {
    
86.     taskENTER_CRITICAL();           //进入临界区
    ! E% o" K) `: k! B" y0 g3 ?
87.     //创建LED0任务
    
88.     xTaskCreate((TaskFunction_t )led0_task,            
    3 U3 h8 u1 v4 G3 [1 T4 [9 u
89.                 (const char*    )"led0_task",           
    . H" U! w/ H. O* I% m  l" z
90.                 (uint16_t       )LED0_STK_SIZE,
    
91.                 (void*          )NULL,                                
    1 t, K0 D5 W9 D6 ?
92.                 (UBaseType_t    )LED0_TASK_PRIO,        
    5 {( N  x1 o. N( B5 K2 |: r
93.                 (TaskHandle_t*  )&LED0Task_Handler);   
    , J$ V& E5 [, C# T! W0 v$ p/ P/ r
94.     //创建usart0任务
    
95.     xTaskCreate((TaskFunction_t )usart0_task,     
    - b5 q! H6 h. v& T+ _" U
96.                 (const char*    )"usart0_task",   
    
97.                 (uint16_t       )USART0_STK_SIZE,
    
98.                 (void*          )NULL,
    " ?4 b- d: {+ d' d: Z% E8 V
99.                 (UBaseType_t    )USART0_TASK_PRIO,
    
100.                 (TaskHandle_t*  )&USART0Task_Handler);
     
101.                 //创建temper0任务
     
102.     xTaskCreate((TaskFunction_t )temper0_task,     
     
103.                 (const char*    )"temper_task",   
     * ~" z  v/ g+ P/ f7 @
104.                 (uint16_t       )TEMPER0_STK_SIZE,
     ! k+ x8 E5 ?! r# h) [3 l/ P9 M
105.                 (void*          )NULL,
     
106.                 (UBaseType_t    )TEMPER0_TASK_PRIO,
     
107.                 (TaskHandle_t*  )&TEMPER0Task_Handler);
     & b1 r) }) p& l" @; T
108.                                 
     
109.         xTaskCreate((TaskFunction_t )LCD_TO_task,     
     
110.                 (const char*    )"LCD_TO_task",   
     
111.                 (uint16_t       )LCD_TO_STK_SIZE,
     
112.                 (void*          )NULL,
       S3 E8 O/ T3 }, S9 ~  b  `
113.                 (UBaseType_t    )LCD_TO_TASK_PRIO,
     : i7 v/ e4 Q$ G' l, w+ K) @. f; n
114.                 (TaskHandle_t*  )&LCD_TOTask_Handler);
     5 R# K5 j0 C$ b1 |
115.                                 
     - H; X2 ~* d6 T- a" Y' T9 @' t6 p
116.     vTaskDelete(StartTask_Handler); //删除开始任务
       \; |4 k7 w3 E: R2 c/ w
117.     taskEXIT_CRITICAL();            //退出临界区
     
118. }
     ' q% r. {" i* ]1 S
119. 
     
120. 
     5 x' {8 \* z' w% U
121. //LED0任务函数
     ( z8 T( v$ ?9 v
122. void led0_task(void *pvParameters)
     0 ^9 N! C# e, m& f4 A# f
123. {
     
124.     while(1)
     
125.     {
     
126.         LED0=~LED0;
     
127.                                 if(LED0==1)
     
128.                                         printf("灯灭\r\n");
     
129.                                 else
     
130.                                         printf("灯亮\r\n");
     . o9 Q: y3 U2 }  ]: c
131.         vTaskDelay(1000);
     
132.     }
     * l5 _9 n/ U, _) h3 X5 V( f
133. }   
     
134. 
     6 _& ?) k4 O; S! f. w
135. 
     
136. //usart0任务函数
     
137. void usart0_task(void *pvParameters)
     
138. {
     6 f/ v# }5 M+ c
139.         
     7 k. X" T  d+ ]+ i9 h: j
140.                         while(1)
     
141.                         {        
     
142.                                 printf("hello lee");
     
143.                                 printf("\r\n");
     
144.                                 vTaskDelay(1000);
     ' l1 |2 s0 o( A. f; q9 ]- m
145.                         }
     4 `+ C3 y1 e& G$ t4 p5 P# ?0 }/ P
146. }
     
147. 
     
148. //temper0任务函数(暂时为LED1翻转)
     
149. void temper0_task(void *pvParameters)
     ' v, O6 E0 t( e7 z; |1 R/ ^4 ^
150. {
     
151.                                        
     ) G& M% [9 J8 j! }
152.                         while (1)
     
153.                         {        
     
154.                                 LED1=~LED1;
       s! v5 t; \; r3 g
155.                                 vTaskDelay(1000);                        
     
156.                         }
     $ Q# E' V) J$ ^* I! m
157. }
     
158. 
     ! _5 H  K- A# c4 x
159. void LCD_TO_task(void *pvParameters)
     
160. {
     
161.         u8 lcd_id[12];
     
162.         sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);        
     * K2 C; k0 z% X; z, T
163.         while (1)
       {( T1 `# [/ F  ~0 S# R
164.                 {        
     
165.                 LCD_ShowString(30,40,210,24,24,"WarShip STM32 ^_^");
     3 A2 S% V; C7 K: S& B0 J
166.                 LCD_ShowString(30,70,200,16,16,"TFTLCD TEST");
     9 O4 \  _$ y! J8 n7 x, ^! T
167.                 LCD_ShowString(30,90,200,16,16,"DARKSTARS");
     3 l: c7 }4 T- m* i& k7 u6 V5 b
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);        
     ; m6 z0 u3 b& \
171.                 }
     
172. }
     , G! i! P. {+ \: O

复制代码

) ?2 O/ n8 C% B1 A

9 ^% d; e4 R: ^% d% d

& i" W6 {- [7 E6 z( H# B

7 z, r  L" B9 ~7 o, n7 r

6 e; j6 `; w/ W
" S1 g, b7 C; r3 N7 f* \8 S( s+ n
. x4 _0 L1 f3 W' ~总结
通过这次系统的移植，我感受到系统的魅力，有了系统之后，许多程序就能并行运行了，这样我们就能完成更加高效，更加同步的信息处理和信息传输。对于高刷新率的信息处理，移植系统无疑是更好的选择。


$ \3 q, [1 ?3 \