01. 概述
; e3 x. X/ w1 `我们以前使用51、AVR、STM32单片机裸机的时候一般都是在main函数里面用while(1)做一个大循环来完成所有的处理，即应用程序是一个无限的循环，循环中调用相应的函数完成所需的处理。有时候我们也需要中断中完成一些处理。相对于多任务系统而言，这个就是单任务系统，也称作前后台系统，中断服务函数作为前台程序，大循环while(1)作为后台程序。



前后台系统的实时性差，前后台系统各个任务都是排队等着轮流执行，不管你这个程序现在有多么紧急，没轮到你就只能等着。相当于所有的任务的优先级都是一样的。但是前后台系统简单，资源消耗也少，稍微大一点的嵌入式应用中前后台系统就明显力不从心了，此时就需要多任务系统。
$ w& p8 S% s/ |8 W* [
/ g% J( Z$ {  Q) W3 S  Z  }) E0 c多任务系统就是把一个大应用分而治之，把大问题划分成很多小问题，逐步的把小问题解决掉，大问题也就随之解决了，这些小问题可以单独的作为一个小任务来处理。这些小任务是并发处理的，并不是说同一时刻执行很多任务，而是由于每个任务执行的时间很短，导致看起来像是同一时刻执行了很多个任务一样。RTOS系统中有一个任务调度器。不同的系统其任务调度器的实现方法也不相同，比如FreeRTOS是一个抢占式的实时多任务系统，那么其任务调度器也是抢占式的。


9 t; o# v% J/ z* C7 C  c
- F: g- B. w4 y+ a高优先级的任务可以打断低优先任务的运行而取得CPU的使用权，这样就保证了那些紧急任务的运行。我们就可以为那些对实时性要求高的任务设置一个很高的优先级。高优先级的任务执行完成以后重新将CPU的使用权归还给低优先级的任务，这个就是抢占式多任务系统的基本原理。
1 ~& u! U6 g" J: l( F7 e$ N
02. FreeRTOS任务
0 ?5 ]9 u) m4 Y# n9 {FreeRTOS中应用既可以使用任务，也可以使用协程，或者两者混合使用。但是任务和协程使用不同的API函数，因此不能通过队列（或者信号量）将数据从任务发送给协程，反之亦然。协程是为那些资源很少的MCU准备的，其开销很小，但是FreeRTOS官方已经不打算在更新协程了。

2.1 任务的特性

+ `3 u3 B: @. j3 i: I8 X3 T2 e1 q4 m简而言之：使用RTOS的实时应用程序可认为是一系列独立任务的集合。每个任务在自己的环境中运行，不依赖于系统中的其它任务或者RTOS调度器。在任何时刻，只有一个任务得到运行，RTOS调度器决定运行哪个任务。调度器会不断的启动、停止每一个任务，宏观看上去就像整个应用程序都在执行。作为任务，不需要对调度器的活动有所了解，在任务切入切出时保存上下文环境（寄存器值、堆栈内容）是调度器主要的职责。为了实现这点，每个任务都需要有自己的堆栈。当任务切出时，它的执行环境会被保存在该任务的堆栈中，这样当再次运行时，就能从堆栈中正确的恢复上次的运行环境。
. x0 K" G, ~7 z1 [5 g
任务特性：
简单
没有使用限制
$ {5 |7 M* |5 C4 y" N( N4 d9 K# s. Z支持完全抢占
# V) K1 B( z/ B支持优先级
& P4 s0 l- w' A' {4 t& m每个任务都有自己的堆栈，消耗RAM较多
如果使用抢占，必须小心的考虑可重入问题
% t6 c: I/ B, D# y03. FreeRTOS协程
协程是为了那些资源很少的MCU而出现的，但是随着MCU的飞速发展，性能越来越强大，现在协程几乎很少用到了，但是FreeRTOS目前还没有将协程移除，但是FreeRTOS是绝对不会再更新和维护协程了，因此协程大家了解一下就行了。在概念上协程和任务是相似的，但是有如下根本上的不同。
( I7 J) s7 m$ c5 I0 Z% k3 k6 Z
3 g9 N: r6 S( r" ^) _& l& U. S3 m% |1.堆栈使用
所有的协程使用同一个堆栈，这样就比使用任务消耗更少的RAM。

; t. [2 J1 A5 ^7 h" M2 q: C' u' |+ L2.调度器和优先级
, b0 m% D9 D+ n# n' j2 a1 j! J' B协程使用合作式的调度器，但是可以再使用抢占式的调度器中使用协程。

) T! h2 b2 j/ c1 x! B' }$ p& D. m3.宏实现
. I8 x7 N3 m' ^9 |4 T2 R协程是通过宏定义来实现的。

4.使用限制
; g, P0 E! X+ P" A为了降低对RAM的消耗做了很多的限制。

04. 任务状态
一个任务可为下面中的一个：
' ]) g& C" G! }" f& K
运行：如果一个任务正在执行，那么说这个任务处于运行状态。此时它占用处理器。
* |5 @7 g. D  i# H$ y$ D6 [0 d
6 E8 m5 P) Z& _3 E. d# i就绪：就绪的任务已经具备执行的能力（不同于阻塞和挂起），但是因为有一个同优先级或者更高优先级的任务处于运行状态而还没有真正执行。

: m( C/ _) o# |0 h! A# Y+ P+ G阻塞：如果任务当前正在等待某个时序或外部中断，我们就说这个任务处于阻塞状态。比如一个任务调用vTaskDelay()后会阻塞到延时周期到为止。任务也可能阻塞在队列或信号量事件上。进入阻塞状态的任务通常有一个“超时”周期，当事件超时后解除阻塞。

6 i* P! b- k9 t7 k挂起：处于挂起状态的任务同样对调度器无效。仅当明确的分别调用vTaskSuspend() 和xTaskResume() API函数后，任务才会进入或退出挂起状态。不可以指定超时周期事件（不可以通过设定超时事件而退出挂起状态）
  V7 M, w7 D9 H+ _1 R  x
9 T; j4 b* z7 e& a5 W/ q任务状态之间的转换如下图所示：

* s! ^0 \$ C7 M/ i

, X& ~# Q/ a" T5 L05. 任务优先级
每个任务都要被指定一个优先级，从0~configMAX_PRIORITIES，configMAX_PRIORITIES定义在FreeRTOSConfig.h中。
$ s( p; j: ?5 M; ]1 x# N" q
如果某架构硬件支持CLZ（或类似）指令（计算前导零的数目，Cortex-M3是支持该指令的，从ARMv6T2才支持这个指令），并且打算在移植层使用这个特性来优化任务调度机制，需要有一些步骤，首先将FreeRTOSConfig.h中configUSE_PORT_OPTIMISED_TASK_SELECTION设置为1，并且最大优先级数目configMAX_PRIORITIES不能大于32。除此之外，configMAX_PRIORITIES可以设置为任意值，但是考虑到configMAX_PRIORITIES设置越大，RAM消耗也越大，一般设置为满足使用的最小值。
  [) v3 |" t, k* v3 u" U0 q9 n* g2 h
低优先级数值代表低优先级。空闲任务（idle task）的优先级为0（tskIDLE_PRIORITY）。
7 A0 d1 u. Q5 t% ^4 `- B
$ Q* z2 y; P  l" Z6 J, MFreeRTOS调度器确保处于最高优先级的就绪或运行态任务获取处理器，换句话说，处于运行状态的任务，只有其中的最高优先级任务才会运行。

任何数量的任务可以共享同一个优先级。如果宏configUSE_TIME_SLICING未定义或着宏configUSE_TIME_SLICING定义为1，处于就绪态的多个相同优先级任务将会以时间片切换的方式共享处理器。
: h, o! n, }" c1 y
$ x* Q: w9 E4 E6 D! P; G06. 任务实现
& T! g2 h- r1 ~6 @; t0 P0 V一个任务具有以下结构：
1 v3 V/ k. j" n; [$ c. H1 n& v

1. void vATaskFunction( void *pvParameters )
   5 l6 \, N2 x: Y# @  O; m
2. {
   2 s. d% {! ]$ O9 _: t6 u# N# ~
3.     for( ;; )
   # M4 w4 _  ?9 `0 I7 M: M/ n
4.     {
   $ m: {5 b" ]. {; G- ?
5.         /*-- 应用程序代码放在这里. --*/
   
6.     }
   
7. 
   
8.     /* 任务不可以从这个函数返回或退出。在较新的FreeRTOS移植包中，如果
   
9.     试图从一个任务中返回，将会调用configASSERT()（如果定义的话）。
   
10.     如果一个任务确实要退出函数，那么这个任务应调用vTaskDelete(NULL)
    % I/ s+ ?$ H, J9 p% T6 _: i$ I4 E
11.     函数，以便处理一些清理工作。*/
    
12.     vTaskDelete( NULL );
    # R7 ]; j3 L6 v4 }% ~
13. }
    

复制代码

任务函数返回为void，参数只有一个void类型指针。所有的任务函数都应该是这样。void类型指针可以向任务传递任意类型信息。
6 ]' T) ]/ y: E- m* e) v
6 t; t* z5 k: [6 R" C任务函数决不应该返回，因此通常任务函数都是一个死循环。
  r9 R! T0 p& k
' Q1 @! k4 d3 R任务由xTaskCreate()函数创建，由vTaskDelete()函数删除。

空闲任务和空闲任务钩子（idle task和Idle Task hook）
8 k& J2 T' Z; I  }8 [+ B
空闲任务
! p! m9 J& c9 A+ h
空闲任务是启动RTOS调度器时由内核自动创建的任务，这样可以确保至少有一个任务在运行。空闲任务具有最低任务优先级，这样如果有其它更高优先级的任务进入就绪态就可以立刻让出CPU。
& ^% ^& R5 B& H  a
删除任务后，空闲任务用来释放RTOS分配给被删除任务的内存。因此，在应用中使用vTaskDelete()函数后确保空闲任务能获得处理器时间就很重要了。除此之外，空闲任务没有其它有效功能，所以可以被合理的剥夺处理器时间，并且它的优先级也是最低的。
, N+ \$ e8 ^+ n  g3 s5 h- H
应用程序任务共享空闲任务优先级（tskIDLE_PRIORITY）也是可能的。这种情况如何配置可以参考configIDLE_SHOULE_YIELD配置参数类获取更多信息。
5 N+ `6 d4 w% [& l3 M& P% q! s
. }+ p3 X; Z1 e: I7 W空闲任务钩子

空闲任务钩子是一个函数，每一个空闲任务周期被调用一次。如果你想将任务程序功能运行在空闲优先级上，可以有两种选择：

1.在一个空闲任务钩子中实现这个功能：因为FreeRTOS必须至少有一个任务处于就绪或运行状态，因此钩子函数不可以调用可能引起空闲任务阻塞的API函数（比如vTaskDelay()或者带有超时事件的队列或信号量函数）。
; r6 A# D1 j6 u; P
2.创建一个具有空闲优先级的任务去实现这个功能：这是个更灵活的解决方案，但是会带来更多RAM开销。
9 h+ j% N# l8 i* q) s/ Q
5 a! J9 ~+ |! c4 U4 s, m8 f创建一个空闲钩子步骤如下：

1.在FreeRTOSConfig.h头文件中设置configUSE_IDLE_HOOK为1；
2.定义一个函数，名字和参数原型如下所示：

1. void vApplicationIdleHook( void );

复制代码

通常，使用这个空闲钩子函数设置CPU进入低功耗模式。

07. 任务控制块
! k7 U4 \5 A0 Y' m/ d2 U6 [( rFreeRTOS中的每个任务都有一些属性需要存储，FreeRTOS将这些属性集合到一起用一个结构体来表示，这个结构体叫做任务控制块：TCP_t，在使用函数xTaskCreate()创建任务的时候就会自动的给每个任务分配一个任务控制块。此结构体在文件tasks.c中有如下声明：

& c, X1 Z9 G/ P* ^

1. /*
   
2. * Task control block.  A task control block (TCB) is allocated for each task,
   6 `) t$ }. u3 F. Q: K
3. * and stores task state information, including a pointer to the task's context
   
4. * (the task's run time environment, including register values)
   
5. */
   ( L+ o/ }0 b% w  A: c* W- v
6. typedef struct tskTaskControlBlock       /* The old naming convention is used to prevent breaking kernel aware debuggers. */
   , K& Z  s3 E1 F1 t7 ~7 T3 b
7. {        //任务堆栈指针
   
8.     volatile StackType_t * pxTopOfStack; /*< Points to the location of the last item placed on the tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE TCB STRUCT. */
   
9. 
   
10.     #if ( portUSING_MPU_WRAPPERS == 1 )
    
11.             //MPU相关设置
    * ?9 |5 G: e4 n
12.         xMPU_SETTINGS xMPUSettings; /*< The MPU settings are defined as part of the port layer.  THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */
    
13.     #endif
    
14.         //状态列表项
    / I/ y9 m# O' c6 I
15.     ListItem_t xStateListItem;                  /*< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */
    - X  f: r. \& K6 B8 `
16.     //事件列表项
    
17.     ListItem_t xEventListItem;                  /*< Used to reference a task from an event list. */
    
18.     //任务优先级
    4 a9 Q8 A( ^2 ]% q
19.     UBaseType_t uxPriority;                     /*< The priority of the task.  0 is the lowest priority. */
    
20.     //任务堆栈起始地址
    . K9 Z0 D; i% H! K- I4 t
21.     StackType_t * pxStack;                      /*< Points to the start of the stack. */
    + V' Z8 e% B6 h, c, p6 J) ?1 N+ u
22.     //任务的名字
    
23.     char pcTaskName[ configMAX_TASK_NAME_LEN ]; /*< Descriptive name given to the task when created.  Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
    8 e% V+ G) e; E. h
24. 
    8 K' Q$ U# p' I' z! M7 ~
25.     #if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )
    . d6 N% u" m$ ^. k
26.             //任务堆栈栈底
    6 D  p% z+ [, V6 R, i/ H
27.         StackType_t * pxEndOfStack; /*< Points to the highest valid address for the stack. */
    / i! I& j+ Y  d! A8 f- x$ }
28.     #endif
    
29. 
    % V8 F( {4 Y4 B* W* L
30.     #if ( portCRITICAL_NESTING_IN_TCB == 1 )
    " b2 ?: i. q9 T# z2 |
31.             //临界区嵌套深度
    
32.         UBaseType_t uxCriticalNesting; /*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */
    1 ?% n) \& S6 e' O; {
33.     #endif
    % a, K  U4 z0 s4 r. c( d, C1 N0 U- l
34. 
    6 C' Y$ C8 g& S+ W1 l7 S
35.     #if ( configUSE_TRACE_FACILITY == 1 )
    
36.             //trace或者debug的时候用得到
    * K$ a. n' C! ?
37.         UBaseType_t uxTCBNumber;  /*< Stores a number that increments each time a TCB is created.  It allows debuggers to determine when a task has been deleted and then recreated. */
    ) I0 y+ v! J  q2 Y: N6 [1 p" W
38.         UBaseType_t uxTaskNumber; /*< Stores a number specifically for use by third party trace code. */
    ; i0 q1 j! d( R: w: B3 y
39.     #endif
    
40. 
    
41.     #if ( configUSE_MUTEXES == 1 )
    
42.             //任务基础优先级，优先级翻转的使用用到
    
43.         UBaseType_t uxBasePriority; /*< The priority last assigned to the task - used by the priority inheritance mechanism. */
    
44.             //任务获取到的互斥信号量个数
    3 F  i  ^5 \0 v- Y9 a! T7 H1 U9 P
45.         UBaseType_t uxMutexesHeld;
    
46.     #endif
      J5 p8 H; R: Z- f$ S+ ^3 ?# ^
47. 
    
48.     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
    
49.         TaskHookFunction_t pxTaskTag;
      {8 T) z5 c% n9 @5 d
50.     #endif
    3 ^# q) W) E& L4 F, a1 r
51. 
    7 G! R/ r5 Z- q0 E( o& _9 c
52.     //与本地存储有关
    
53.     #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
    . ^* |" s' R! }/ s- h
54.         void * pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];
    
55.     #endif
    6 R5 T( e3 |( E# ]$ i( p: E
56. 
    + F4 A# E9 L7 L8 H* x3 ^1 K
57.     #if ( configGENERATE_RUN_TIME_STATS == 1 )
    % r1 s$ s/ \4 |9 D( o
58.             //用来记录任务运行总时间
    
59.         uint32_t ulRunTimeCounter; /*< Stores the amount of time the task has spent in the Running state. */
    
60.     #endif
    
61. 
    
62.     #if ( configUSE_NEWLIB_REENTRANT == 1 )
    
63. 
    + V4 e. W% Q& J* ^4 T# q
64.         /* Allocate a Newlib reent structure that is specific to this task.
    
65.          * Note Newlib support has been included by popular demand, but is not
    $ ^( ]" @+ z$ H6 F# N
66.          * used by the FreeRTOS maintainers themselves.  FreeRTOS is not
    
67.          * responsible for resulting newlib operation.  User must be familiar with
    " u6 d* |- Q( r9 s: x2 G2 S+ C7 l
68.          * newlib and must provide system-wide implementations of the necessary
    
69.          * stubs. Be warned that (at the time of writing) the current newlib design
    
70.          * implements a system-wide malloc() that must be provided with locks.
    
71.          *
    
72.          * See the third party link <a href="http://www.nadler.com/embedded/newlibAndFreeRTOS.html" target="_blank">http://www.nadler.com/embedded/newlibAndFreeRTOS.html</a>
    ! Q: ?) a5 F. h& G+ d
73.          * for additional information. */
    
74.             //定义一个newlib结构体变量
    8 W7 y2 D  n8 Q+ i+ q
75.         struct  _reent xNewLib_reent;
    : v# h4 ~' u2 C! Y
76.     #endif
    2 B4 M* [6 C7 u6 w( Y
77. 
    8 ?: h0 O6 f8 ?
78.     //任务通知相关变量
    7 n7 w" K  v2 I0 W, U/ [( s" W
79.     #if ( configUSE_TASK_NOTIFICATIONS == 1 )
    
80.             //任务通知值
    ) R  s* |5 W* U$ `% u& p
81.         volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    
82.             //任务通知状态
    % J. Z9 r/ C) Q
83.         volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    
84.     #endif
    
85. 
    : @% I  O/ \" ?& A& r1 _3 }
86.     /* See the comments in FreeRTOS.h with the definition of
    
87.      * tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */
      H5 \7 q6 r& {$ I( p
88.     #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */
    
89.         uint8_t ucStaticallyAllocated;                     /*< Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */
    
90.     #endif
    
91. 
    
92.     #if ( INCLUDE_xTaskAbortDelay == 1 )
    
93.         uint8_t ucDelayAborted;
    ' L1 C! c; j. t( {6 C
94.     #endif
    
95. 
      x+ U+ z! b+ `7 e8 r% u
96.     #if ( configUSE_POSIX_ERRNO == 1 )
    
97.         int iTaskErrno;
    4 e& m1 y2 r" D
98.     #endif
    
99. } tskTCB;
    + z) n" d" r) I, A& g$ d9 q
100. 
     
101. /* The old tskTCB name is maintained above then typedefed to the new TCB_t name
     6 M5 J: h( ~( j! k0 U! M) n* x
102. * below to enable the use of older kernel aware debuggers. */
     
103. typedef tskTCB TCB_t;

复制代码

- t+ n3 c7 _$ W$ v  M08. 任务堆栈
& ?% Z5 R. @9 k0 Q' ^& ?FreeRTOS之所以能正确的恢复一个任务的运行就是因为有任务堆栈在保驾护航，任务调度器在进行任务切换的时候会将当前任务的现场保存到在此任务的任务堆栈中，等到此任务下次运行的时候就会先用堆栈中保存的值来恢复现场，恢复现场以后任务就会接着从上次中断的地方开始运行。
& K+ C0 l2 f4 T0 L! Z9 A
- g- E; {8 S  V% l# l创建任务的时候需要给任务指定堆栈，如果使用的函数xTaskCreate()创建任务（动态方法）的话那么任务堆栈就会有函数xTaskCreate()自动创建，后面分析xTaskCreate()的时候会讲解。如果使用函数xTaskCreateStatic()创建任务(静态方法)的话就需要程序员自行定义任务堆栈，然后堆栈首地址作为函数的参数puxStackBuffer传递给函数。

1. TaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode,
   
2.                                     const char * const pcName,     /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
   
3.                                     const uint32_t ulStackDepth,
   " ]: y: F$ J- ^: K7 S+ M
4.                                     void * const pvParameters,
   # b8 @' Q! H) k: k* M- ~2 y
5.                                     UBaseType_t uxPriority,
   
6.                                     StackType_t * const puxStackBuffer,
   
7.                                     StaticTask_t * const pxTaskBuffer ) PRIVILEGED_FUN

复制代码

; z8 v+ h4 U: V
0 P1 R4 k' M) F8 P# {
- G( o3 @3 U% j9 j! F0 E' V