移植步骤（以STM32F103为例）
添加FreeRTOS源码至项目文件
1.官网下载源码，并解压。Source文件夹中的文件即为我们需要移植的文件，其中portable文件夹里都是需要根据平台修改或删减的文件。

$ N, H4 J2 s8 K& y1 b: ~# P7 Y! v

2.打开一个工程的源码目录，新建文件夹FreeRTOS，将源码中的文件复制到此文件夹中。
9 m) g. u9 T0 u2 p  ?" k
  r: g; }, I8 |5 Q$ m+ _
4 P& q& }# F) w. K7 X; \
% B2 m+ U  ~% h7 k+ @9 X* Q3.在portable文件夹中只保留GCC/ARM_CM3（使用的STM32CubeIDE开发环境）与MemMang两个文件夹。如果是使用的keil开发环境，那么需要保留RVDS与MemMang两个文件夹。
* k+ @. t! @8 T  F8 ?0 W

. v( c8 P6 V  B8 N6 b6 X9 W/ y
4.根据需要在MemMang文件夹中选择合适的堆分配算法文件。（一般STM32F103选择heap_4.c文件）。如果使用Makefile文件组织编译过程，那么需要排除其他的算法文件。

) e' ^" i' E$ ~

1. SRC := $(filter-out Source/FreeRTOS/portable/MemMang/heap_1.c, $(SRC))
   6 R- d% t" C3 J0 @# r
2. SRC := $(filter-out Source/FreeRTOS/portable/MemMang/heap_2.c, $(SRC))
   ; ]' \  R) V/ z4 E: U
3. SRC := $(filter-out Source/FreeRTOS/portable/MemMang/heap_3.c, $(SRC))
   8 M, r8 I/ F1 P9 A) N( L7 z
4. SRC := $(filter-out Source/FreeRTOS/portable/MemMang/heap_5.c, $(SRC))

复制代码

9 w% W1 M* ~  L7 _4 e1 z5.添加在工程中添加FreeRTOS头文件。

1. #include directory of FreeRTOS
     r/ r8 E( ~/ T: k
2. INCLUDE_DIR += -ISource/FreeRTOS/include
   
3. INCLUDE_DIR += -ISource/FreeRTOS/portable/GCC/ARM_CM3

复制代码

3 p1 q1 y& ^3 D5 m5 a( m6.从下载源码的Demo文件夹中选择一个适合的工程，并从工程的源码中复制FreeRTOSConfig.h到FreeRTOS/include文件夹。由于我们采用的是STM32CubeIDE，因此选择CORTEX_STM32F100_Atollic工程中的配置文件。



; d3 _6 u' Y& f8 j6 _! ?修改FreeRTOSConfig.h文件
根据项目工程需要修改FreeRTOSConfig.h文件，这是移植过程中最为重要的一步，需要根据需要对配置文件进行修改。以下提供了一个修改好的模板：

1 m- Q3 D" A: M5 X) c

1. /*
   , N4 e9 F8 |; ?( U/ B7 |; }* \0 ~: T% p
2. * FreeRTOS Kernel V10.4.1
   # j  U* X) v% v- `" d0 e0 p
3. * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
   7 f/ k! @% P& A8 [3 z
4. *
   5 P7 J+ N) A. G: I3 h  H( I
5. * Permission is hereby granted, free of charge, to any person obtaining a copy of
   4 O' g6 n% i. ]" j& A% c
6. * this software and associated documentation files (the "Software"), to deal in
   9 x' C& |: D# l
7. * the Software without restriction, including without limitation the rights to
   2 ^" d; o, k* K% f
8. * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
   
9. * the Software, and to permit persons to whom the Software is furnished to do so,
   7 V2 `* v* ^, _7 t# {$ n, ]$ t9 d
10. * subject to the following conditions:
    7 L; K' A8 n  f  p& y* z3 G
11. *
    6 ~  Q! K3 ?+ `# }' E5 z
12. * The above copyright notice and this permission notice shall be included in all
    $ f/ l' N9 Q- |8 E: k. R) A& c+ U
13. * copies or substantial portions of the Software.
    
14. *
    2 a9 E: n4 z' t$ g3 B* Z
15. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    
16. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
    % v$ @( Q4 @9 |; s
17. * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
    
18. * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
    
19. * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
    
20. * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    
21. *
    
22. * 1 tab == 4 spaces!
    
23. */
    . k" @9 W0 H$ r+ ^2 y, I
24. 
    
25. /* The following #error directive is to remind users that a batch file must be
    2 t3 Q' Q1 c1 x/ w! `% g- T
26. * executed prior to this project being built.  The batch file *cannot* be
    
27. * executed from within CCS4!  Once it has been executed, re-open or refresh
    ! I' k. ~4 E" A( C7 D" b( B* |
28. * the CCS4 project and remove the #error line below.
    
29. */
    
30. //#error Ensure CreateProjectDirectoryStructure.bat has been executed before building.  See comment immediately above.
    
31. 
    / z$ L: g0 f# [0 G% d9 Z
32. #ifndef FREERTOS_CONFIG_H
    
33. #define FREERTOS_CONFIG_H
    $ X+ g# K: B9 x/ [
34. 
    
35. #include "stm32f10x_conf.h"
    
36. #include "stm32f10x.h"
    
37. /*-----------------------------------------------------------
    7 y7 q2 l4 L4 L  C3 j2 k$ K9 k
38. * Application specific definitions.
    ' O* c9 k  |( `  z4 ?) D
39. *
    / |  r  y2 V: v; R0 w
40. * These definitions should be adjusted for your particular hardware and
    
41. * application requirements.
    
42. *
    
43. * THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE
    
44. * FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.
    & f! g, J- X7 L& w5 i* F; @
45. *
    
46. *----------------------------------------------------------*/
    . A8 Q1 M: ~' M! Z: d7 X! H6 f, d
47. 
    / _; }0 ~  j+ u9 S+ W
48. /*
    ; _6 D/ f3 L1 k. \
49. * FreeRTOS 支持的调度方式FreeRTOS 操作系统支持三种调度方式：
    % k* a" |( d6 E
50. * 抢占式调度，时间片调度和合作式调度。
    . L8 M: ]9 Q6 v% v0 @/ t0 E; r
51. * 实际应用主要是抢占式调度和时间片调度，合作式调度用到的很少。
    : J6 ?- ]# Y+ s$ k& K2 l8 g7 {. d
52. *
    . w, N% s& J& e
53. * 抢占式调度：
    
54. * 每个任务都有不同的优先级，任务会一直运行直到被高优先级任务抢占或者遇到阻塞式的 API 函数，比如 vTaskDelay。
    % f( S- `) y* M) e  y+ W
55. *
    3 T- t. n' e" t  _8 }+ q
56. * 时间片调度：
    5 S+ o( H2 {/ p) m% W9 _) u& \1 E
57. * 每个任务都有相同的优先级，任务会运行固定的时间片个数或者遇到阻塞式的 API 函数，比如vTaskDelay，才会执行同优先级任务之间的任务切换。
    5 v6 r, c7 h: y  v' O
58. * 在 FreeRTOS 操作系统中只有同优先级任务才会使用时间片调度
    
59. */
    
60. 
    ) L5 e5 ^6 D7 S3 P: S
61. /**
    : n5 t) C1 {; d+ d' {! b& T" k: C6 \
62. * 配置为 1, 使能抢占式调度器
    . I/ P2 C4 p- d" s) Q0 r
63. * 配置为 0, 使能合作式调度器
    
64. */
    * F9 u# q. [; b* l8 |
65. #define configUSE_PREEMPTION                     1
    1 c& F- H+ T# x
66. 
    
67. /**
    
68. * 只能使用编译器提供的RAM创建RTOS对象
    
69. */
    9 _6 ?/ |+ Y) e2 m0 c
70. #define configSUPPORT_STATIC_ALLOCATION          0
    # ~3 u. p& l8 G
71. 
    
72. /**
    
73. * 使用从FreeRTOS堆自动分配的RAM创建RTOS对象
    
74. */
    + p) K/ W* k& P% a  t* I, w& e
75. #define configSUPPORT_DYNAMIC_ALLOCATION         1
    
76. 
    , i7 P& }% g9 B6 P, S* w" ^! p  I
77. /**
    8 R9 |% M) M, y2 K
78. * 钩子函数的主要功能是用于函数的扩展，用户可以根据自己的需要往里面添加相关的测试函数。
      X8 Q2 _; Y) q( [8 H
79. */
    + }. ^" l/ O" U7 g& L) P& r* ^
80. //使能空闲任务的钩子函数
    
81. #define configUSE_IDLE_HOOK                      0
    
82. //使能滴答定时器中断里面执行的钩子函数
    
83. #define configUSE_TICK_HOOK                      0
    
84. 
    1 F5 h( P5 N6 o% S" \
85. /**
    
86. * 此参数用于定义 CPU 的主频，单位 Hz
    5 y" [: E. o8 A$ f# ]
87. */
    * R- ^- j) v' p  M3 z
88. #define configCPU_CLOCK_HZ                       ( SystemCoreClock )
    
89. 
    " ^+ x1 f# I1 f2 u
90. /**
    6 E0 I8 D/ N5 R. q
91. * 此参数用于定义系统时钟节拍数，单位 Hz，一般取 1000Hz 即可
    6 a: v3 _3 H5 E7 Q: I1 ~  k
92. */
    * I* ]9 s1 W: [. p. @5 W
93. #define configTICK_RATE_HZ                       ((TickType_t)1000)
    
94. 
    * a0 U/ e$ R4 n: K, a! G- r
95. /**
    
96. * 此参数用于定义可供用户使用的最大优先级数，
    & X2 L8 e+ o7 K: ^
97. * 如果这个定义的是 5，那么用户可以使用的优先级号是 0,1,2,3,4，不包含 5
    
98. */
    
99. 
      p2 ]4 }* q# [! @
100. #define configMAX_PRIORITIES                     ( 32 )
     # M! Z2 _3 ^8 T. H, _+ {. U  B
101. 
     
102. /**
     
103. * 此参数用于定义空闲任务的栈空间大小，单位字，即 4 字节
     
104. */
     0 V6 U1 j' U& z0 L' [2 U" @
105. #define configMINIMAL_STACK_SIZE                 ((uint16_t)128)
     . X( z! ^3 A& R
106. 
     - x  z+ r7 Q. X% Y6 [1 t# C/ s! G6 f
107. /**
     
108. * 定义堆大小，FreeRTOS 内核，用户动态内存申请，任务栈，任务创建，信号量创建，消息队列创建等都需要用这个空间
     
109. */
     # z7 t. U) Q0 p
110. #define configTOTAL_HEAP_SIZE                    ((size_t)10*1024)
     $ b8 P; E) A( s9 C
111. 
     
112. /**
     ; ?- }0 g, d$ h: ~9 C, P: o( K* f& C( o
113. * 定义任务名最大的字符数，末尾的结束符 '\0'也要计算在内
     
114. */
     
115. #define configMAX_TASK_NAME_LEN                  ( 16 )
     
116. 
     
117. /**
     ' @: W. X+ T0 I. ~+ h3 r
118. * 系统时钟节拍计数使用 TickType_t 数据类型定义的，
     / D) P7 N/ z& K
119. * 如果用户使能了宏定义 configUSE_16_BIT_TICKS，那么 TickType_t 定义的就是 16 位无符号数，
     ) K( |0 J8 i6 s+ U+ E+ ~
120. * 如果没有使能，那么 TickType_t 定义的就是 32 位无符号数。
     
121. * 对于 32 位架构的处理器，一定要禁止此宏定义，即设置此宏定义数值为 0 即可。
     
122. * 而 16 位无符号数类型主要用于 8 位和 16 位架构的处理器。
     
123. */
     
124. #define configUSE_16_BIT_TICKS                   0
     
125. 
     
126. /**
     0 {2 q7 l+ _. f7 U5 S+ w
127. * 使能互斥信号量
     
128. */
     
129. #define configUSE_MUTEXES                        1
     
130. 
     . V6 `& Y% S4 ?& H9 g+ F% G
131. /**
     
132. * 通过此定义来设置可以注册的信号量和消息队列个数。
     
133. */
     3 H' \- d* \4 I3 j
134. #define configQUEUE_REGISTRY_SIZE                8
     & Y' G# s3 B& p1 ], L
135. 
     
136. /* 某些运行FreeRTOS的硬件有两种方法选择下一个要执行的任务：
     8 b2 @; b) D) c/ }6 p
137. * 通用方法和特定于硬件的方法（以下简称“特殊方法”）。
     * J2 k8 v. a- a. V$ _
138. *
     9 W5 ?/ X* o) |. \. t- V
139. * 通用方法：
     ! q# y% Y+ S% y, T- t4 u& k4 M
140. *      1.configUSE_PORT_OPTIMISED_TASK_SELECTION 为 0 或者硬件不支持这种特殊方法。
     ; `9 a9 N7 I7 R' z7 x/ c  Q
141. *      2.可以用于所有FreeRTOS支持的硬件
     
142. *      3.完全用C实现，效率略低于特殊方法。
     * g$ U- c7 V( |* R3 j7 n
143. *      4.不强制要求限制最大可用优先级数目
     % _  G9 v% q0 [
144. * 特殊方法：
     
145. *      1.必须将configUSE_PORT_OPTIMISED_TASK_SELECTION设置为1
     
146. *      2.依赖一个或多个特定架构的汇编指令（一般是类似计算前导零[CLZ]指令）
     
147. *      3.比通用方法更高效
     
148. *      4.一般强制限定最大可用优先级数目为32
     
149. * 一般是硬件计算前导零指令，如果所使用的，MCU没有这些硬件指令的话此宏应该设置为0
     
150. */
     
151. 
     0 f* r9 x5 q% `7 [9 q. z- F8 X
152. /**
     $ W" X: _$ U9 Q  e
153. * 此配置用于优化优先级列表中要执行的最高优先级任务的算法。对 CM 内核的移植文件，默认已经在文件 portmacro.h 文件中使能。
     
154. */
     
155. #define configUSE_PORT_OPTIMISED_TASK_SELECTION  1
     ! N. w1 C8 n2 J8 E# M7 @1 M$ T
156. 
     0 F1 w! L4 T- G" J9 z5 P; I0 [
157. /* Co-routine definitions. */
     
158. /**
     9 Q# ~( c' r8 x8 U6 w
159. * 使能合作式调度相关函数
     9 |9 B! T) y# S8 T+ X: J1 P7 S. M
160. */
     5 o% i; {% r0 w- E' `& l
161. #define configUSE_CO_ROUTINES                 0
     ' U+ E1 {- H$ B8 H! a# x2 Z2 i6 P
162. 
     / j' Z% l9 p9 @: Z+ y" h
163. /**
     4 f; @# K5 ~) V0 x
164. * 此参数用于定义可供用户使用的最大的合作式任务优先级数
     4 I! |: L. `- Z- j; m2 U
165. */
     
166. #define configMAX_CO_ROUTINE_PRIORITIES ( 2 )
     
167. 
     3 g5 c9 z: Z7 X
168. /* Software timer definitions. */
     # n/ l) l6 C; U+ y- w8 f/ ^% W
169. //禁能软件定时器
     
170. #define configUSE_TIMERS                                0
     
171. //配置软件定时器任务的优先级
     
172. #define configTIMER_TASK_PRIORITY                ( 3 )
     " {- D: T# d' W$ z) [
173. //配置软件定时器命令队列的长度
     
174. #define configTIMER_QUEUE_LENGTH                5
     + c  C' ?- G2 [8 p
175. //配置软件定时器任务的栈空间大小
     
176. #define configTIMER_TASK_STACK_DEPTH         (configMINIMAL_STACK_SIZE)
     $ Q: V7 S( m+ I# D- p2 E5 }) H( v
177. 
     
178. /* Set the following definitions to 1 to include the API function, or zero
     
179. to exclude the API function. */
     
180. #define INCLUDE_vTaskPrioritySet                1
     
181. #define INCLUDE_uxTaskPriorityGet                1
       l, R8 `& q. [; K" b
182. #define INCLUDE_vTaskDelete                                1
     
183. #define INCLUDE_vTaskCleanUpResources        1
     
184. #define INCLUDE_vTaskSuspend                        1
     ! U2 L/ U; _/ z5 H
185. #define INCLUDE_vTaskDelayUntil                        1
     ( ]6 t9 Z7 v& t9 h+ D/ m9 d( r3 q
186. #define INCLUDE_vTaskDelay                                1
     * ]9 F: ?) o0 _
187. 
     
188. /*
     
189. * Cortex-M内核使用8bit来配置优先级，但是STM32只使用了高4bit，数值越小，优先级越高。
     $ ~. E! V0 G& v3 a
190. * 在往寄存器里面写数值配置的时候，是按照8bit来写的，所以真正写的时候需要经过转换，公式为：
     
191. * ((priority << (8 - __NVIC_PRIO_BITS)) & 0xff)，其中的priority就是我们配置的真正的优先级
     ' q* Z8 z8 G% t1 C, `1 X
192. */
     ; O. `) A. l& r8 i8 O
193. //Use the system definition, if there is one
     
194. #ifdef __NVIC_PRIO_BITS
     , L- f( s* u+ a* A
195.         #define configPRIO_BITS       __NVIC_PRIO_BITS
     - O0 O; [. ~7 G
196. #else
     
197.         #define configPRIO_BITS       4        /* 15 priority levels */
     , L7 K- t: U% r1 u. ~0 Z3 n
198. #endif
     1 d4 j+ ?; r9 G4 D' \: X
199. 
     
200. #define configLIBRARY_LOWEST_INTERRUPT_PRIORITY                        15
     
201. 
     ( V& V, `2 g4 `
202. /**
     * j) F- F6 m. H  f: m$ F6 B$ ]: O0 E
203. * SysTick和PendSV 都是配置为了最低优先级，即0xf 。这样可以提高系统的实时响应能力，即其他的外部中断可以及时的得到响应。
     
204. *
     
205. */
     
206. /* The lowest priority. */
     
207. #define configKERNEL_INTERRUPT_PRIORITY         ( configLIBRARY_LOWEST_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
     
208. 
     
209. /*
     
210. * 用于配置STM32的特殊寄存器basepri寄存器的值，用于屏蔽中断，当大于basepri值的优先级的中断将被全部屏蔽。basepri只有4bit有效，
     7 a% b  F* {+ O
211. * 默认只为0，即全部中断都没有被屏蔽。configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY配置为：5，意思就是中断优先级大于5的中断都被屏蔽。
     
212. * 当把配置好的优先级写到寄存器的时候，是按照8bit来写的，所以真正写的时候需要经过转换，公式为：
     4 M9 z) a& O5 o% W, e
213. * ((priority << (8 - __NVIC_PRIO_BITS)) & 0xff)，其中的priority就是我们配置的真正的优先级。经过这个公式之后得到的是下面的这个宏：
     
214. * configMAX_SYSCALL_INTERRUPT_PRIORITY
     % e5 E2 \' R% f( G
215. *
     
216. * 在FreeRTOS中，关中断是通过配置basepri寄存器来实现的，关掉的中断由配置的basepri的值决定，
     & N; n4 C$ ]5 |0 d& q# r- ?
217. * 小于basepri值的中断FreeRTOS是关不掉的，这样做的好处是可以系统设计者可以人为的控制那些非常重要的中断不能被关闭，在紧要的关头必须被响应。
     & [8 _8 p& _4 ]* _+ n# I4 D/ k
218. * 而在UCOS中，关中断是通过控制PRIMASK来实现的，PRIMASK是一个单1的二进制位，写1则除能除了NMI和硬 fault的所有中断。
     
219. * 当UCOS关闭中断之后，即使是你在系统中设计的非常紧急的中断来了都不能马上响应，这加大了中断延迟的时间，如果是性命攸关的场合，那后果估计挺严重。
     ! w& A' l' m! b; Q4 V
220. * 相比UCOS的关中断的设计，FreeRTOS的设计则显得人性化很多。
     9 F' O* N* V3 m! S- |# H5 f
221. */
     $ E) D# \6 Q- ?% E; M1 n& q
222. #define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY        5
     
223. 
     " N- A; O" m4 [
224. /* Priority 5, or 95 as only the top four bits are implemented. */
     
225. /* !!!! configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to zero !!!!
     1 I, j9 a( S, t4 |' U
226. See <a href="http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html." target="_blank">http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html.</a> */
     * v$ h) A3 T3 a0 q+ g
227. #define configMAX_SYSCALL_INTERRUPT_PRIORITY         ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
     4 T- f; V" r2 Q6 d* t
228. 
     
229. #define configASSERT( x ) if( ( x ) == 0 ) { taskDISABLE_INTERRUPTS(); for( ;; ); }
     ( ?# M# j8 {9 A) P! I& n" i
230. 
     + J6 t* t- Y9 {8 E  s+ b' {* C
231. /**
     
232. * 在 FreeRTOS 的移植文件 port.c 中有用到 SVC 中断的 0 号系统服务，即 SVC 0。此中断在 FreeRTOS中仅执行一次， 用于启动第一个要执行的任务。
     
233. * 另外， 由于 FreeRTOS 没有配置 SVC 的中断优先级，默认没有配置的情况下， SVC 中断的优先级就是最高的 0。
     6 j, u3 ?' q- Q; z$ C$ k
234. */
     1 R% Z8 `* n0 v0 K# _! d
235. #define vPortSVCHandler SVC_Handler
     : I5 [' k7 m& K9 q& c& C/ f) @
236. 
     
237. /**
     - h0 e9 |4 Z  Q* N& S
238. * SysTick和PendSV 都是配置为了最低优先级
       E# l( y" }! U. f1 D
239. */
     
240. #define xPortPendSVHandler PendSV_Handler
     
241. #define xPortSysTickHandler SysTick_Handler
     / a% u! t2 {: ^' a7 S
242. 
     
243. #endif /* FREERTOS_CONFIG_H */
     

复制代码

8.修改stm32f10x_it.c文件，注释void SVC_Handler(void), void PendSV_Handler(void), void SysTick_Handler(void)三个函数。因为这三个函数已经在port.c中实现了，并且在配置文件中通过宏定义的方式对应起来（也可以在启动文件中修改相应的中断向量名）。
+ e7 i0 ~  L: c4 f$ X0 M3 ?' |7 P, d, q

1. /**
   , B+ S# _4 H8 C4 W1 S
2. * 在 FreeRTOS 的移植文件 port.c 中有用到 SVC 中断的 0 号系统服务，即 SVC 0。此中断在 FreeRTOS中仅执行一次， 用于启动第一个要执行的任务。
   & ]: v: Q* i! c. z% Q' j
3. * 另外， 由于 FreeRTOS 没有配置 SVC 的中断优先级，默认没有配置的情况下， SVC 中断的优先级就是最高的 0。
   
4. */
   / m/ J: |0 E+ e6 j% }9 R
5. #define vPortSVCHandler SVC_Handler
   
6. 
     Y" g, f! D  h# S( Q
7. /**
   
8. * SysTick和PendSV 都是配置为了最低优先级
   - S# A* D0 Q# p
9. */
   & s$ d" B+ B# T5 ^4 P7 ~
10. #define xPortPendSVHandler PendSV_Handler
    
11. #define xPortSysTickHandler SysTick_Handler

复制代码

9.配置MCU的中断优先级。移植了FreeRTOS的MCU一般采用第四中断优先级分组，即全部的四位都用来配置抢占优先级（共16个抢占式中断优先级）。
% ^: N# ~  ]7 p' N4 S; j( u2 z

1. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);

复制代码

) t4 V/ ]! J6 s- I修改延时函数
延时函数在STM32单片机开发的项目中有广泛的应用，微秒级延时在一些时间要求严格的场景下（例如软件模拟I2C通讯）是必不可少的。由于FreeRTOS默认采用了system tick作为时间片分配的时基定时器，可能与利用system tick设计的延时函数出现冲突。再加上FreeRTOS提供的延时函数void vTaskDelay( const TickType_t xTicksToDelay )最小的延时时间等于FreeRTOS的tick时间（一般设置为1ms），因此需要重新设计一套不基于system tick的微秒级延时函数。利用CM3/4内核中的数据观察点与跟踪(DWT)寄存器，可以在不占用硬件外设定时器的情况下实现微秒级的精准延时。延时函数的设计与实现可以参考笔者的《STM32开发项目：微秒级的精准延时》这篇博文，以下给出核心代码实现：
6 Q0 e1 ~+ J" X3 I) {

1. // 0xE000EDFC DEMCR RW Debug Exception and Monitor Control Register.
   4 P. F# @8 V: B2 R) \
2. #define DEMCR           ( *(__IO uint32_t *)0xE000EDFC )
   
3. #define TRCENA          ( 0x01 << 24) // DEMCR的DWT使能位
   3 A9 A+ D# ~& B( D9 u, J
4. 
   
5. #define  DBGMCU_CR   *(__IO uint32_t *)0xE0042004                        //MCU调试模块控制寄存器，详细内容参考《stm32中文参考手册》调试支持（DBG）章节，747页
   % G/ D1 z% @8 i
6. 
   
7. // 0xE0001000 DWT_CTRL RW The Debug Watchpoint and Trace (DWT) unit
   # ]- T& D) [4 F1 A8 Y" H
8. #define DWT_CTRL        ( *(__IO uint32_t *)0xE0001000 )
   
9. #define DWT_CTRL_CYCCNTENA       ( 0x01 << 0 ) // DWT的SYCCNT使能位
   
10. 
    
11. // 0xE0001004 DWT_CYCCNT RW Cycle Count register,
    
12. #define DWT_CYCCNT      ( *(__IO uint32_t *)0xE0001004) // 显示或设置处理器的周期计数值
    
13. 
    
14. void delay_init()
    
15. {
    2 a) d3 i" C0 x/ E1 |
16.         //使能DWT外设
    ( b6 f3 L* f; v0 ]& C7 n- B
17.         DEMCR |= (uint32_t)TRCENA;
    
18. 
    
19.         //DWT CYCCNT寄存器计数清0
    
20.         DWT_CYCCNT = (uint32_t)0u;
    
21. 
    
22.         //使能Cortex-M3 DWT CYCCNT寄存器
    & x4 _4 G) h. w, M/ `
23.         DWT_CTRL |= (uint32_t)DWT_CTRL_CYCCNTENA;
    
24. }
    1 u6 B5 I5 @! i! n0 A- o3 k0 M5 b
25. 
    0 P2 M3 {2 Z, t
26. // 微秒延时
    
27. void delay_us(uint32_t uSec)
    
28. {
    ) p( c6 X3 `) ?' s+ A
29.         uint32_t ticks_start, ticks_end, ticks_delay;
    
30. 
    8 E% d$ y; _( G8 t8 Z% V! A2 o
31.         ticks_start = DWT_CYCCNT;
    
32. 
    0 G  V+ U1 \8 `% ?1 L3 [
33.         ticks_delay = ( uSec * ( SystemCoreClock / (1000000) ) ); // 将微秒数换算成滴答数
    
34. 
    - A4 [9 q9 @. L
35.         ticks_end = ticks_start + ticks_delay;
    * B2 H  F2 }1 P
36. 
    
37.         if ( ticks_end > ticks_start )
    
38.         {
    , y9 k8 p. P( `8 L7 v! f7 T6 K
39.                 while( DWT_CYCCNT < ticks_end );
    
40.         }
    . X- w9 P8 k1 W5 x
41.         else // 计数溢出，翻转
    
42.         {
    ' k- c3 G! u" u
43.                 while( DWT_CYCCNT >= ticks_end ); // 翻转后的值不会比ticks_end小
    
44.                 while( DWT_CYCCNT < ticks_end );
    4 d  Y0 _! V7 v3 x% i: Q
45.         }
    
46. }
    : P6 d# g: I# ?3 e0 b) B" A4 F
47. 
    
48. void delay_ms(uint16_t ms)
    % w6 H& U) V% M6 ?/ x
49. {
    
50.         delay_us(ms*1000);
    
51. }
    $ x  P. i5 y$ K

复制代码

移植到STM32F407
移植到STM32F407的步骤与上面介绍的步骤基本一致，但有几个不同的地方需要注意：
; R* \6 Y: [# U5 Z' d
ARM_CM3文件夹替换为ARM_CM4F文件夹：在portable文件夹中只保留GCC/ARM_CM4F（使用的STM32CubeIDE开发环境）；在Makefile中添加FreeRTOS头文件：INCLUDE_DIR += -ISource/FreeRTOS/portable/GCC/ARM_CM4F。
( v6 i& M$ X2 ^1 ?  uFreeRTOSConfig.h文件中进行适当的修改。例如可以将分配的堆大小调大#define configTOTAL_HEAP_SIZE ((size_t)50*1024)。
1 Y' V' _6 K+ }. a6 f应用指南
运行FreeRTOS的系统与裸机系统主要区别在于执行业务逻辑的方式发生了改变。裸机系统一般会采用主循环轮询+定时器中断轮询+其他中断抢占的方式来处理复杂的多任务。而FreeRTOS则采用根据功能的不同创建不同优先级的任务，然后借助任务调度器、任务通知等一系列的机制自动分配任务执行的顺序与时间。
3 F; }8 {* d8 t" W$ [+ s% y. }
一般流程
以下列举了运行FreeRTOS的系统的一般流程：
+ w) x. p( C: E1.采用DWT寄存器实现系统的延时函数（项目中可能会用到微秒级的精确延时）。
2.正常初始化RCC时钟（可直接调用"system_stm32f10x.h"中的void SystemInit(void)函数）。
3.正常配置NVIC，需要设置NVIC分组为第四分组。
) c- f0 |; t/ q! n# _+ j4.创建开始任务与各个业务任务，并开启任务调度器。
. F: l- o9 G: \  _
+ a; x1 I6 i. \" Z: \2 v6 r) n
任务创建模板
为了代码移植和管理的方便，可以在用户项目文件夹User中创建"user_task.h"与"user_task.c"两个文件用以集中管理任务。以下列举了创建FreeRTOS的任务的一般流程：

1.创建开始任务，用于启动其他任务，并随即启动任务调度器（在主函数中直接调用void FreeRTOS_Exec( )）。
/ |- }( N5 V, r$ W/ u) o

1. /*************************头文件内容****************************/
   
2. //任务优先级
   6 q7 ^8 g7 m, J9 J$ L
3. #define START_TASK_PRIO     1
   1 r" I# b# \7 r, w3 L& q
4. //任务堆栈大小
   8 `" R4 w" k( L: y! `; q( B
5. #define START_STK_SIZE      200
   5 V9 Y. c, S' O. u
6. //任务句柄
   
7. extern TaskHandle_t StartTask_Handler;
   
8. 
   4 E# ~- H+ g- [4 z8 J/ o9 W+ A( A% d
9. /*************************源文件内容****************************/
   
10. TaskHandle_t StartTask_Handler;
    
11. 
    ) `% \$ ~- O) N! |5 I
12. void start_task(void *pvParameters)
    5 {1 p' ^7 @- d/ H$ u
13. {
    / u7 s. ?3 j7 C' I1 \* |6 v& t" S
14.         taskENTER_CRITICAL();           //进入临界区
    
15.         //创建LED0任务
    
16.         xTaskCreate((TaskFunction_t )led0_task,
    5 n/ w! n1 F1 G) W  l( U) v
17.                         (const char*    )"led0_task",
    
18.                         (uint16_t       )LED0_STK_SIZE,
    8 M' l/ W' V  |& ?- ?8 {
19.                         (void*          )NULL,
    
20.                         (UBaseType_t    )LED0_TASK_PRIO,
    
21.                         (TaskHandle_t*  )&LED0Task_Handler);
    6 v5 j$ k3 j- @. e
22. 
    . ^3 G( _9 w# ~2 b
23.         //创建modbus poll任务
    
24.         xTaskCreate((TaskFunction_t )ModbusPoll_task,
    6 C& K# D+ n/ o( I% m- D1 O/ j) a
25.                         (const char*    )"ModbusPoll_task",
    4 w1 v3 s8 _3 b3 t, i
26.                         (uint16_t       )MODBUS_POLL_STK_SIZE,
    0 b/ I, C0 L$ e" r) k% D. b
27.                         (void*          )NULL,
    
28.                         (UBaseType_t    )MODBUS_POLL_TASK_PRIO,
    
29.                         (TaskHandle_t*  )&ModbusPollTask_Handler);
    
30. 
    
31.         //创建ads1115 DAQ任务
    3 I" e. B' F) f# i6 K* l7 _
32.         xTaskCreate((TaskFunction_t )ADS1115Daq_task,
    ; f0 v  K5 P' h, l
33.                         (const char*    )"ADS1115Daq_task",
    
34.                         (uint16_t       )ADS1115_DAQ_STK_SIZE,
    
35.                         (void*          )NULL,
    
36.                         (UBaseType_t    )ADS1115_DAQ_TASK_PRIO,
    , J( [2 w, o: y# f  z+ `6 C! K/ ^
37.                         (TaskHandle_t*  )&ADS1115DaqTask_Handler);
    
38. 
    
39.         //创建刷新modbus寄存器执行动作的任务
    
40.         xTaskCreate((TaskFunction_t )MBRefresh_task,
    
41.                         (const char*    )"MBRefresh_task",
    4 @- t, Q$ _, W3 t" |
42.                         (uint16_t       )MBREFRESHTASK_STK_SIZE,
    5 w6 Q$ I8 l5 V
43.                         (void*          )NULL,
    & T- C/ U! z) z$ _* K0 a
44.                         (UBaseType_t    )MBREFRESHTASK_TASK_PRIO,
    
45.                         (TaskHandle_t*  )&MBRefreshTask_Handler);
    " g5 C. @9 A1 h0 `8 d
46. 
    3 g3 n1 T( B3 }5 x4 }
47.         vTaskDelete(StartTask_Handler); //删除开始任务
    
48.         taskEXIT_CRITICAL();            //退出临界区
    * J) n! b5 `1 p: F
49. }
    
50. 
    
51. void FreeRTOS_Exec()
    1 D4 P. |7 B0 K6 z, i
52. {
    ( O# k- M5 d, J) D
53.         //创建开始任务
    : w4 a+ G+ Z& |/ Z& d, \9 X( U
54.         xTaskCreate((TaskFunction_t )start_task,                        //任务函数
    
55.                         (const char*    )"start_task",                                        //任务名称
    
56.                         (uint16_t       )START_STK_SIZE,                                //任务堆栈大小
    9 T, B& m3 c: B) L) C; j- J5 o
57.                         (void*          )NULL,                                                                //传递给任务函数的参数
    
58.                         (UBaseType_t    )START_TASK_PRIO,                //任务优先级
    3 Z5 a- a/ I3 E% C5 Y
59.                         (TaskHandle_t*  )&StartTask_Handler);                //任务句柄
    
60. 
    
61.         vTaskStartScheduler();                                                                        //开启任务调度
    $ [- @# k+ f* L( n( n! s. I/ B
62. }
    

复制代码

& {2 d$ b+ @; x# m" t1 f2.根据项目的不同，设计并创建业务任务的执行函数（由开始任务创建并启动）。以下列举几个常用的任务执行函数：
0 A# N) j5 O& T3 J1 X

1. /*************************头文件内容****************************/
   # A8 M* b% b& {" O
2. //任务优先级
   7 P" Z  N0 y, v7 u' x+ g! n( S/ c
3. #define LED0_TASK_PRIO      0
   + ~8 O, C' k  {2 `# k) H$ L
4. //任务堆栈大小
   0 r; V  Y" z1 P6 ]0 t
5. #define LED0_STK_SIZE       50
   
6. //任务句柄
   
7. extern TaskHandle_t LED0Task_Handler;
   : l* ?; k2 m% K1 F' e2 A" d
8. 
   
9. //任务优先级
   ! E/ G$ ]/ ?  I* O6 V+ T
10. #define MODBUS_POLL_TASK_PRIO      1
    , }$ l8 |3 T; t9 U9 b9 f: d
11. //任务堆栈大小
    # r! I& u8 }1 B4 [  Y4 E/ {
12. #define MODBUS_POLL_STK_SIZE       100
    , ~8 j. H  K# e3 Y5 q
13. //任务句柄
    
14. extern TaskHandle_t ModbusPollTask_Handler;
    & i3 a! G7 C8 D
15. 
    4 {$ z* @8 S2 X
16. //任务优先级
    / T, V6 x: c' N, V7 S( P
17. #define ADS1115_DAQ_TASK_PRIO      2
    $ J' H4 z9 C& m3 B8 `* y
18. //任务堆栈大小
    7 L) \9 S  `+ k+ ~) ~0 S: p
19. #define ADS1115_DAQ_STK_SIZE       100
    
20. //任务句柄
    
21. extern TaskHandle_t ADS1115DaqTask_Handler;
    " B0 [; m  W! u/ C% x) s# E8 y$ J
22. 
    $ k6 A) {( I2 n% @) |+ }
23. //任务优先级
    
24. #define MBREFRESHTASK_TASK_PRIO      0
    8 D4 q% B& m% X# b; \
25. //任务堆栈大小
    
26. #define MBREFRESHTASK_STK_SIZE       100
    6 H0 @9 s6 y: u
27. //任务句柄
    
28. extern TaskHandle_t MBRefreshTask_Handler;
    
29. 
    
30. /*************************源文件内容****************************/
    
31. TaskHandle_t LED0Task_Handler;
    6 K' |/ Z# `; O. ?
32. TaskHandle_t ModbusPollTask_Handler;
    ) ]8 q/ n" h! b* e- b8 x
33. TaskHandle_t ADS1115DaqTask_Handler;
    0 N4 w4 V- p. y: }
34. TaskHandle_t MBRefreshTask_Handler;
    
35. 
    
36. //LED任务函数
    
37. void led0_task(void *pvParameters)
    2 W7 x7 K8 `' v# e3 N
38. {
    : Z" j$ i9 m+ ~8 u) Z: r; K
39.         while(1)
    
40.         {
    
41.                 MCU_LED=~MCU_LED;
    
42.                 vTaskDelay(200);
    
43.         }
    9 t9 L7 o/ C1 E: T/ I
44. }
    1 Q4 o# R' G; H4 V5 d
45. 
    
46. //modbus功能任务
    , ^# Z. Q; a- O5 J7 ], ^2 P
47. void ModbusPoll_task(void *pvParameters)
    
48. {
    ( M4 C5 R% _, A  T; }' ?3 J; j% t1 M& ]
49.         TickType_t ticks = xTaskGetTickCount();
    2 G7 x3 l% n$ R  M% [
50. 
    
51.         //        User_MB_InitPortParam(3, 115200, MB_PAR_NONE);
    / S4 ~2 E+ \, n
52.         User_MB_InitRegs();
    ' |) g2 E- J* T4 l
53.         eMBInit( MB_RTU, FREEMODBUS_DEV_ADDR, FREEMODBUS_PORT_NUM, FREEMODBUS_PORT_BAUDRATE, FREEMODBUS_PORT_PARITY);
    
54.         eMBEnable(  );
    
55. 
    
56.         while (1)
    
57.         {
    
58.                 eMBPoll();
    
59.                 //                modbus_user_variate_limit();
    6 ?/ S( |/ R3 t! O9 B! Z3 z* |4 c
60.                 //                daemon_refresh();
    
61. 
    & Q0 X2 O0 x; P
62.                 //1ms 一个处理周期
    ! F. R2 R* q8 P" v+ b1 e" ?6 o
63.                 vTaskDelayUntil( &ticks, 1 );
    ) X9 F2 \0 ^5 \
64.         }
    
65. }
    
66. 
    
67. //ADS1115的采集任务
    # b- v+ H  t" K* ^) V# I( \+ |
68. void ADS1115Daq_task(void *pvParameters)
    
69. {
    : {5 l9 {9 D  S  S, N
70.         int16_t adcDataTemp[4] = {0};
    1 p2 f2 ~2 c8 L
71. 
    
72.         TickType_t ticks = xTaskGetTickCount();
    5 m7 H5 j: v2 I, [
73. 
    
74.         I2C_Virtual_ConfigPort(ADS1115_SDA_PORT, ADS1115_SDA_PIN, ADS1115_SCL_PORT, ADS1115_SCL_PIN);
    
75.         I2C_Virtual_SwitchBus(ADS1115_SDA_PORT, ADS1115_SDA_PIN, ADS1115_SCL_PORT, ADS1115_SCL_PIN);
    
76. 
      U& A6 P" k5 L9 M8 h0 \) m
77.         ADS1115_UserConfig2();
    
78. 
    
79.         while (1)
    / @) I5 k' }8 ]1 @
80.         {
    
81.                 for (uint8_t chan = 0; chan < 2; chan++)
    
82.                 {
    
83.                         ADS1115_ScanChannel(chan);
    - P# v8 z8 Y/ f) a
84.                         vTaskDelay(10);
    
85. 
    1 d3 ?: o# O9 m& \% @
86.                         if(ADS1115_ReadRawData(&adcDataTemp[chan])!=0)
    
87.                         {
    
88.                                 //保留小数点后三位精度
    
89.                                 SensorData[chan].value = (float)(ADS1115_RawDataToVoltage(adcDataTemp[chan])*1000)/1000.0;
    ) z# r+ Z: |2 V7 h" T3 h
90.                         }
    
91.                 }
    + T" @6 b2 A- E/ z( k
92. 
    
93.                 //100ms 一个处理周期
    
94.                 vTaskDelayUntil( &ticks, 100);
    
95.         }
    + j. X5 C, e& [5 ~: `4 b
96. }
    
97. 
    
98. //其他数据的刷新任务
    ; f. C5 P: V# s; ]
99. void  MBRefresh_task(void *pvParameters)
    
100. {
     8 |1 \4 U; G6 t7 k8 f5 b
101.         TickType_t ticks = xTaskGetTickCount();
     2 |7 [; H- [6 x/ h! _' O
102. 
     / y* _+ ~6 S- p3 l
103.         while (1)
     0 _8 A, P, c+ y$ J6 Q# L+ t
104.         {
     3 j; ]/ x& n  G/ K0 e. W
105.                 User_RefreshData();
     & I, F+ t) I7 f( f9 F4 S2 V& q
106.                 User_RefreshAction();
     
107. 
     
108.                 //500ms 一个处理周期
     . O& y( c% t/ s5 k4 \$ n( T
109.                 vTaskDelayUntil( &ticks, 500);
     
110.         }
     
111. }
       |. z* h+ U( T) _( K8 A
112. 
     
113. 
     

复制代码