8 y6 d/ h+ y+ F' X. l6 T

大家晚上好，我是杰杰，最近挺忙的，好久没有更新了，今天周末就吐血更新一下吧！

" C1 ]$ G6 m# A; u

在文章的最前面，本章主要讲解FreeRTOS任务切换

▲▲▲▲▲

本文是杰杰原创，转载请说明出处：【连载】从单片机到操作系统⑥——FreeRTOS任务切换机制详解

8 ?" z" ?; g" C  w7 a前言
# z/ L0 _, Q) t+ D     FreeRTOS是一个是实时内核，任务是程序执行的最小单位，也是调度器处理的基本单位，移植了FreeRTOS，则避免不了对任务的管理，在多个任务运行的时候，任务切换显得尤为重要。而任务切换的效率会决定了系统的稳定性与效率。
$ ]/ j& c4 p: Z8 F( ]    FreeRTOS的任务切换是干嘛的呢，rtos的实际是永远运行的是具有最高优先级的运行态任务，而那些之前在就绪态的任务怎么变成运行态使其得以运行呢，这就是我们FreeRTOS任务切换要做的事情，它要做的是找到最高优先级的就绪态任务，并且让它获得cpu的使用权，这样，它就能从就绪态变成运行态，这样子，整个系统的实时性就会很好，响应也会很好，而不会让程序阻塞卡死。
    要知道怎么实现任务切换，那就要知道任务切换的机制，在不同的cpu（mcu）中，触发的方式可能会不一样，现在是以Cortex-M3为例来讲讲任务的切换。为了大家能看懂本文，我就抛转引玉一下，引用《Cortex-M3权威指南-中文版》的部分语句（如涉及侵权，请联系杰杰删除）
9 v, x9 Y# a6 r$ ZSVC 和 PendSV
    SVC（系统服务调用，亦简称系统调用）和 PendSV（Pended System Call，可悬起系统调用），它们多用于在操作系统之上的软件开发中。SVC 用于产生系统函数的调用请求。例如，操作系统不让用户程序直接访问硬件，而是通过提供一些系统服务函数，用户程序使用 SVC 发出对系统服务函数的呼叫请求，以这种方法调用它们来间接访问硬件。因此，当用户程序想要控制特定的硬件时，它就会产生一个 SVC 异常，然后操作系统提供的 SVC 异常服务例程得到执行，它再调用相关的操作系统函数，后者完成用户程序请求的服务。
, W5 Y3 q9 A7 `) J0 b) c" `   另一个相关的异常是 PendSV（可悬起的系统调用），它和 SVC 协同使用。一方面，SVC异常是必须立即得到响应的（若因优先级不比当前正处理的高，或是其它原因使之无法立即响应，将上访成硬 fault——译者注），应用程序执行 SVC 时都是希望所需的请求立即得到响应。另一方面，PendSV 则不同，它是可以像普通的中断一样被悬起的（不像 SVC 那样会上访）。OS 可以利用它“缓期执行”一个异常——直到其它重要的任务完成后才执行动作。悬起 PendSV 的方法是：手工往 NVIC 的 PendSV 悬起寄存器中写 1。悬起后，如果优先级不够高，则将缓期等待执行。
9 O1 R* z, \$ A. h3 N    如果一个发生的异常不能被即刻响应，就称它被“悬起”(pending)。不过，少数 fault异常是不允许被悬起的。一个异常被悬起的原因，可能是系统当前正在执行一个更高优先级异常的服务例程，或者因相关掩蔽位的设置导致该异常被除能。对于每个异常源，在被悬起的情况下，都会有一个对应的“悬起状态寄存器”保存其异常请求，直到该异常能够执行为止，这与传统的 ARM 是完全不同的。在以前，是由产生中断的设备保持住请求信号。现在NVIC 的悬起状态寄存器的出现解决了这个问题，即使后来设备已经释放了请求信号，曾经的中断请求也不会错失。
系统任务切换的工程分析
   在系统中正常执行的任务（假设没有外部中断IRQ），用Systick直接做上下文切换是完全没有问题的，如图：
0 `1 A& v6 `# q, \3 g$ ]​
但是问题是几乎很少嵌入式的设备会不用其丰富的中断响应，所以，直接用systick做系统的上下文切换那是不实际的，这存在很大的风险，因为假设systick打断了一个中断（IRQ），立即做出上下文切换的话，则触犯用法 fault 异常，除了重启你没有其他办法了，这样子做出来的产品就是垃圾！！用我老板的话说就是写的什么狗屎！！！如图所示：
4 b- Z$ G8 c- C' x9 T) ~* D: B( D8 i​
6 Y/ ?. u; D" n6 w, p! F# Q5 M    那这么说这样不行那也不行，怎么办啊？请看看前面接介绍的PendSV，是不是有点豁然开朗了？PendSV 来完美解决这个问题。PendSV 异常会自动延迟上下文切换的请求，直到其它的 ISR 都完成了处理后才放行。为实现这个机制，需要把 PendSV 编程为最低优先级的异常。如果 OS 检测到某 IRQ 正在活动并且被 SysTick 抢占，它将悬起一个 PendSV 异常，以便缓期执行上下文切换。
   懂了吗？就是说，只要将PendSV的优先级设为最低的，systick即使是打断了IRQ，它也不会马上进行上下文切换，而是等到IRQ执行完，PendSV 服务例程才开始执行，并且在里面执行上下文切换。过程如图所示：
% u, A& e/ p) V% o6 e4 U​
任务切换的源码实现
1 g6 v+ j  d: q/ m6 t" `5 F( ]过程差不多了解了，那看看FreeRTOS中怎么实现吧！！
% a2 A' I5 Q1 E% o7 A4 NFreeRTOS有两种方法触发任务切换：

•   一种就是systick触发PendSV异常，这是最经常使用的。
• 另一种是主动进行切换任务，执行系统调用，比如普通任务可以使用taskYIELD()强制任务切换，中断服务程序中使用portYIELD_FROM_ISR()强制任务切换。
  ) ?8 A8 B+ e6 }/ v7 _! Q4 K2 e6 e

1
先说说第一种吧，就在systick中断中调用xPortSysTickHandler();
下面是源码：

0 T" `4 D( l7 P( j 1 void xPortSysTickHandler( void )
2 {
3         vPortRaiseBASEPRI();
' x, ~+ q4 O8 ^# o% j! R2 @( X 4          {
  D, q$ ]" s% ~ 5                 /* Increment the RTOS tick. */
2 T% Z' s) r+ ]6 ^0 Z 6                 if ( xTaskIncrementTick() != pdFALSE )
" w0 J0 l  P8 g: `9 d# Q9 W 7                     {
8                         /* A context switch is required.
9               Context switching is performed in
10             the PendSV interrupt.  Pend the PendSV interrupt. */
! ?( @3 A7 _$ l+ p& I/ W! P7 Z2 [1 y/ @, S: y11                         portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
" h8 J9 u  b- V12                     
13         }
14            
15     }
" W; f5 s" }; t( D1 p$ O& e9 P16         vPortClearBASEPRIFromISR();
0 h4 M4 k2 J% i17 }
; d$ [4 ^/ L4 L( z6 e& K
它的执行过程是这样子的，屏蔽所有中断，因为SysTick以最低的中断优先级运行，所以当这个中断执行时所有中断必须被屏蔽。vPortRaiseBASEPRI();就是屏蔽所有中断的。而且并不需要保存本次中断的值，因为systick的中断优先级是已知的，执行完直接恢复所有中断即可。
    在xTaskIncrementTick()中会对tick的计数值进行自加，然后检查有没有处于就绪态的最优先级任务，如果有，则返回非零值，然后表示需要进行任务切换，而并非马上进行任务切换，此处要注意，它只是向中断状态寄存器bit28位写入1，只是将PendSV挂起，假如没有比PendSV更高优先级的中断，它才会进入PendSV中断服务函数进行任务切换。1 #define portNVIC_PENDSVSET_BIT        ( 1UL << 28UL )
然后解除屏蔽所有中断。
1vPortClearBASEPRIFromISR();
! C/ ]+ T% f/ m, I3 j2
另一种方法是主动进行任务切换，不管是使用taskYIELD()还是portYIELD_FROM_ISR()，最终都会执行下面的代码：
- p8 e6 t0 A0 T: h7 E% }# m1#define portYIELD()                                                                \
) W# {0 N1 P0 y% o7 q2 h7 G2{                                                                                \
3    /* Set a PendSV to request a context switch. */                             \
0 j9 v& n; H( b5 g1 K. Y+ x4    portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;                             \                                                                       
5    __dsb( portSY_FULL_READ_WRITE );                                            \
# M  y! v# f4 ]2 X# C: a6 d6    __isb( portSY_FULL_READ_WRITE );                                            \
7}
% g6 Q, w% e" [2 j

: a5 c* u3 y3 j) v4 |其实是一个宏定义来的。同样是向中断状态寄存器bit28位写入1，将PendSV挂起，然后等待任务的切换。
具体的任务切换源码
, h; Y1 l; K3 \; z     一直在说怎么进行任务切换的，好像还没看到任务切换的源码啊，哎，下面来看看任务切换的真面目！！
6 k; b8 q* H6 K/ u0 g* K( `& s 1__asm void xPortPendSVHandler(void)
2{
3    extern uxCriticalNesting;
4    extern pxCurrentTCB;
9 X# W$ v' C* [  l2 g 5    extern vTaskSwitchContext;
6    PRESERVE8
# T+ k6 o+ H( R5 g 7    mrs r0, psp
( p; ^' _" J, \; }) V: L 8    isb
9    ldr r3, =pxCurrentTCB       /* Get the location of the current TCB. */
5 P: Z: J. m/ W- r9 W( f! B3 i10    ldr r2, [r3]
, t3 I. ]# B& Y: V11    stmdb r0!, {r4-r11}         /* Save the remaining registers. */
12    str r0, [r2]                /* Save the new top of stack into the first member of the TCB. */
13    stmdb sp!, {r3, r14}
14    mov r0, #configMAX_SYSCALL_INTERRUPT_PRIORITY
) R4 t. S1 T+ u- C. h: E15    msr basepri, r0
16    dsb
17    isb
/ b& W# Q0 ?9 L18    bl vTaskSwitchContext
$ s  i# y7 z- R! @, h% ]) p19    mov r0, #0
; c" W8 e* v3 Z' z) h: e  C5 T20    msr basepri, r0
21    ldmia sp!, {r3, r14}
$ p" A. W" ]. p7 u22    ldr r1, [r3]
23    ldr r0, [r1]                /* The first item in pxCurrentTCB is the task top of stack. */
. n8 w: n) j3 l9 f, d24    ldmia r0!, {r4-r11}         /* Pop the registers and the critical nesting count. */
; V( P3 u$ M! O! z25    msr psp, r0
26    isb
27    bx r14
( A& y1 E7 ~4 D; L) L) q) R28    nop
29}

  j$ R& \# v* R3 i8 Z" x不是我不想看，是我看到汇编就头大啊，这几天我也在看源码，实在是头大。
  找到核心的函数看看就好啦，不管那么多，有兴趣的可以研究一下中断代码，有不懂的也很欢迎你们来问我，一起研究研究，也是不错的选择。
9 P8 R' l) Y& W) \! [4 ^下面是看重点的地方了：
9 j. s) A. e+ ]" b( T$ N1mov r0,             #configMAX_SYSCALL_INTERRUPT_PRIORITY
2msr basepri, r0

& R0 t; E6 ~$ k- r( ABL是跳转指令嘛，这个我还是有点懂的。
- b' }7 m# B; `; G  调用函数vTaskSwitchContext(),寻找新的任务运行,通过使变量pxCurrentTCB指向新的任务来实现任务切换,然后就是打开中断，退出去了。
寻找下一个要运行任务
" H4 Y7 ^$ [% t* \. F' {/ Q( C7 m* E1 v  是不是感觉没什么大不了的样子，如果你是这样子觉得的，可能还没学到家，赶紧去看看FreeRTOS的源码，在config.h配置文件中是不是有一个叫做硬件查找下一个运行的任务呢？configUSE_PORT_OPTIMISED_TASK_SELECTION，这个在FreeRTOS中叫做特殊方法，其实也是硬件查找啦，但是并不是每种单片机都支持的，如果是不支持的话，只能选择软件查找的方法了，就是所谓的通用方法。通用方法我就不多说了，因为我用的是STM32，他是支持硬件方法的，这样子效率更高，所以我也没必要去研究他的软件方法，假如有兴趣的小伙伴可以研读一下源码，有不懂的可以向我提问，源码如下：
' Z7 I  f( b% ? 1#define taskSELECT_HIGHEST_PRIORITY_TASK()                                                            \
2    {                                                                                                   \
3    UBaseType_t uxTopPriority = uxTopReadyPriority;                                                     \
8 R0 a* y8 M  K0 ` 4                                                                                                        \
5        /* Find the highest priority queue that contains ready tasks. */                                \
( z6 {0 o' K& t; z. ~+ i 6        while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopPriority ] ) ) )                           \
9 a' v: ]5 i. M6 ] 7        {                                                                                               \
/ o% w$ K/ q7 {& A3 c, _) \$ ~$ _ 8            configASSERT( uxTopPriority );                                                              \
. g  L' R0 L" W, f 9            --uxTopPriority;                                                                            \
10        }                                                                                               \
* r( A( v8 Y% w2 l  h11                                                                                                        \
% {& ?1 B4 B$ s3 g12        /* listGET_OWNER_OF_NEXT_ENTRY indexes through the list, so the tasks of                        \
& a% ?. l2 P4 a3 i$ g13        the same priority get an equal share of the processor time. */                                  \
7 x7 q( o7 F$ p' O8 ?; R14        listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) );           \
7 L+ j0 G7 R, U- h! c7 K15        uxTopReadyPriority = uxTopPriority;                                                             \
16    } /* taskSELECT_HIGHEST_PRIORITY_TASK */

  c3 M0 m8 k4 G而硬件的方法源码则在下面：

7 z7 P9 B8 D/ e4 u5 n1    #define taskSELECT_HIGHEST_PRIORITY_TASK()                                                      \
! T. \8 e0 D- F* r, [2 ~) L% z& @2    {                                                                                               \
3        UBaseType_t uxTopPriority;                                                                      \
, Q* p2 ?/ ?  F0 x  w4                                                                                                    \
5        /* Find the highest priority list that contains ready tasks. */                             \
6        portGET_HIGHEST_PRIORITY( uxTopPriority, uxTopReadyPriority );                              \
7        configASSERT( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ uxTopPriority ] ) ) > 0 );     \
" j) U" M( `' g  b, ]5 J/ W8        listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) );       \
4 V5 q' n7 o! k  V7 f6 Y1 R  X9    } /* taskSELECT_HIGHEST_PRIORITY_TASK() */

其方法是利用硬件提供的计算前导零指令CLZ，具体宏定义为：
1#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31UL - ( uint32_t ) __clz( ( uxReadyPriorities ) ) )  
6 H! Y2 Y! D0 y4 c& r
7 ~4 Y' G0 y+ ^/ ]
静态变量uxTopReadyPriority包含了处于就绪态任务的最高优先级的信息，因为FreeRTOS运行的永远是处于最高优先级的运行态，而下个处于最高优先级的就绪态则必定会在下次任务切换的时候运行，uxTopReadyPriority使用每一位来表示任务是否处于就绪态，比如变量uxTopReadyPriority的bit0为1，则表示存在优先级为0的任务处于就绪态，bit6为1则表示存在优先级为6的任务处于就绪态。并且，由于bit0的优先级高于bit6，那么下个任务就是bit0的任务运行了（数组越低优先级越高）。由于32位整形数最多只有32位，因此使用这种特殊方法限定最大可用优先级数目为32，即优先级0~31。得到了下个处于最高优先级就绪态任务了，就调用listGET_OWNER_OF_NEXT_ENTRY来获取下一个任务的列表项，然后将该列表项的任务控制块TCB赋值给pxCurrentTCB，那么我们就得到下一个要运行的任务了。
至此，任务切换已经完成。
- H2 P  U* {1 ]0 W( ^8 T  YEND
8 g9 O% }2 ^) ^
$ o; m( U5 k% b2 `5 F4 G+ `0 ~1 p5 {更多好文章请关注杰杰。
( M* u- y9 P; B# j# V% ^% S
1 a$ k( x% X) v/ I; c" S【连载】从单片机到操作系统⑤——FreeRTOS列表&列表项的源码解读
; Q  B3 }1 @3 W! t! U【连载】从单片机到操作系统④——FreeRTOS创建任务&开启调度详解

4 W* Q7 m+ k4 ?- T* G【连载】从单片机到操作系统③——走进FreeRTOS
STM32进阶之串口环形缓冲区实现
本文直接引用了《Cortex-M3权威指南》的部分语句







0 V/ M! m# ]8 P% p# \6 s

imarookie 发表于 2018-10-30 10:46
1 U% y  Z* d0 }& O1 f任务怎么切换的啊   比如说从高优先级任务怎么切换到低优先级任务的，机制是什么  我看的一脸懵逼，能通俗 ...

高优先级任务通过主动放弃CPU使用权来切换到底优先级任务，，比如挂起，阻塞延时等方式
2 u& h% D2 T1 u" u
而高优先级任务能被运行的时候，会抢占低优先级的任务，通过悬挂中断——PendSV来进行任务切换，PendSV中断服务函数中进行上文保存，下文切换动作，，，将当前任务的信息入栈，msp指针指向要切换的任务sp指针，然后出栈，进行任务切换

任务怎么切换的啊   比如说从高优先级任务怎么切换到低优先级任务的，机制是什么  我看的一脸懵逼，能通俗的解释一下吗 ？

忆古思贤 发表于 2018-9-28 17:03
菜鸟进来学习

8 p5 _& C4 W) T$ f  Z/ N& m2 J加油

好文章，谢谢分享！学习了！

CFGCTYFV

学习了，谢谢

hi201803 发表于 2018-9-10 13:20
学习了，谢谢

8 \9 v" C! ^8 d, ^0 G客气了

谢谢分享！学习了！

学习.......................

向高手学习

看看大神的帖子

学习学习

yyyabc 发表于 2018-9-18 13:31
& [5 W- `$ R* d, H1 L' F7 X学习学习

学习学习~~~

菜鸟进来学习

谢谢分享，学习了