一、源码处理
文件下载
/ W2 l  w- s  \" T) a8 e0 e1、官网下载源码
3 C& _7 ^; W( w2 P

2、找到相关的例程

2 ?9 U! A5 s' Q% j8 a9 K3、进入源码文件

. B5 P) a7 k' L& t$ S! f

, k, Y& ~+ J+ d+ b0 m
/ C) ~- |5 f3 ^, @/ G- t% ?4、找到相关的文件
6 x1 ?, S9 h" \8 A: v; f. ^

. E) |, P/ m5 J- J; T- j5 gkeil、RVDS为需要的文件，MemMang为需要的内存文件
: S/ b! C; u; z* c
* f% [9 C& C: g& f文件移植
# ?9 u4 c& i, Q  U( T# m" ^1、在之前led灯程序基础上添加文件
" R4 d& }% E6 \+ d6 ]2 [注释：在正点原子开源工程里可以下载

  Y9 S4 V4 D4 h$ ^" E

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

复制代码

+ ?6 D3 O5 u. u" P$ B4 `
: K; T& p1 a7 @1 a# S2、将相关.h文件包含进去
7 j5 @5 x+ P! y( w5 }
& U: Z; W0 q# B: [$ H6 z. f

! ^! k! @! g, R  V1 h
此时编译会报错
& B3 w5 z+ T  t) T9 j继续包含所需要的文件

文件地址：

6 T$ B& D! R& C3、修改相关文件
  T! b, u( |0 o% s. w! K7 \4 G
注释：正点原子给的工程例程是支持ucos的，所以我们需要把一些oc相关的删除掉
以下是修改之后程序代码：
sys.h
# {# g) a  a; O9 a
5 }1 l9 U6 o+ D$ `- |

( \  n! v! ]4 ]: R
/ g2 z" C% g! ?5 Z; ~: zusart.c

, n! ~! ?! k" w1 @
原来是include.h，需要改成FreePTOS.h

delay.c
& \; z; V7 E: k" J9 a. X3 f
1:SysTIck_Handler()
* {5 F) Z9 [; c- n$ T2 |

1. extern void xPortSysTickHandler(void);
   ( J) n' C' U# I  P6 z4 _
2. 
   
3. //systick中断服务函数,使用ucos时用到
   
4. void SysTick_Handler(void)
   
5. {        
   9 o+ Q- R5 b* G( I; z% ]
6.     if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
   . `: c  O0 P& I8 i
7.     {
   
8.         xPortSysTickHandler();        
   
9.     }
   
10. }

复制代码

* V: O, d0 H) Y/ X5 u2:delay_init

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  
   # j% p" B" Y% \# u
7.         reload*=1000000/configTICK_RATE_HZ;                        //根据configTICK_RATE_HZ设定溢出时间
   ' @9 M2 R0 G$ [% A. ^+ r8 p
8.                                                                                                 //reload为24位寄存器,最大值:16777216,在72M下,约合0.233s左右        
   0 ~( J# c( C: M! g; P
9.         fac_ms=1000/configTICK_RATE_HZ;                                //代表OS可以延时的最少单位           
   
10. 
    4 U: L1 C9 L0 I- |% f% {5 K; N! ?
11.         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;           //开启SYSTICK中断
    . |: c; ?: }* E. a/ o( i2 z
12.         SysTick->LOAD=reload;                                                 //每1/configTICK_RATE_HZ秒中断一次        
    
13.         SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;           //开启SYSTICK   
    
14. }

复制代码

# E' K! t4 u* I3:两个延时函数
* a, A5 b% J( t6 B4 z

1. //延时nus
   , @9 g' ^# L) t6 S0 W
2. //nus:要延时的us数.        
   
3. //nus:0~204522252(最大值即2^32/fac_us@fac_us=168)                                                                              
   
4. void delay_us(u32 nus)
   / Y2 Z5 T, [8 ]1 d2 Q  {
5. {               
   ' ^7 k# p, g! x% s% P9 ]( d! s# k; ]
6.         u32 ticks;
   
7.         u32 told,tnow,tcnt=0;
   
8.         u32 reload=SysTick->LOAD;                                //LOAD的值                     
   * j  ?- K. t4 m& Z1 N; H7 |
9.         ticks=nus*fac_us;                                                 //需要的节拍数
   
10.         told=SysTick->VAL;                                        //刚进入时的计数器值
    ' a* j- t+ o* R" f6 l5 R" c8 ], {
11.         while(1)
    ) t7 g1 O% \2 Q; U9 T2 C
12.         {
    
13.                 tnow=SysTick->VAL;        
    
14.                 if(tnow!=told)
    % r2 M7 E3 j/ j, u
15.                 {            
      j# Y# R, V) a4 y
16.                         if(tnow<told)tcnt+=told-tnow;        //这里注意一下SYSTICK是一个递减的计数器就可以了.
    
17.                         else tcnt+=reload-tnow+told;            
    
18.                         told=tnow;
    
19.                         if(tcnt>=ticks)break;                        //时间超过/等于要延迟的时间,则退出.
    ' l! q6 G3 L6 x, {3 v& J* _
20.                 }  
    ) ], z* a& c( [- L6 n
21.         };                                                                                    
    
22. }  
    
23. //延时nms
    $ M  a, L; b3 ?
24. //nms:要延时的ms数
    / p) `& R9 F3 R0 v  R
25. //nms:0~65535
    * L  f2 c: U$ \$ Z
26. void delay_ms(u32 nms)
    " |; n; }9 ]( a, ]$ d3 Z
27. {        
    
28.         if(xTaskGetSchedulerState()!=taskSCHEDULER_NOT_STARTED)//系统已经运行
    * e; \' R$ O; t; z( Q8 O
29.         {               
      n- o5 [4 ]) ^; H( O% @7 {" J( _6 q
30.                 if(nms>=fac_ms)                                                //延时的时间大于OS的最少时间周期
    : A/ d, z2 s, z' p0 g# F- E
31.                 {
      j1 I% `% w  l
32.                            vTaskDelay(nms/fac_ms);                         //FreeRTOS延时
    
33.                 }
    
34.                 nms%=fac_ms;                                                //OS已经无法提供这么小的延时了,采用普通方式延时   
    ( t5 L' H6 E. i, h% u" T+ i
35.         }
    
36.         delay_us((u32)(nms*1000));                                //普通方式延时
    
37. }
    3 @! j3 W1 Z" P. h
38. 
    
39. //延时nms,不会引起任务调度
    
40. //nms:要延时的ms数
    
41. void delay_xms(u32 nms)
    
42. {
    
43.         u32 i;
    
44.         for(i=0;i<nms;i++) delay_us(1000);
    
45. }

复制代码

8 f8 I7 s3 q' N% s+ `' q4、屏蔽中断
& L" p2 X  ~$ O1 n% g- j+ j
/ r+ X  q* R% ~3 f: ?+ i

  B4 |1 }8 Q8 s! Y0 I' b
5、最后编译一下，就创建成功啦！！！

创建任务并执行任务
2 l' o  _% R" _创建任务分以下步骤:
8 y3 f4 p" I  v. }

1. 设置任务优先级
   
2. 设置任务堆栈大小
   
3. 设置任务句柄
   4 ~/ O  w: Z* `- |0 G4 G
4. 设置任务函数

复制代码

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

* p9 O* `+ r% m0 a7 sOLED程序移植相对简单，只需要把相关文件夹进去就行
这是移植所需要的的一些相关文件：

, [8 _# P+ P0 \% w6 v" s  Q/ E其中NRF24L01.c是无线通信模块的，我还在肝中，有需要请私信我。
/ K8 e1 z, M2 g" s; k$ Z# c主函数：

% \& a5 s7 D, j# i; ?0 [: \; \2 q

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   - e$ y( r1 t. z- b( ^
4. #include "led.h"
   & p3 y! K+ Y. \' c
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   
7. #include "lcd.h"
   
8. 
   
9. //任务优先级
   9 H  u6 P1 N$ f1 t1 n
10. #define START_TASK_PRIO                1
    , J) r, [. I# t0 B+ x( A
11. //任务堆栈大小        
      t/ J( k- @% d1 Q* ]+ K$ }
12. #define START_STK_SIZE                 128  
    2 g' M7 U& Z, m' Y: o  m' r
13. //任务句柄
    
14. TaskHandle_t StartTask_Handler;
    & U7 A. y' @2 e! Y0 T9 O
15. //任务函数
    ' ?1 y) s& }, M/ Y1 K
16. void start_task(void *pvParameters);
    8 C. K: D( Q* [, u. }& u
17. 
    4 a- ?$ l8 o9 y8 a
18. 
    
19. //任务优先级
    
20. #define LED0_TASK_PRIO                2
    
21. //任务堆栈大小        
    
22. #define LED0_STK_SIZE                 50  
    % F! n$ N: a5 ^6 y& g
23. //任务句柄
    * T, g5 @/ f6 ^$ t- z- w
24. TaskHandle_t LED0Task_Handler;
    
25. //任务函数
    
26. void led0_task(void *pvParameters);
    
27. 
    
28. //任务优先级
    " g+ n$ U2 J5 O. Z
29. #define USART0_TASK_PRIO                3
    
30. //任务堆栈大小        
    
31. #define USART0_STK_SIZE                 50  
    . ]% U% z: d8 }3 F7 j
32. //任务句柄
    
33. TaskHandle_t USART0Task_Handler;
    
34. //任务函数
    % P/ s/ U4 i7 k% M5 j  @( a
35. void usart0_task(void *pvParameters);
    ) K7 w, p5 l# c7 J: Y
36. 
    
37. 
    
38. //任务优先级
    6 Y5 x$ P+ h( P( Z2 T$ e- Z2 K
39. #define TEMPER0_TASK_PRIO                4
    2 d3 @4 B+ S" z
40. //任务堆栈大小        
    5 ]9 b6 W6 r- I  r0 N+ u
41. #define TEMPER0_STK_SIZE                 50  
    
42. TaskHandle_t TEMPER0Task_Handler;
    - V/ J. H) [" N6 ~5 ?
43. //任务函数
    . ^# i  u& m! R% [/ X' e/ V! @
44. void TEMPER0_task(void *pvParameters);
    
45. 
    
46. 
    ) B8 o' d& T2 A4 W! u
47. //任务优先级
    
48. #define LCD_TO_TASK_PRIO                5
    
49. //任务堆栈大小        
    4 `# ]3 Z% P7 I
50. #define LCD_TO_STK_SIZE                 50  
    1 x+ M0 \7 J( @1 l; Q
51. //任务句柄
    # c! _9 x$ A" p
52. TaskHandle_t LCD_TOTask_Handler;
    , v) q. p  [- _0 I6 J
53. //任务函数
    
54. 
    8 N6 k% h  Y  t' c
55. void LCD_TO_task(void *pvParameters);
    
56. //任务句柄
    ! D+ r5 W$ o  t7 J  V
57. 
    " o& J! K$ U" ~. d
58. TaskHandle_t TEMPER0Task_Handler;
    0 Z3 o. s2 s+ ~5 b! x
59. //任务函数
    
60. 
      F3 K# G1 {* T  p9 Q
61. void temper0_task(void *pvParameters);
    
62. int main(void)
    
63. {
    7 e- j& T& L( P2 ~9 ]: L# i
64.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4         
    7 y9 S1 u, V6 P% U+ i- M
65.         delay_init();                                            //延时函数初始化         
    6 u: d2 q5 Z7 A) l7 d4 `# v# a( |# T
66.         uart_init(115200);                                        //初始化串口
    
67.         LED_Init();
    9 Y" a; l9 w& D
68.         //初始化LED
    - R: U' W9 O" u  t" m9 `
69.         LCD_Init();
    
70.         POINT_COLOR=RED;
    
71.         //初始化LCD
    
72.         
    0 {/ I6 ?% W3 u: @8 l, ?0 p
73.         //创建开始任务
    
74.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    0 L. O$ R7 `$ [+ M
75.                 (const char*    )"start_task",          //任务名称
    ) l' y5 g$ V, u1 ~2 G  A3 A
76.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    
77.                 (void*          )NULL,                  //传递给任务函数的参数
    5 E! x( x4 T: O; I% H
78.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    ) \3 j: t; N" z
79.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    8 z6 M: ~; H1 i( h
80.     vTaskStartScheduler();          //开启任务调度
    
81. }
    ( i7 u7 j9 b' H  P
82. 
    + _7 B% u+ P9 |7 u8 r
83. //开始任务任务函数
    . v: X" Y1 e. h! Y4 i' @4 k
84. void start_task(void *pvParameters)
    
85. {
    9 m& @" }" g3 s8 @0 `& [
86.     taskENTER_CRITICAL();           //进入临界区
    5 E6 m# q& p. [. @/ D7 |
87.     //创建LED0任务
    - `, v! j! S+ L1 L# p3 T+ Z" ?
88.     xTaskCreate((TaskFunction_t )led0_task,            
    
89.                 (const char*    )"led0_task",           
    2 ^7 @' E) W7 G$ t
90.                 (uint16_t       )LED0_STK_SIZE,
    
91.                 (void*          )NULL,                                
    
92.                 (UBaseType_t    )LED0_TASK_PRIO,        
    
93.                 (TaskHandle_t*  )&LED0Task_Handler);   
      X1 B+ Q; d9 {7 @, F$ h
94.     //创建usart0任务
    ( x+ t' @- ^- ]+ c
95.     xTaskCreate((TaskFunction_t )usart0_task,     
    - L: Q- Z2 Y, r" c6 [2 {5 ]
96.                 (const char*    )"usart0_task",   
    / X, T2 O) @. F4 t
97.                 (uint16_t       )USART0_STK_SIZE,
    
98.                 (void*          )NULL,
    ( ?+ x4 M1 Z2 ?" n2 N2 R$ w+ Q
99.                 (UBaseType_t    )USART0_TASK_PRIO,
    
100.                 (TaskHandle_t*  )&USART0Task_Handler);
       i1 _2 G- t3 ~* E; V3 }
101.                 //创建temper0任务
     
102.     xTaskCreate((TaskFunction_t )temper0_task,     
     ! U- r) o2 d! n5 f0 ], Q1 p
103.                 (const char*    )"temper_task",   
     
104.                 (uint16_t       )TEMPER0_STK_SIZE,
     
105.                 (void*          )NULL,
     - p  P9 {$ a- u. l7 h! K( N
106.                 (UBaseType_t    )TEMPER0_TASK_PRIO,
     8 A) X) d0 K6 E5 l
107.                 (TaskHandle_t*  )&TEMPER0Task_Handler);
     " P- j2 N% G( y) q& g% P* S* u
108.                                 
     
109.         xTaskCreate((TaskFunction_t )LCD_TO_task,     
     
110.                 (const char*    )"LCD_TO_task",   
     
111.                 (uint16_t       )LCD_TO_STK_SIZE,
     : a7 q8 J7 i4 J& e; x! }% C8 s
112.                 (void*          )NULL,
     
113.                 (UBaseType_t    )LCD_TO_TASK_PRIO,
     
114.                 (TaskHandle_t*  )&LCD_TOTask_Handler);
     
115.                                 
     + W( B5 m* n& [9 y; g
116.     vTaskDelete(StartTask_Handler); //删除开始任务
     
117.     taskEXIT_CRITICAL();            //退出临界区
     
118. }
     & Y& c) O4 `7 M$ p' B0 N& y
119. 
     
120. 
     8 d: N+ k% |* M  r: z0 W! P# g
121. //LED0任务函数
     
122. void led0_task(void *pvParameters)
     
123. {
     
124.     while(1)
     
125.     {
     9 N9 i6 s" v" U
126.         LED0=~LED0;
     7 q" g1 `. V# }/ |! {& m) T: o# H
127.                                 if(LED0==1)
     - j) r$ u+ A% D5 w
128.                                         printf("灯灭\r\n");
     ! m, O& `' `, y5 h! I% o, g% L
129.                                 else
     
130.                                         printf("灯亮\r\n");
     % G$ a- O' R% ^0 S
131.         vTaskDelay(1000);
     
132.     }
     
133. }   
     
134. 
     : v; C0 u$ d8 i* B0 T
135. 
     
136. //usart0任务函数
     ' r8 \% F" [) p: u& \- N
137. void usart0_task(void *pvParameters)
     
138. {
     
139.         
     1 L9 ~6 Z; u* F
140.                         while(1)
     ' G1 f" D4 C, Z7 [) S: H& j
141.                         {        
     
142.                                 printf("hello lee");
     $ |6 T2 f. ^9 X
143.                                 printf("\r\n");
     * Q& ?' b+ \$ o: g
144.                                 vTaskDelay(1000);
     
145.                         }
     * z9 E1 j! c6 l1 n* l) K
146. }
     
147. 
     
148. //temper0任务函数(暂时为LED1翻转)
     
149. void temper0_task(void *pvParameters)
     7 [7 A3 G8 _/ p: i. |4 K
150. {
     3 }5 P- b; m8 Z" a: `  S1 t
151.                                        
     
152.                         while (1)
     
153.                         {        
     5 ~- }  P# \6 K' z2 l2 V
154.                                 LED1=~LED1;
     
155.                                 vTaskDelay(1000);                        
     
156.                         }
       L3 g* t2 J6 m8 h  m9 d8 J1 P7 W
157. }
     / a# f. ~& j% N& d/ D  W- D- ^
158. 
     
159. void LCD_TO_task(void *pvParameters)
     $ }# V/ ]3 j% |; F+ T
160. {
     
161.         u8 lcd_id[12];
     
162.         sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);        
     
163.         while (1)
     8 A# v( F3 L/ Y$ F
164.                 {        
     : a! `5 u3 W1 O4 E# w
165.                 LCD_ShowString(30,40,210,24,24,"WarShip STM32 ^_^");
     + q9 m8 z; j1 r* W  p
166.                 LCD_ShowString(30,70,200,16,16,"TFTLCD TEST");
     
167.                 LCD_ShowString(30,90,200,16,16,"DARKSTARS");
     + a8 v. i5 h* r  h" w% ?3 X
168.                  LCD_ShowString(30,110,200,16,16,lcd_id);                //显示LCD ID
     
169.                 LCD_ShowString(30,130,200,12,12,"2020/12/4");
     7 Y# e' u2 T# ?
170.                 vTaskDelay(1000);        
     $ V2 x. [( X; t8 I4 v
171.                 }
     ; A+ d2 B' p9 Q# B2 z# T
172. }
     % e# z* B& X, [6 d: v

复制代码

/ O2 Z6 Z+ D5 V. ]3 F% u8 ~

& k' v$ t& b$ v: E& U6 J

2 b! x/ F2 H1 N& D
6 e& a( a, h+ a8 A9 }, K# y

3 K# B( X7 v: ~* N6 w7 m
8 A/ e3 M* K/ t0 ?& B; j总结
通过这次系统的移植，我感受到系统的魅力，有了系统之后，许多程序就能并行运行了，这样我们就能完成更加高效，更加同步的信息处理和信息传输。对于高刷新率的信息处理，移植系统无疑是更好的选择。



9 a0 I' }9 o2 k2 k& s. {# u