一、源码处理
文件下载
, ~! M  f8 G0 d/ q; S3 [1、官网下载源码

* n) f" y+ I9 |  l

2、找到相关的例程
/ M& v; Y" @: y. g% h7 a

3、进入源码文件
- \- z8 d& A% F' F' r
% d# R& `! |' U2 H3 a2 q3 U

: E6 P+ q" Z2 r
4、找到相关的文件

9 {+ `% g5 r, a1 c5 O, x+ B
5 h0 H# X- j5 L  ^4 S  T5 ekeil、RVDS为需要的文件，MemMang为需要的内存文件

文件移植
! d2 ~- U& s' |* @* J. J1、在之前led灯程序基础上添加文件
注释：在正点原子开源工程里可以下载

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

复制代码

" Q2 m6 q* w: _) s
2、将相关.h文件包含进去

+ M7 F3 H  [( m2 r: Z% q2 C3 n. c

此时编译会报错
继续包含所需要的文件

+ t- Q/ C5 O5 r1 B; J# M9 N( N: D

0 Z( P' u/ t: b% s( T
文件地址：

3、修改相关文件

8 U5 W, C; R" A5 L: |注释：正点原子给的工程例程是支持ucos的，所以我们需要把一些oc相关的删除掉
* J- [+ Z$ A  {" p# y8 Q/ T以下是修改之后程序代码：
sys.h
& f5 }' i$ u* @& q) L. p
3 m$ d$ p3 ?* t2 m' e( \! E; b

usart.c
8 }! x. K) s( X# ^' f* _: J) u. e

7 J5 `  @: }9 v" |9 E% m2 g7 b& c
原来是include.h，需要改成FreePTOS.h
. ]$ G4 n& Z$ i6 c: b
delay.c

1:SysTIck_Handler()

1. extern void xPortSysTickHandler(void);
   
2. 
   
3. //systick中断服务函数,使用ucos时用到
   
4. void SysTick_Handler(void)
   
5. {        
   
6.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
   , }5 A% c* f# l/ r1 H* f
7.     {
   
8.         xPortSysTickHandler();        
   
9.     }
   
10. }

复制代码

# `6 `& O$ O; \1 o6 [' D2:delay_init

4 a( G7 F& L  ]8 e) n

1. oid delay_init()
   2 v! O8 D5 J6 u' b
2. {
   - [4 l4 }- s4 F$ T* d
3.         u32 reload;
   
4.         SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);//选择外部时钟  HCLK
   3 }* ^7 o8 i9 {( o2 ^2 u
5.         fac_us=SystemCoreClock/1000000;                                //不论是否使用OS,fac_us都需要使用
   ) f# Q9 \' |6 o5 b
6.         reload=SystemCoreClock/1000000;                                //每秒钟的计数次数 单位为M  
   
7.         reload*=1000000/configTICK_RATE_HZ;                        //根据configTICK_RATE_HZ设定溢出时间
   ! {& b2 P( G6 k) L7 w( m# 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中断
    4 b' D; y3 D: J
12.         SysTick->LOAD=reload;                                                 //每1/configTICK_RATE_HZ秒中断一次        
    
13.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
    
14. }

复制代码

3:两个延时函数

& v# g( Y3 R8 h, l

1. //延时nus
   * ?& V. \9 O, W
2. //nus:要延时的us数.        
   / J0 B- c$ I7 V# N) E: i4 d
3. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                                                              
   + a9 B/ {. m7 G
4. void delay_us(u32 nus)
   
5. {               
   * Z- m' ]+ h: f
6.         u32 ticks;
   
7.         u32 told,tnow,tcnt=0;
   ) I+ g# |7 `( i. h6 F3 [! v2 }
8.         u32 reload=SysTick->LOAD;                                //LOAD的值                     
   
9.         ticks=nus*fac_us;                                                 //需要的节拍数
   
10.         told=SysTick->VAL;                                        //刚进入时的计数器值
    9 D/ i3 G8 O$ a& [2 y5 l3 v
11.         while(1)
    4 j" l' o: N" O; P  s+ b/ m
12.         {
    
13.                 tnow=SysTick->VAL;        
    
14.                 if(tnow!=told)
    / Q' s4 {  W% t/ G
15.                 {            
    6 B! Q4 e) l1 s
16.                         if(tnow<told)tcnt+=told-tnow;        //这里注意一下SYSTICK是一个递减的计数器就可以了.
    
17.                         else tcnt+=reload-tnow+told;            
    ' C# A/ A4 U" h- F
18.                         told=tnow;
    
19.                         if(tcnt>=ticks)break;                        //时间超过/等于要延迟的时间,则退出.
    
20.                 }  
    
21.         };                                                                                    
    , P) \) m' t6 k" d4 S
22. }  
    
23. //延时nms
    
24. //nms:要延时的ms数
      O$ D% i2 L7 F- U
25. //nms:0~65535
    
26. void delay_ms(u32 nms)
    ' F" E! U3 O: w8 L, W# I: l
27. {        
    & O9 u+ i+ q* ?: p* S. P' J& A+ l
28.         if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    - p, M, C' b; b# _8 w+ U
29.         {               
    
30.                 if(nms>=fac_ms)                                                //延时的时间大于OS的最少时间周期
    # ]. H6 @9 |! ?: |% L2 C
31.                 {
    6 n: r; I5 r- q2 ?) a
32.                            vTaskDelay(nms/fac_ms);                         //FreeRTOS延时
    ; a( e5 |0 |7 l! h4 R
33.                 }
    
34.                 nms%=fac_ms;                                                //OS已经无法提供这么小的延时了,采用普通方式延时   
    
35.         }
    
36.         delay_us((u32)(nms*1000));                                //普通方式延时
    % ~! |( K% @. g
37. }
    & e: d& [: c/ f, M) m
38. 
    
39. //延时nms,不会引起任务调度
    % [: b0 ^2 p& ^
40. //nms:要延时的ms数
    
41. void delay_xms(u32 nms)
    4 m$ _2 }1 J, H$ ?  Y# ]
42. {
    
43.         u32 i;
    
44.         for(i=0;i<nms;i++) delay_us(1000);
    4 n/ t# s8 k  n6 d6 E
45. }

复制代码

3 S/ _; D5 U4 w2 H& }1 j* E4 A4、屏蔽中断
& D1 G/ [, p. V" V! S! G

& R( O( D* W. {) N4 h4 ]
! a5 R$ h7 g; G0 w$ T/ ~$ D$ B5、最后编译一下，就创建成功啦！！！

% _4 V* w* Q  q  L  O创建任务并执行任务
, {; P# X% _& L3 C7 D+ m创建任务分以下步骤:

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

复制代码

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

9 n# Y' D' Q3 {: q8 D3 D. }1 I% [OLED程序移植相对简单，只需要把相关文件夹进去就行
这是移植所需要的的一些相关文件：
! M, z5 J4 U0 n( [! Y+ V, U5 Z

1 k1 h* f& F8 s9 h5 ]) z1 s8 }其中NRF24L01.c是无线通信模块的，我还在肝中，有需要请私信我。
主函数：

/ z7 t! h: l' V0 w+ ?6 p% f; w/ C

1. #include "sys.h"
   
2. #include "delay.h"
   * l5 z7 L4 c) o& I/ c/ ~. x1 Q/ F
3. #include "usart.h"
   ; M$ ]0 j) c% k5 @
4. #include "led.h"
   % J; f; C$ u, O( _8 q
5. #include "FreeRTOS.h"
   ! O( ]% P* A- ^- A& \( Q1 Z. N
6. #include "task.h"
   / \% K* _0 T* g1 }3 I) Q! e% G8 d- c: m
7. #include "lcd.h"
   
8. 
   
9. //任务优先级
   
10. #define START_TASK_PRIO                1
    
11. //任务堆栈大小        
    
12. #define START_STK_SIZE                 128  
    + g* K! t" |7 ^% z5 I
13. //任务句柄
    : L4 \( Q( u0 ]4 e' }* o% }% u8 Z
14. TaskHandle_t StartTask_Handler;
    $ g- @! t9 F) D/ ]" E: X9 P
15. //任务函数
    
16. void start_task(void *pvParameters);
    4 O  b. [2 T, J7 }$ x
17. 
    
18. 
    
19. //任务优先级
    
20. #define LED0_TASK_PRIO                2
    2 m0 ?, R! D+ [9 _; Y
21. //任务堆栈大小        
    " |; O& ]. k! B; M
22. #define LED0_STK_SIZE                 50  
    
23. //任务句柄
    
24. TaskHandle_t LED0Task_Handler;
    
25. //任务函数
    
26. void led0_task(void *pvParameters);
    
27. 
    
28. //任务优先级
    % M# V# k! H& V1 ]) d3 q
29. #define USART0_TASK_PRIO                3
    ' e0 G! k" \& F8 ?
30. //任务堆栈大小        
    % N  f4 {6 f' G( A3 p1 c
31. #define USART0_STK_SIZE                 50  
    
32. //任务句柄
    
33. TaskHandle_t USART0Task_Handler;
    
34. //任务函数
    9 ^6 V/ j& l; G! A
35. void usart0_task(void *pvParameters);
    
36. 
    
37. 
    6 O3 I4 a+ A; \0 P
38. //任务优先级
      b) V/ z$ c. G0 x# Z$ {4 \7 y: L
39. #define TEMPER0_TASK_PRIO                4
    
40. //任务堆栈大小        
    
41. #define TEMPER0_STK_SIZE                 50  
    
42. TaskHandle_t TEMPER0Task_Handler;
    ' c' `; Z) @5 H8 j; v
43. //任务函数
    ! O3 g6 k% f# r6 r, g( {0 y8 {
44. void TEMPER0_task(void *pvParameters);
    
45. 
    
46. 
    
47. //任务优先级
    
48. #define LCD_TO_TASK_PRIO                5
    ' I) S: G0 H: l# E7 Y3 W
49. //任务堆栈大小        
    
50. #define LCD_TO_STK_SIZE                 50  
    
51. //任务句柄
    
52. TaskHandle_t LCD_TOTask_Handler;
    ) B5 W/ |/ f6 t  g, e' [, `
53. //任务函数
    
54. 
    2 \6 z' b+ b3 B  k" M- B& a
55. void LCD_TO_task(void *pvParameters);
    ) B& L+ Z! N# R8 V: g! Z
56. //任务句柄
    " ?9 v8 j( \# V
57. 
    % \% \# d; |5 m& i  K1 G5 v
58. TaskHandle_t TEMPER0Task_Handler;
    
59. //任务函数
    
60. 
    
61. void temper0_task(void *pvParameters);
    ( s' f4 d( x! t  e
62. int main(void)
    
63. {
    
64.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    ) C" A8 P4 W2 l
65.         delay_init();                                            //延时函数初始化         
    $ ]: X, V, J# b' H# Y
66.         uart_init(115200);                                        //初始化串口
    % t& \: w& m5 u/ b% P: I, w( q
67.         LED_Init();
    . C- W& X& k8 d5 L0 b; ]$ x" v% U* L3 R9 f5 P
68.         //初始化LED
    - w* I7 W" K' X, K$ }
69.         LCD_Init();
    
70.         POINT_COLOR=RED;
    
71.         //初始化LCD
    2 F" w  }% T  c9 h6 V: |
72.         
    & |0 u* Q; m8 P+ U5 s
73.         //创建开始任务
    . a4 s+ J7 p* k- H6 I, i3 I
74.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    $ [+ d" f* J3 o0 A; I8 O' H
75.                 (const char*    )"start_task",          //任务名称
    . L5 v/ }+ H5 A/ o
76.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    , p8 V" l' w& n
77.                 (void*          )NULL,                  //传递给任务函数的参数
    * O' F# c) q$ \4 d" b
78.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
79.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    6 z0 w$ ]$ a) L
80.     vTaskStartScheduler();          //开启任务调度
    
81. }
    ( M! Y3 ]- V3 j* A1 b' T1 v# m
82. 
    ( Q0 Q/ X9 O) u+ V0 u  n: l6 t
83. //开始任务任务函数
    : r" ^) w; |8 x8 b
84. void start_task(void *pvParameters)
    5 m: |' R* C" I
85. {
    
86.     taskENTER_CRITICAL();           //进入临界区
    
87.     //创建LED0任务
    
88.     xTaskCreate((TaskFunction_t )led0_task,            
    . D' J- b, E2 J( r& ?1 }  M6 q  g
89.                 (const char*    )"led0_task",           
    
90.                 (uint16_t       )LED0_STK_SIZE,
    
91.                 (void*          )NULL,                                
    
92.                 (UBaseType_t    )LED0_TASK_PRIO,        
    . y5 C( L/ \6 o) g- P
93.                 (TaskHandle_t*  )&LED0Task_Handler);   
    8 F! I, \+ s# J2 I
94.     //创建usart0任务
    5 R. M- ^- z' V& e: y+ Z
95.     xTaskCreate((TaskFunction_t )usart0_task,     
    / x/ M$ @7 _+ i/ b, K0 @
96.                 (const char*    )"usart0_task",   
    
97.                 (uint16_t       )USART0_STK_SIZE,
    * x/ @/ L2 I3 w& I0 {' w
98.                 (void*          )NULL,
    ! R3 W3 C& W9 D; F$ G; V$ E
99.                 (UBaseType_t    )USART0_TASK_PRIO,
    9 r0 @( {5 R) \$ N. a) o- \  U
100.                 (TaskHandle_t*  )&USART0Task_Handler);
     , Q% S3 I8 G$ X, b4 ]& [% V! C
101.                 //创建temper0任务
     9 f4 \- i6 ^1 s3 W
102.     xTaskCreate((TaskFunction_t )temper0_task,     
     7 Y% r: m# m+ p# I- q3 ?
103.                 (const char*    )"temper_task",   
     
104.                 (uint16_t       )TEMPER0_STK_SIZE,
     " `* p9 o4 y9 v$ U) E; y; m" I3 T
105.                 (void*          )NULL,
     
106.                 (UBaseType_t    )TEMPER0_TASK_PRIO,
     
107.                 (TaskHandle_t*  )&TEMPER0Task_Handler);
     
108.                                 
     % q- F7 ], ?3 Z4 |  L
109.         xTaskCreate((TaskFunction_t )LCD_TO_task,     
     
110.                 (const char*    )"LCD_TO_task",   
     
111.                 (uint16_t       )LCD_TO_STK_SIZE,
     
112.                 (void*          )NULL,
     $ n) z* p) m4 U
113.                 (UBaseType_t    )LCD_TO_TASK_PRIO,
     
114.                 (TaskHandle_t*  )&LCD_TOTask_Handler);
     3 u( H' N  R, u: j/ H5 ]' L# z
115.                                 
     2 X8 M' _, p- r, |% g" o
116.     vTaskDelete(StartTask_Handler); //删除开始任务
     3 U3 \- K# I2 b2 K- [" u* p
117.     taskEXIT_CRITICAL();            //退出临界区
     
118. }
     
119. 
     
120. 
     % O; S$ O5 ]4 @. z
121. //LED0任务函数
     3 ~( Q3 W. m1 ?; T. G$ ]1 i
122. void led0_task(void *pvParameters)
     
123. {
     
124.     while(1)
     . O+ B1 C1 g% U1 f
125.     {
     
126.         LED0=~LED0;
     3 q; ]0 z5 D" b. m9 I+ k' E: i
127.                                 if(LED0==1)
     
128.                                         printf("灯灭\r\n");
     
129.                                 else
     
130.                                         printf("灯亮\r\n");
       k8 B4 |) ~5 V' F/ G$ J. S
131.         vTaskDelay(1000);
     
132.     }
     $ P0 a+ B0 P9 q0 V, S) }  y' }3 b2 g% k
133. }   
     
134. 
     2 {, j" g* w3 F0 z1 ~
135. 
     ( Q6 M6 N& X0 Q! A
136. //usart0任务函数
     # p+ v) U0 s$ w: O" x
137. void usart0_task(void *pvParameters)
     ! W  O# c6 k3 U2 }2 Q
138. {
     
139.         
     8 F! b* {2 x. o' K+ X
140.                         while(1)
     
141.                         {        
     
142.                                 printf("hello lee");
     5 X9 J3 ^1 i2 |! l
143.                                 printf("\r\n");
     : q% q7 W' p( A, R# x5 {/ {# l
144.                                 vTaskDelay(1000);
     
145.                         }
     
146. }
     
147. 
     / K* _2 ]2 m3 U- O3 ?2 I
148. //temper0任务函数(暂时为LED1翻转)
     % A6 K# r! n4 a9 o; [) M
149. void temper0_task(void *pvParameters)
     
150. {
     / s! U/ o" Z& }0 k( B6 ?
151.                                        
     
152.                         while (1)
     
153.                         {        
     7 R# ]6 r  U) X/ V/ d- x* n
154.                                 LED1=~LED1;
     * t  t! F( r$ [5 Z
155.                                 vTaskDelay(1000);                        
     2 T: j1 ?( d/ T% a9 E6 f/ N
156.                         }
     
157. }
     6 B* e1 R% i0 p
158. 
     : [9 U% x, T) ]" U8 W1 F
159. void LCD_TO_task(void *pvParameters)
     
160. {
     
161.         u8 lcd_id[12];
     
162.         sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);        
     9 y6 U, E) B7 j; v, m
163.         while (1)
     , \$ f, W; r: ]* z- k5 e! u+ L
164.                 {        
     8 K& U2 `0 C9 o$ r
165.                 LCD_ShowString(30,40,210,24,24,"WarShip STM32 ^_^");
     
166.                 LCD_ShowString(30,70,200,16,16,"TFTLCD TEST");
     - Q$ z% U( N9 ~' Z
167.                 LCD_ShowString(30,90,200,16,16,"DARKSTARS");
     $ K1 L' z& D; 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);        
     
171.                 }
     
172. }
     

复制代码

$ O3 r9 D1 {( Z4 Z* \0 r

- W+ B) v9 @- t' J

6 H/ `6 M5 ~+ W% z7 r; o& h


; p# ?2 R* e% g# B# t总结
通过这次系统的移植，我感受到系统的魅力，有了系统之后，许多程序就能并行运行了，这样我们就能完成更加高效，更加同步的信息处理和信息传输。对于高刷新率的信息处理，移植系统无疑是更好的选择。
( G! t4 o+ o, B5 g3 f" _9 H


9 a* `% X. X5 [
9 L( p* j; z, J; O1 t$ n