这个就是我们第8节，提到的Index起到的作用

FreeRTOS 与隔壁的 RT-Thread 和 μC/OS 一样，都支持时间片的功能。 所谓时间片就是同一个优先级下可以有多个任务，每个任务轮流地享有相同的 CPU 时间， 享有 CPU 的时间我们叫时间片。在 RTOS 中，最小的时间单位为一个 tick，即 SysTick 的中断周期，RT-Thread 和 μC/OS 可以指定时间片的大小为多个 tick，但是 FreeRTOS 不一样，时间片只能是一个 tick。 与其说 FreeRTOS 支持时间片，倒不如说它的时间片就是正常的任务调度 。

9.1 时间片测试实验

假设目前系统中有三个任务就绪（算上空闲任务就是 4 个），任务 1 和任务 2 的优先级为 2，任务 3 的优先级为 3。
image.png
为了方便在逻辑分析仪中地分辨出任务 1 和任务 2 使用的时间片大小，任务 1 和任务2 的主体编写成一个无限循环函数，不会阻塞， 任务 3 的阻塞时间设置为 1 个 tick。任务 1和任务 2 的任务主体编写为一个无限循环， 这就意味着，优先级低于 2 的任务就会被饿死，得不到执行，比如空闲任务。在真正的项目中，并不会这样写，这里只是为了实验方便。

  1. /*
  2. *************************************************************************
  3. *                             包含的头文件
  4. *************************************************************************
  5. */
  6. #include "FreeRTOS.h"
  7. #include "task.h"
  9. /*
  10. *************************************************************************
  11. *                              全局变量
  12. *************************************************************************
  13. */
  14. portCHAR flag1;
  15. portCHAR flag2;
  16. portCHAR flag3;
  18. extern List_t pxReadyTasksLists[ configMAX_PRIORITIES ];
  20. /*
  21. *************************************************************************
  22. *                        任务控制块 & STACK 
  23. *************************************************************************
  24. */
  25. TaskHandle_t Task1_Handle;
  26. #define TASK1_STACK_SIZE                    128
  27. StackType_t Task1Stack[TASK1_STACK_SIZE];
  28. TCB_t Task1TCB;
  30. TaskHandle_t Task2_Handle;
  31. #define TASK2_STACK_SIZE                    128
  32. StackType_t Task2Stack[TASK2_STACK_SIZE];
  33. TCB_t Task2TCB;
  35. TaskHandle_t Task3_Handle;
  36. #define TASK3_STACK_SIZE                    128
  37. StackType_t Task3Stack[TASK3_STACK_SIZE];
  38. TCB_t Task3TCB;
  40. /*
  41. *************************************************************************
  42. *                               函数声明 
  43. *************************************************************************
  44. */
  45. void delay (uint32_t count);
  46. void Task1_Entry( void *p_arg );
  47. void Task2_Entry( void *p_arg );
  48. void Task3_Entry( void *p_arg );
  51. /*
  52. ************************************************************************
  53. *                                main函数
  54. ************************************************************************
  55. */
  56. int main(void)
  57. {    
  58.     /* 硬件初始化 */
  59.     /* 将硬件相关的初始化放在这里，如果是软件仿真则没有相关初始化代码 */
  61.     /* 创建任务 */
  62.     Task1_Handle = xTaskCreateStatic( (TaskFunction_t)Task1_Entry,   /* 任务入口 */
  63.                                       (char *)"Task1",               /* 任务名称，字符串形式 */
  64.                                       (uint32_t)TASK1_STACK_SIZE ,   /* 任务栈大小，单位为字 */
  65.                                       (void *) NULL,                 /* 任务形参 */
  66.                                       (UBaseType_t) 2,               /* 任务优先级，数值越大，优先级越高 */
  67.                                       (StackType_t *)Task1Stack,     /* 任务栈起始地址 */
  68.                                       (TCB_t *)&Task1TCB );          /* 任务控制块 */
  70.     Task2_Handle = xTaskCreateStatic( (TaskFunction_t)Task2_Entry,   /* 任务入口 */
  71.                                       (char *)"Task2",               /* 任务名称，字符串形式 */
  72.                                       (uint32_t)TASK2_STACK_SIZE ,   /* 任务栈大小，单位为字 */
  73.                                       (void *) NULL,                 /* 任务形参 */
  74.                                       (UBaseType_t) 2,               /* 任务优先级，数值越大，优先级越高 */                                          
  75.                                       (StackType_t *)Task2Stack,     /* 任务栈起始地址 */
  76.                                       (TCB_t *)&Task2TCB );          /* 任务控制块 */
  78.     Task3_Handle = xTaskCreateStatic( (TaskFunction_t)Task3_Entry,   /* 任务入口 */
  79.                                       (char *)"Task3",               /* 任务名称，字符串形式 */
  80.                                       (uint32_t)TASK3_STACK_SIZE ,   /* 任务栈大小，单位为字 */
  81.                                       (void *) NULL,                 /* 任务形参 */
  82.                                       (UBaseType_t) 3,               /* 任务优先级，数值越大，优先级越高 */                                          
  83.                                       (StackType_t *)Task3Stack,     /* 任务栈起始地址 */
  84.                                       (TCB_t *)&Task3TCB );          /* 任务控制块 */                                      
  86.     portDISABLE_INTERRUPTS();
  88.     /* 启动调度器，开始多任务调度，启动成功则不返回 */
  89.     vTaskStartScheduler();                                      
  91.     for(;;)
  92.     {
  93.         /* 系统启动成功不会到达这里 */
  94.     }
  95. }
  97. /*
  98. *************************************************************************
  99. *                               函数实现
  100. *************************************************************************
  101. */
  102. /* 软件延时 */
  103. void delay (uint32_t count)
  104. {
  105.     for(; count!=0; count--);
  106. }
  107. /* 任务1 */
  108. void Task1_Entry( void *p_arg )
  109. {
  110.     for( ;; )
  111.     {
  112.         flag1 = 1;
  113.         //vTaskDelay( 1 );
  114.         delay (100);        
  115.         flag1 = 0;
  116.         delay (100);
  117.         //vTaskDelay( 1 );        
  118.     }
  119. }
  121. /* 任务2 */
  122. void Task2_Entry( void *p_arg )
  123. {
  124.     for( ;; )
  125.     {
  126.         flag2 = 1;
  127.         //vTaskDelay( 1 );
  128.         delay (100);        
  129.         flag2 = 0;
  130.         delay (100);
  131.         //vTaskDelay( 1 );        
  132.     }
  133. }
  136. void Task3_Entry( void *p_arg )
  137. {
  138.     for( ;; )
  139.     {
  140.         flag3 = 1;
  141.         vTaskDelay( 1 );
  142.         //delay (100);        
  143.         flag3 = 0;
  144.         vTaskDelay( 1 );
  145.         //delay (100);
  146.     }
  147. }
  149. /* 获取空闲任务的内存 */
  150. StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
  151. TCB_t IdleTaskTCB;
  152. void vApplicationGetIdleTaskMemory( TCB_t **ppxIdleTaskTCBBuffer, 
  153.                                     StackType_t **ppxIdleTaskStackBuffer, 
  154.                                     uint32_t *pulIdleTaskStackSize )
  155. {
  156.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
  157.         *ppxIdleTaskStackBuffer=IdleTaskStack; 
  158.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
  159. }


9.2 实验现象

进入软件调试，全速运行程序，从逻辑分析仪中可以看到任务 1 和任务 2 轮流执行，每一次运行的时间等于任务 3 中 flag3 输出高电平或者低电平的时间，即一个 tick， 具体仿真的波形图见图。
image.png 在这一个 tick（时间片）里面，任务 1 和任务 2 的 flag 标志位做了很多次的翻转，点逻辑分析仪中 Zoom In 按钮将波形放大后就可以看到 flag 翻转的细节 image.png

9.3 原理分析

之 所 以 在 同 一 个 优 先 级 下 可 以 有 多 个 任 务 ， 最 终 还 是 得 益 于taskRESET_READY_PRIORITY()和 taskSELECT_HIGHEST_PRIORITY_TASK()这两个函函数的实现方法。接下来我们分析下这两个函数是如何在同一个优先级下有多个任务的时候起作用的。

系统在任务切换的时候总会从就绪列表中寻找优先级最高的任务来执行，寻找优先级最高的任务这个功能由 taskSELECT_HIGHEST_PRIORITY_TASK()函数来实现，该函数在task.c 中定义， 

  1. #define taskSELECT_HIGHEST_PRIORITY_TASK()                                                            \
  2.     {                                                                                                    \
  3.     UBaseType_t uxTopPriority;                                                                            \
  4.                                                                                                         \
  5.         /* 寻找包含就绪任务的最高优先级的队列 */                                                            \
  6.         portGET_HIGHEST_PRIORITY( uxTopPriority, uxTopReadyPriority );                                    \
  7.         /* 获取优先级最高的就绪任务的TCB，然后更新到pxCurrentTCB */                                       \
  8.         listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) );            \
  9.     } /* taskSELECT_HIGHEST_PRIORITY_TASK() */
  1. 寻 找就 绪 任 务 的 最 高 优 先 级 。 即 根 据 优 先 级 位 图 表uxTopReadyPriority 找到就绪任务的最高优先级，然后将优先级暂存在 uxTopPriority。
  2. 获取优先级最高的就绪任务的 TCB，然后更新到 pxCurrentTCB。目前我们的实验是在优先级 2 上有任务 1和任务 2，假设任务 1 运行了一个 tick，那接下来再从对应优先级 2 的就绪列表上选择任务来运行就应该是选择任务 2？怎么选择，代码上怎么实现？奥妙就在 listGET_OWNER_OF_NEXT_ENTRY()函数中，该函数在 list.h 中定义。
    1. /* 获取链表节点的OWNER，即TCB */
    2. #define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList )                                        \
    3. {                                                                                            \
    4.  List_t * const pxConstList = ( pxList );                                                \
    5.  /* 节点索引指向链表第一个节点调整节点索引指针，指向下一个节点，
    6.  如果当前链表有N个节点，当第N次调用该函数时，pxInedex则指向第N个节点 */\
    7.  ( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;                            \
    8.  /* 当前链表为空  应该是获取第一个不为空的ITEM */                                                                       \
    9.  if( ( void * ) ( pxConstList )->pxIndex == ( void * ) &( ( pxConstList )->xListEnd ) )    \
    10.  {                                                                                        \
    11.      ( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;                        \
    12.  }                                                                                        \
    13.  /* 获取节点的OWNER，即TCB */                                                             \
    14.  ( pxTCB ) = ( pxConstList )->pxIndex->pvOwner;                                             \
    15. }
    listGET_OWNER_OF_NEXT_ENTRY()函数的妙处在于它并不是获取链表下的第一个节点的 OWNER，而且用于获取下一个节点的 OWNER。有下一个那么就会有上一个的说法，怎么理解？假设当前链表有 N 个节点，当第 N 次调用该函数时， pxIndex 则指向第 N个节点， 即每调用一次， 节点遍历指针 pxIndex 则会向后移动一次，用于指向下一个节点。
    本实验中，优先级 2 下有两个任务，当系统第一次切换到优先级为 2 的任务（包含了任务 1 和任务 2，因为它们的优先级相同） 时， pxIndex 指向任务 1， 任务 1 得到执行。 当任务 1 执行完毕，系统重新切换到优先级为 2 的任务时， 这个时候 pxIndex 指向任务 2，任务 2 得到执行， 任务 1 和任务 2 轮流执行，享有相同的 CPU 时间， 即所谓的时间片。
    本实验中，任务 1 和任务 2 的主体都是无限循环，那如果任务 1 和任务 2 都会调用将自己挂起的函数（实际运用中，任务体都不能是无限循环的，必须调用能将自己挂起的函数） ，比如 vTaskDelay()。 调用能将任务挂起的函数中，都会先将任务从就绪列表删除，然 后 将 任 务 在 优 先 级 位 图 表 uxTopReadyPriority 中 对 应 的 位 清 零， 这 一 功 能 由taskRESET_READY_PRIORITY()函数来实现， 该函数在 task.c 中定义 
    1.  #define taskRESET_READY_PRIORITY( uxPriority )                                                        \
    2.  {                                                                                                    \
    3.      if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ ( uxPriority ) ] ) ) == ( UBaseType_t ) 0 )    \
    4.      {                                                                                                \
    5.          portRESET_READY_PRIORITY( ( uxPriority ), ( uxTopReadyPriority ) );                            \
    6.      }                                                                                                \
    7.  }
    taskRESET_READY_PRIORITY() 函 数 的 妙 处 在 于 清 除 优 先 级 位 图 表uxTopReadyPriority 中相应的位时候，会先判断当前优先级链表下是否还有其它任务，如果有则不清零。 假设当前实验中，任务 1 会调用 vTaskDelay()，会将自己挂起，只能是将任务 1 从就绪列表删除，不能将任务 1 在优先级位图表 uxTopReadyPriority 中对应的位清 0，因为该优先级下还有任务 2，否则任务 2 将得不到执行

9.4 修改代码，支持优先级

为了改的和官方的接近

9.4.1 xPortSysTickHandler()函数

当xTaskIncrementTick()函数返回为真时才进行任务切换， 原来的 xTaskIncrementTick()是不带返回值的， 执行到最后会调用 taskYIELD()执行任务切换 

  1. void xPortSysTickHandler( void )
  2. {
  3.     /* 关中断 */
  4.     vPortRaiseBASEPRI();
  6.     {
  7.         //xTaskIncrementTick();
  9.         /* 更新系统时基 */
  10.         if( xTaskIncrementTick() != pdFALSE )
  11.         {
  12.             /* 任务切换，即触发PendSV */
  13.             //portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
  14.             taskYIELD();
  15.         }
  16.     }
  18.     /* 开中断 */
  19.     vPortClearBASEPRIFromISR();
  20. }

1. 修改xTaskIncrementTick() 函数

  1. //void xTaskIncrementTick( void )
  2. BaseType_t xTaskIncrementTick( void )
  3. {
  4.     TCB_t * pxTCB;
  5.     TickType_t xItemValue;    
  6.     BaseType_t xSwitchRequired = pdFALSE;
  8.     const TickType_t xConstTickCount = xTickCount + 1;
  9.     xTickCount = xConstTickCount;
  11.     /* 如果xConstTickCount溢出，则切换延时列表 */
  12.     if( xConstTickCount == ( TickType_t ) 0U )
  13.     {
  14.         taskSWITCH_DELAYED_LISTS();
  15.     }
  17.     /* 最近的延时任务延时到期 */
  18.     if( xConstTickCount >= xNextTaskUnblockTime )
  19.     {
  20.         for( ;; )
  21.         {
  22.             if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )
  23.             {
  24.                 /* 延时列表为空，设置xNextTaskUnblockTime为可能的最大值 */
  25.                 xNextTaskUnblockTime = portMAX_DELAY;
  26.                 break;
  27.             }
  28.             else /* 延时列表不为空 */
  29.             {
  30.                 pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );
  31.                 xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xStateListItem ) );
  33.                 /* 直到将延时列表中所有延时到期的任务移除才跳出for循环 */
  34.                 if( xConstTickCount < xItemValue )
  35.                 {
  36.                     xNextTaskUnblockTime = xItemValue;
  37.                     break;
  38.                 }
  40.                 /* 将任务从延时列表移除，消除等待状态 */
  41.                 ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
  43.                 /* 将解除等待的任务添加到就绪列表 */
  44.                 prvAddTaskToReadyList( pxTCB );
  47.                 #if (  configUSE_PREEMPTION == 1 ) //2
  48.                 {
  49.                     if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
  50.                     {
  51.                         xSwitchRequired = pdTRUE;
  52.                     }
  53.                 }
  54.                 #endif /* configUSE_PREEMPTION */
  55.             }
  56.         }
  57.     }/* xConstTickCount >= xNextTaskUnblockTime */
  59.     #if ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) )//3    
  60.     {
  61.         if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ pxCurrentTCB->uxPriority ] ) ) 
  62.                                      > ( UBaseType_t ) 1 )
  63.         {
  64.             xSwitchRequired = pdTRUE;
  65.         }
  66.     }
  67.     #endif /* ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) ) */
  70.     /* 任务切换 */
  71.     //portYIELD();
  72. }
  1. 定 义 一 个 局 部 变 量 xSwitchRequired ， 用 于 存 储xTaskIncrementTick()函数的返回值，当返回值是 pdTRUE 时，需要执行一次任务切换，默认初始化为 pdFALSE。
  2. configUSE_PREEMPTION 是在 FreeRTOSConfig.h 的一个宏，默认为 1，、，即将 xSwitchRequired 的值置为 pdTRUE。 在 xTaskIncrementTick()函数还没有修改成带返回值的时候，我们是在执行完 xTaskIncrementTick()函数的时候，不管是否有任务就绪，不管就绪的任务的优先级是否比当前任务优先级高都执行一次任务切换。如果就绪任务的优先级比当前优先级高，那么执行一次任务切换与加了代码清单 12-6(3)这段代码实现的功能是一样的。如果没有任务就绪呢？就不需要执行任务切换，这样与之前的实现方法相比就省了一次任务切换的时间。虽然说没有更高优先级的任务就绪，执行任务切换的时候还是会运行原来的任务，但这是以多花一次任务切换的时间为代价的。
  3. 这部分与时间片功能相关。 当 configUSE_PREEMPTION 与configUSE_TIME_SLICING 都为真， 且当前优先级下不止一个任务时就执行一次任务切换，即将 xSwitchRequired 置为 pdTRUE 即可。 在 xTaskIncrementTick()函数还没有修改成带返回 值 之 前 ， 这 部 分 代 码 不 需 要 也 是 可 以 实 现 时 间 片 功 能 的， 即 只 要 在 执 行 完xTaskIncrementTick() 函 数 后 执 行 一 次 任 务 切 换 即 可 。 configUSE_PREEMPTION 在FreeRTOSConfig.h 中默认定义为 1， configUSE_TIME_SLICING 如果没有定义， 则会默认在 FreeRTOS.h 中定义为 1。其实 FreeRTOS 的这种时间片功能不能说是真正意义的时间片，因为它不能随意的设置时间为多少个 tick，而是默认一个 tick，然后默认在每个 tick 中断周期中进行任务切换而已。

第一部分完结