[导读] 学习梳理一下FreeRTOS任务管理单元实现思路，代码分析基于V10.4.3。从本文开始计划写个图解freeRTOS内核系列笔记分享给朋友们，希望大家喜欢。文章中或有错误，也请留言交流指正，或加本人微信进行交流～
, x2 ^; s7 M  c8 i* a

本文主要学习梳理FreeRTOS任务管理器的基本原理，大体框架。

内核任务管理器需求

先来对比一下裸奔系统与RTOS应用系统的编程模型，看看两种编程的不同画风。

裸奔系统

在不用RTOS的单片机应用开发时，编程模型大概是这样的画风：

• 程序的主体是一个死循环，该应用程序由一系列协同工作的函数片段组成，相互实现逻辑配合，实现用户业务需求。该应用程序独占单片机，常规的单片机系统都仅有有一个计算单元核。
• 普通外设I/O,这里所说I/O是指广义的I/O，比如GPIO、PWM、ADC、DAC、LCD显示（当然这里并不严谨，比如ADC,DAC、LCD等也可以产生中断）等。中断函数将异步事件接收成或报文或标志或数值，在与主循环发生逻辑关联。
• 中断外设，比如UART、USB、I2C、定时器、DMA等根据应用需求而使用的中断。这些中断都需要相应的中断函数进行处理异步中断事件。对于输出可能采样主动输出，一般由主循环某一个动作执行；对于输入设备或许采用轮询方式，在与主循环进行耦合。
  , `  J! V$ ~; L0 F3 B4 |

RTOS应用系统

在一个基于RTOS应用系统中，其编程模型大致是下面这样一个画风，有多个并行的任务在相对长的宏观时间维度看起来，多个任务是并行运行的，但对于常规单片机而言（一般都是单核），任一时刻只有一个任务或中断函数在独占CPU核。

• 常见的RTOS没有设备驱动模型，没有对外设设备进行抽象，中断函数将会由用户或调用RTOS 机制，比如event/signal等与任务进行通信
• 任务间还有可能需要通信，或传递消息，或完成某项需求相互间需要同步等
• 同样任务需要与硬件普通IO外设进行打交道，或入或出。但有可能是这个任务实现，也有可能是哪个任务执行。完全取决于开发人员如何设计。
• RTOS实现任务的切入切出，切入使某任务运行；切出使某任务挂起，出让CPU，暂停运行。
• RTOS充当底层支持功能，RTOS还提供丰富的时间管理，队列、邮箱等机制供应用开发使用。
• ......
  

对于单片机而言，一般只有一个核，所有RTOS为了方便理解，可以看成是最最主要的目就是通过软件方法将硬件CPU核程序运行环境抽象为每一个应用任务虚拟出一个软核。这样从时间维度上看起来多任务是并行的，而事实上这种并行是伪并行。

上图仅仅为理解RTOS作用方便，这种虚拟核本质上并不存在，只是将硬件CPU核的运行时上下文（PC指针、状态寄存器等寄存器组、任务运行时临时变量等）通过快照保存切入切出而实现多任务的伪并行运行。

FreeRTOS任务管理器需求

从前文看出，任务管理要实现任务的切入、切出，则首先需要对任务进行抽象描述，以实现在CPU上能够实现切换。根据阅读代码以及文献加上自己的理解，将内核任务管理器的主要功能需求大致梳理成下面这样一张用例图Use case Diagram，仅仅为理解方便，或许并不严谨。

从上图，大致可以看出FreeRTOS任务调度器需要以下一些功能需求：

• 任务抽象描述，一个任务一般本质上是一个死循环程序片段（当然也有任务运行着会退出被杀掉的可能）。对于任务的抽象：
  4 t  a8 [2 D+ n1 y2 K
  • 一般会有任务的执行主体，利用函数主体函数指针进行抽象
  • RTOS常规都是的基于优先级抢占调度算法，因此需要抽象出哪个任务具有更高概率能被执行，用优先级进行描述
  • 任务需要得以切换，就需要将任务在切换间的临时状态进行保存，栈机制就能很好的满足这样的需求，因此每个任务都有一个或大或小的任务栈。其本质上是一片连续的FILO（先入后出）内存。
  • .....
    
• 任务创建、删除等API接口，供应用开发使用。
• 任务调度器控制接口，启动调度器、停止调度器、挂起所有任务、恢复运行等调度器接口。
• 任务杂项信息接口，比如获取任务状态、tick信息、调试、获取任务名等API接口
• 任务调度算法，基于调度策略对运行时的任务进行调度，或挂起、或运行、或就绪等，主要根据调度策略管理任务的切入切出。这里主要涉及到任务间上下文切换、任务与中断函数间的上下文切换两种场景。
• 抽象C运行时环境，现代RTOS应用系统一般基于C语言，抽象C运行时环境，这里主要指栈，当然很多RTOS内核也内核堆，freeRTOS也不例外。熟悉C编程的朋友都知道，堆内存由malloc/free函数操作集提供用户接口，既然C堆已有，为何RTOS内核重新造轮子？为啥内核额外需要实现自己的堆管理器呢？这大体是基于下面些缘由：
  0 r/ F. I* M# t) G
  • 编译器C堆实现，在小型嵌入式系统上有时候并不能直接使用。
  • C堆的实现可能相对较大，占用了较大代码空间。比较浪费有限的代码存储空间。
  • C堆很少是线程安全的。
  • C堆申请执行时间不是确定的， 执行功能所需的时间因调用而异。
  • C堆会在单片机有限的内存资源引发内存碎片问题。
  • C堆会使链接器配置复杂化。
  • C堆如引发未知错误，不便于调试。
    ' o, C) K% C2 L1 w+ ]$ V4 X

FreeRTOS任务描述抽象

对于其中几项必须的关键数据域描述一下其抽象作用：
7 k9 y' x( k" w# A

• pxTopOfStack：指向任务栈栈顶指针
• xStateListItem：任务状态链表描述节点，用于动态将该任务添加、删除到就绪或阻塞任务对列链表中
• xEventListItem：事件链表描述节点，描述本任务相关事件，用于将本任务添加到事件链表中。
• uxPriority：任务优先级，用于描述本任务的优先级。
• pxStack：任务栈指针，指向本任务的任务栈。
• pcTaskName：任务名字符串存储区，长度可配。默认为16字节
  

其他的数据域，可裁剪实现一些更丰富的功能，比如主要用于防治优先级反转的优先级继承机制，trace追踪功能等。限于篇幅，也主要梳理任务管理器的主要原理，就不展开了。

任务创建删除管理

FreeRTOS为用户提供一组函数集用于任务的创建、删除等管理，先看任务的创建API：

BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
      const char * const pcName,     
$ D2 A; m0 F9 J  G      const configSTACK_DEPTH_TYPE usStackDepth,
, x1 U& W( g' P0 M+ P      void * const pvParameters,
      UBaseType_t uxPriority,
% T) B- T8 Y# e: l! u+ X& k. f/ _3 F      TaskHandle_t * const pxCreatedTask ) PRIVILEGED_FUNCTION;

- T- g+ @: q& P  T8 f+ gTaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode,
        const char * const pcName,   
4 h$ \* @. z0 N( S3 D6 N0 p        const uint32_t ulStackDepth,
/ b5 q) {& {6 b3 z        void * const pvParameters,
/ O3 @0 b- }, l" \5 @5 K3 g, S& q, V        UBaseType_t uxPriority,
        StackType_t * const puxStackBuffer,
" ?% [; L' l6 H& o1 E+ W9 T* g        StaticTask_t * const pxTaskBuffer ) PRIVILEGED_FUNCTION;
) M& G" [' g" Y
BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition,
. x& |; L8 r/ h8 [: k0 J* z          TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
0 P8 [5 e) R4 x' X  m+ s
% V( e  O3 Z: e7 q8 l+ XBaseType_t xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition,
6 Y' _/ K; S8 t" ?/ x          TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
+ S' R' L9 R) I: r& r/ I

• xTaskCreate/xTaskCreateStatic 都是用于创建任务而用，其区别在于：
  9 Y8 Y$ J0 ?) m3 v+ x
  • xTaskCreate 申请任务控制块以及栈从内核堆申请
  • xTaskCreateStatic 创建的任务，其任务控制块内存以及任务栈内存由用户传入。或许有朋友会问StaticTask_t这不是任务控制块嘛，仔细看看其结构定义其内存对齐及大小刚好是前面说的任务控制块的定义。
    2 A6 [- V$ }; Y- Q  S% |1 S# c
• xTaskCreateRestricted() /xTaskCreateRestrictedStatic(),主要用于在有或使能MPU单元的芯片中创建任务。这里的MPU是指Memory Protection Unit (MPU)，不是微处理器的意思。这两者的区别与上面两个API类似，主要在于其内存分配方式不同，xTaskCreateRestricted是从内核堆动态申请，xTaskCreateRestrictedStatic用户传入。
• PRIVILEGED_FUNCTION 这个宏是用于存储保护单元芯片的。
  . L9 R( x; u8 K7 T2 N

这几个任务创建函数都是用于任务创建，任务一旦创建就会被插入任务就绪链表中，当调度器调度启动后就按任务状态机根据调度策略以及外部输入事件进行调度接管。这里以xTaskCreate绘制一下其内在干了些啥：

再看看另外两个函数：

void vTaskAllocateMPURegions( TaskHandle_t xTask,
        const MemoryRegion_t * const pxRegions ) PRIVILEGED_FUNCTION;
void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
* X6 m6 e" x( W/ W

• vTaskAllocateMPURegions: 定义一组内存保护单元（MPU）区域，供MPU受限任务使用.
• vTaskDelete: 删除用使用xTaskCreate()或xTaskCreateStatic()创建的任务。
  ; r3 a6 q9 m: e1 e7 [* W7 l

任务控制管理接口void vTaskDelay( const TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
6 a& \' I, o1 v$ x8 ]# |& v4 kBaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
4 G% g9 s6 G! p) V4 e' ?$ ?                            const TickType_t xTimeIncrement ) PRIVILEGED_FUNCTION;
' o9 O# K; x# I# b2 r: ABaseType_t xTaskAbortDelay( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
7 q" k, y( R; X6 v% s) r$ p6 v5 ^void vTaskGetInfo( TaskHandle_t xTask,
                   TaskStatus_t * pxTaskStatus,
, s" w- {: h! e' h, f% X3 y                   BaseType_t xGetFreeStackSpace,
                   eTaskState eState ) PRIVILEGED_FUNCTION;
7 M( U' Y: w9 j( y: q; \void vTaskPrioritySet( TaskHandle_t xTask,
                       UBaseType_t uxNewPriority ) PRIVILEGED_FUNCTION;
7 V# e( c- q( z; gvoid vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;
void vTaskResume( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
! \: w: \  h  n# b& Y' z2 WBaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
. \# R; P2 |& Y4 l$ M

这一系列的API接口操作集主要用于对任务进行挂起延时、获取优先级、自中断函数获取优先级、挂起、恢复运行等操作。基本从其函数名就可以看出其作用。比如：

• vTaskDelay调用，会使调用该函数的任务进入阻塞状态一段时间，时间为传入的tick数。
  " M  b: y0 w' U- s. d+ P# h

这里需要注意的是有的函数在中断函数体里面不可以调用，需要使用专用版本，具体可以看看手册或注释。

调度器控制接口void vTaskStartScheduler( void ) PRIVILEGED_FUNCTION;
: Q, ~. h! b" `) V$ T* Uvoid vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;
  q, N0 j. F! `) Rvoid vTaskSuspendAll( void ) PRIVILEGED_FUNCTION;
BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;
5 [0 n& @/ D* B, X5 j1 B

这一组函数API集主要用于调度器的启动、停止控制：

• vTaskStartScheduler，主要用于待用户任务创建好后，硬件初始化后，启动内核调度器
• vTaskEndScheduler，可用于停止内核调度器，一般很少用到，在一些安全相关的应用可能会在出故障时主动停止调度器。
• vTaskSuspendAll，挂起所有任务，可以用用户逻辑主动挂起所有的任务
• xTaskResumeAll，恢复所有任务为就绪态。
  * }+ ?) x# ]7 h8 N0 v0 O

任务杂项API集

我根据代码及注释及自己理解，将这些API归类到杂项API集合：

TickType_t xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;
( I& H0 M+ m. \% ]3 X$ jUBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
& B2 `2 z* b" q* Jchar * pcTaskGetName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION;     
2 @/ Q* q  o+ E: E2 gTaskHandle_t xTaskGetHandle( const char * pcNameToQuery ) PRIVILEGED_FUNCTION;   
3 f) c; p  p4 P, I4 [/ IUBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
9 Z' q8 g8 p( I  G0 [configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
( i4 B/ z2 _5 ]" ]' Tvoid vTaskSetApplicationTaskTag( TaskHandle_t xTask,
+ K/ B, S2 v4 T& Y         TaskHookFunction_t pxHookFunction ) PRIVILEGED_FUNCTION;
TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
/ S9 @5 T+ ?2 Z8 q. `7 Y4 L  t) n7 k6 nTaskHookFunction_t xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

" j9 }! }: z. L. I" dvoid vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
- [  a' @' q2 x5 T6 Y4 ?( Y          BaseType_t xIndex,
# g; U0 \, u- \6 C' A9 g          void * pvValue ) PRIVILEGED_FUNCTION;
void * pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,

& d' ], q4 A! u" |void vApplicationStackOverflowHook( TaskHandle_t xTask,
           char * pcTaskName );
! v; {# q4 c5 I- a/ N; Svoid vApplicationTickHook( void );
......
; ?( Q- K% P1 w; N" I% ?- EBaseType_t xTaskGenericNotifyStateClear( TaskHandle_t xTask,
) O& _: Y6 h0 M6 B, B1 Y) Y                                         UBaseType_t uxIndexToClear ) PRIVILEGED_FUNCTION;

' Z  K: k( m9 y8 xuint32_t ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
                                        UBaseType_t uxIndexToClear,
" t: B( d8 D& j$ @. I% v! Z                                        uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;
void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
2 d1 K3 P0 n: }- P1 G" P# e
0 a! M$ v( N1 j; O, [BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
                                 TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;

+ y7 L& V9 D+ F6 z7 WBaseType_t xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) PRIVILEGED_FUNCTION;

这些函数具体作用就不赘述，这里仅仅梳理分类，用到时候查手册即可。

跨平台移植接口BaseType_t xTaskIncrementTick( void ) PRIVILEGED_FUNCTION;
void vTaskPlaceOnEventList( List_t * const pxEventList,
8 x, P1 V# ^7 r; e) Y) g4 `                            const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
void vTaskPlaceOnUnorderedEventList( List_t * pxEventList,
* ^$ _% L, z8 j+ \2 Z                                     const TickType_t xItemValue,
+ w2 m  Z7 V+ x: J2 D. s' S9 l! m* h                                     const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
void vTaskPlaceOnEventListRestricted( List_t * const pxEventList,
                                      TickType_t xTicksToWait,
                                      const BaseType_t xWaitIndefinitely ) PRIVILEGED_FUNCTION;
BaseType_t xTaskRemoveFromEventList( const List_t * const pxEventList ) PRIVILEGED_FUNCTION;
1 Z1 z4 q1 b0 H( V: J& W' A9 Jvoid vTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem,
                                        const TickType_t xItemValue ) PRIVILEGED_FUNCTION;
1 D8 w5 q3 m4 Y% J+ v
portDONT_DISCARD void vTaskSwitchContext( void ) PRIVILEGED_FUNCTION;
TickType_t uxTaskResetEventItemValue( void ) PRIVILEGED_FUNCTION;
) q" v( n: O* j1 Z4 y, r  J5 BTaskHandle_t xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;
8 y1 t" @# \  F% o) e/ R8 bvoid vTaskMissedYield( void ) PRIVILEGED_FUNCTION;
BaseType_t xTaskGetSchedulerState( void ) PRIVILEGED_FUNCTION;
7 I4 I, @2 t$ [; a0 M; j2 E+ q0 ?$ BBaseType_t xTaskPriorityInherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;
BaseType_t xTaskPriorityDisinherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;
- f# L- O8 U1 X5 fvoid vTaskPriorityDisinheritAfterTimeout( TaskHandle_t const pxMutexHolder,
UBaseType_t uxTaskGetTaskNumber( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
void vTaskSetTaskNumber( TaskHandle_t xTask,
" O9 b* x; m! o  _                         const UBaseType_t uxHandle ) PRIVILEGED_FUNCTION;
void vTaskStepTick( const TickType_t xTicksToJump ) PRIVILEGED_FUNCTION;

) I0 v6 }3 D) g+ X
eSleepModeStatus eTaskConfirmSleepModeStatus( void ) PRIVILEGED_FUNCTION;
% J3 w6 D# k' s; e
2 R, e3 E' {. L$ fTaskHandle_t pvTaskIncrementMutexHeldCount( void ) PRIVILEGED_FUNCTION;
* Q0 J# L5 j, Q6 M( R- w
void vTaskInternalSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
; R! W& r! s/ h: C/ v+ l- u

这些接口不同硬件平台需要做具化的移植，做差异化的处理，但是对于FreeRTOS统一了内部调用的接口。这样的思路在应用开发时也可以考虑使用，对于公共部分可以抽象出统一的接口，这样在不同平台上可以很方便的进行移植。对于这些接口后面有机会学习整理分享。

对于用例图中的其他部分，核心调度部分以及上下文切换，篇幅所限留在后面学习整理分享。

总结一下

本文基本学习梳理了一下对于FreeRTOS任务调度器外部接口、以及大体作用，基本组成情况，水平所限，文章中错误难免，欢迎交流指正。