freeRTOS源码解析4--tasks.c 7-编程知识

freeRTOS源码解析4--tasks.c 7

news/2024/10/5 20:28:48/文章来源:https://www.cnblogs.com/freeManX1807/p/18442512

4.2.20 空闲任务调用1--prvCheckTasksWaitingTermination

删除所有终止的任务, 释放资源。简单描述就是清空xTasksWaitingTermination列表，释放资源，递减uxCurrentNumberOfTasks和uxDeletedTasksWaitingCleanUp。
接口：
static void prvCheckTasksWaitingTermination( void )
接口代码如下：

 1 static void prvCheckTasksWaitingTermination( void )
 2 {
 3     /** THIS FUNCTION IS CALLED FROM THE RTOS IDLE TASK **/
 4 
 5     #if ( INCLUDE_vTaskDelete == 1 )
 6     {
 7         TCB_t * pxTCB;
 8 
 9         /* uxDeletedTasksWaitingCleanUp is used to prevent taskENTER_CRITICAL()
10          * being called too often in the idle task. */
11         while( uxDeletedTasksWaitingCleanUp > ( UBaseType_t ) 0U )
12         {
13             #if ( configNUMBER_OF_CORES == 1 )
14             {
15                 taskENTER_CRITICAL();
16                 {
17                     {
18                         /* 从终止列表中取出任务 */
19                         pxTCB = listGET_OWNER_OF_HEAD_ENTRY( ( &xTasksWaitingTermination ) );
20                         /* 将任务从终止列表中移出 */
21                         ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
22                         --uxCurrentNumberOfTasks;
23                         --uxDeletedTasksWaitingCleanUp;
24                     }
25                 }
26                 taskEXIT_CRITICAL();
27 
28                 prvDeleteTCB( pxTCB );    // 释放任务资源
29             }
30             #endif /* #if( configNUMBER_OF_CORES == 1 ) */
31         }
32     }
33     #endif /* INCLUDE_vTaskDelete */
34 }

prvCheckTasksWaitingTermination

4.2.21 空闲任务调用2--prvGetExpectedIdleTime

这个用于低功耗，主要作用是获取期望睡眠的tick时间。
接口：
static TickType_t prvGetExpectedIdleTime( void )

返回：实际返回的是最近唤醒任务的剩余tick数，即最多能够睡眠这么多tick数后就要苏醒了，因为有任务延迟结束需要唤醒了。
接口代码如下：

 1 static TickType_t prvGetExpectedIdleTime( void )
 2 {
 3     TickType_t xReturn;
 4     UBaseType_t uxHigherPriorityReadyTasks = pdFALSE;
 5 
 6     /* uxHigherPriorityReadyTasks takes care of the case where
 7      * configUSE_PREEMPTION is 0, so there may be tasks above the idle priority
 8      * task that are in the Ready state, even though the idle task is
 9      * running. */
10     /* uxHigherPriorityReadyTasks用于configUSE_PREEMPTION为0的情况, 因为有可能
11      * 存在空闲任务在运行时, 也有高于空闲任务优先级的任务处于就绪态。如果是抢占
12      * 式的调度的话, 则不可能会有更高优先级的任务就绪, 否则根本轮不到空闲任务
13      * 运行。 */
14     #if ( configUSE_PORT_OPTIMISED_TASK_SELECTION == 0 )
15     {
16         if( uxTopReadyPriority > tskIDLE_PRIORITY )
17         {
18             uxHigherPriorityReadyTasks = pdTRUE;
19         }
20     }
21     #else
22     {
23         const UBaseType_t uxLeastSignificantBit = ( UBaseType_t ) 0x01;
24 
25         /* When port optimised task selection is used the uxTopReadyPriority
26          * variable is used as a bit map.  If bits other than the least
27          * significant bit are set then there are tasks that have a priority
28          * above the idle priority that are in the Ready state.  This takes
29          * care of the case where the co-operative scheduler is in use. */
30         if( uxTopReadyPriority > uxLeastSignificantBit )
31         {
32             uxHigherPriorityReadyTasks = pdTRUE;
33         }
34     }
35     #endif /* if ( configUSE_PORT_OPTIMISED_TASK_SELECTION == 0 ) */
36 
37     /* 这里一样, 抢占式的话当前任务就是空闲任务, 所以下面的判断除了最后的else,
38      * 其他都只有非抢占式的才有可能进, 抢占式的就直接看最后的else即可。 */
39     if( pxCurrentTCB->uxPriority > tskIDLE_PRIORITY )
40     {
41         xReturn = 0;
42     }
43     else if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ tskIDLE_PRIORITY ] ) ) > 1U )
44     {
45         /* There are other idle priority tasks in the ready state.  If
46          * time slicing is used then the very next tick interrupt must be
47          * processed. */
48         /* 和空闲任务同优先级的话, 应该也是先运行其他任务最后运行空闲任务 */
49         xReturn = 0;
50     }
51     else if( uxHigherPriorityReadyTasks != pdFALSE )
52     {
53         /* There are tasks in the Ready state that have a priority above the
54          * idle priority.  This path can only be reached if
55          * configUSE_PREEMPTION is 0. */
56         xReturn = 0;
57     }
58     else
59     {
60         /* 这里算出来的值是最近唤醒的任务的剩余tick数 */
61         xReturn = xNextTaskUnblockTime;
62         xReturn -= xTickCount;
63     }
64 
65     return xReturn;
66 }

prvGetExpectedIdleTime

4.2.22 空闲任务调用3--vPortSuppressTicksAndSleep

这个接口就是用于进入低功耗模式的，由于这个和具体的平台相关，所以定义在port.c中，这里只看cortex-m3和m4核的代码。

这个接口个人认为非常复杂，里面有一些计算流程本人也不是很明白，还需要以后反复开发和阅读才能理解。

接口：
__weak void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )

__weak：如果没有__weak修饰的相同接口定义了，则用新定义的接口，否则就使用该接口，类似与多态，需要编译器支持，非c标准。

参数1：xExpectedIdleTime，4.2.21的接口计算返回的tick数。

前置接口1：eSleepModeStatus eTaskConfirmSleepModeStatus( void )，用于确定是否真的需要进入低功耗模式。

返回：eSleepModeStatus，eAbortSleep：不进入，eStandardSleep：进入但休眠时间不高于xExpectedIdleTime，eNoTasksWaitingTimeout：进入但只能依靠外部中断唤醒。

 1 eSleepModeStatus eTaskConfirmSleepModeStatus( void )
 2 {
 3     #if ( INCLUDE_vTaskSuspend == 1 )
 4         /* The idle task exists in addition to the application tasks. */
 5         const UBaseType_t uxNonApplicationTasks = configNUMBER_OF_CORES;
 6     #endif /* INCLUDE_vTaskSuspend */
 7 
 8     eSleepModeStatus eReturn = eStandardSleep;
 9 
10     /* This function must be called from a critical section. */
11 
12     /* 此时调度器暂停, 有必要检查一下是否有任务就绪了, 或者调度延迟了,
13      * 或者有tick中断处理被延迟了 */
14     if( listCURRENT_LIST_LENGTH( &xPendingReadyList ) != 0U )
15     {
16         /* A task was made ready while the scheduler was suspended. */
17         eReturn = eAbortSleep;
18     }
19     else if( xYieldPendings[ portGET_CORE_ID() ] != pdFALSE )
20     {
21         /* A yield was pended while the scheduler was suspended. */
22         eReturn = eAbortSleep;
23     }
24     else if( xPendedTicks != 0U )
25     {
26         /* A tick interrupt has already occurred but was held pending
27          * because the scheduler is suspended. */
28         eReturn = eAbortSleep;
29     }
30 
31     #if ( INCLUDE_vTaskSuspend == 1 )
32         else if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == ( uxCurrentNumberOfTasks - uxNonApplicationTasks ) )
33         {
34             /* If all the tasks are in the suspended list (which might mean they
35              * have an infinite block time rather than actually being suspended)
36              * then it is safe to turn all clocks off and just wait for external
37              * interrupts. */
38             /* 如果所有的任务都在挂起列表中(即使是那些等待事件且无限延迟的任务有),
39              * 那么可以停止时钟并等待外部中断 */
40             eReturn = eNoTasksWaitingTimeout;
41         }
42     #endif /* INCLUDE_vTaskSuspend */
43     else
44     {
45         mtCOVERAGE_TEST_MARKER();
46     }
47 
48     return eReturn;
49 }

　　前置接口2：void vTaskStepTick( TickType_t xTicksToJump )

　　参数：xTicksToJump--休眠的tick数，用于更新xTickCount值。

 1 void vTaskStepTick( TickType_t xTicksToJump )
 2 {
 3     TickType_t xUpdatedTickCount;
 4 
 5     /* Correct the tick count value after a period during which the tick
 6      * was suppressed.  Note this does *not* call the tick hook function for
 7      * each stepped tick. */
 8     xUpdatedTickCount = xTickCount + xTicksToJump;
 9     configASSERT( xUpdatedTickCount <= xNextTaskUnblockTime );
10 
11     if( xUpdatedTickCount == xNextTaskUnblockTime )
12     {
13         /* Arrange for xTickCount to reach xNextTaskUnblockTime in
14          * xTaskIncrementTick() when the scheduler resumes.  This ensures
15          * that any delayed tasks are resumed at the correct time. */
16         /* 有任务到达唤醒时间了, 使xPendedTicks自增, 让xTaskIncrementTick()
17          * 接口去实现任务的唤醒 */
18         configASSERT( uxSchedulerSuspended != ( UBaseType_t ) 0U );
19         configASSERT( xTicksToJump != ( TickType_t ) 0 );
20 
21         /* Prevent the tick interrupt modifying xPendedTicks simultaneously. */
22         taskENTER_CRITICAL();
23         {
24             xPendedTicks++;
25         }
26         taskEXIT_CRITICAL();
27         xTicksToJump--;    // xPendedTicks已自增了, xTicksToJump就需要少算一个
28     }
29     else
30     {
31         mtCOVERAGE_TEST_MARKER();
32     }
33 
34     // 更新xTickCount值
35     xTickCount += xTicksToJump;
36 }

　　系统滴答时钟的几个寄存器需要展示一下：

接口代码如下：

  1 __weak void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )
  2 {
  3     uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements, ulSysTickDecrementsLeft;
  4     TickType_t xModifiableIdleTime;
  5 
  6     /* Make sure the SysTick reload value does not overflow the counter. */
  7     /* xMaximumPossibleSuppressedTicks是最多可以休眠的tick数, 在
  8      * vPortSetupTimerInterrupt中有初始化。 */
  9     if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks )
 10     {
 11         xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
 12     }
 13 
 14     /* Enter a critical section but don't use the taskENTER_CRITICAL()
 15      * method as that will mask interrupts that should exit sleep mode. */
 16     /* taskENTER_CRITICAL()接口修改的是basepri, 而__disable_irq()修改的是
 17      * primask, 不然某些中断被屏蔽后这些中断触发就无法退出休眠模式了. */
 18     __disable_irq();
 19     __dsb( portSY_FULL_READ_WRITE );
 20     __isb( portSY_FULL_READ_WRITE );
 21 
 22     /* If a context switch is pending or a task is waiting for the scheduler
 23      * to be unsuspended then abandon the low power entry. */
 24     /* 检查是否真的需要进入低功耗 */
 25     if( eTaskConfirmSleepModeStatus() == eAbortSleep )
 26     {
 27         /* Re-enable interrupts - see comments above the __disable_irq()
 28          * call above. */
 29         __enable_irq();
 30     }
 31     else
 32     {
 33         /* Stop the SysTick momentarily.  The time the SysTick is stopped for
 34          * is accounted for as best it can be, but using the tickless mode will
 35          * inevitably result in some tiny drift of the time maintained by the
 36          * kernel with respect to calendar time. */
 37         /* SysTick停止时间会计入总时长, 使用无滴答模式会导致内核时间与日历时间
 38          * 存在微小偏差. */
 39         /* portNVIC_SYSTICK_CTRL_REG: 0xE000E010, SYSTICK Control and Status Register.
 40          * portNVIC_SYSTICK_CLK_BIT_CONFIG: ( 1UL << 2UL ),
 41          * portNVIC_SYSTICK_INT_BIT: ( 1UL << 1UL ), *0xE000E010=0x06.
 42          * 即使用内部时钟, 使能该中断并禁止systick, 可以按自己需求修改, 但bit0不能置位 */
 43         portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT );
 44 
 45         /* Use the SysTick current-value register to determine the number of
 46          * SysTick decrements remaining until the next tick interrupt.  If the
 47          * current-value register is zero, then there are actually
 48          * ulTimerCountsForOneTick decrements remaining, not zero, because the
 49          * SysTick requests the interrupt when decrementing from 1 to 0. */
 50         /* portNVIC_SYSTICK_CURRENT_VALUE_REG: 0xE000E018, 跟定时器计数的寄存器差不多. */
 51         ulSysTickDecrementsLeft = portNVIC_SYSTICK_CURRENT_VALUE_REG;
 52 
 53         if( ulSysTickDecrementsLeft == 0 )
 54         {
 55             ulSysTickDecrementsLeft = ulTimerCountsForOneTick;
 56         }
 57 
 58         /* Calculate the reload value required to wait xExpectedIdleTime
 59          * tick periods.  -1 is used because this code normally executes part
 60          * way through the first tick period.  But if the SysTick IRQ is now
 61          * pending, then clear the IRQ, suppressing the first tick, and correct
 62          * the reload value to reflect that the second tick period is already
 63          * underway.  The expected idle time is always at least two ticks. */
 64         /* 计算重载的计数值, 这里分两种情况: 1、第一个tick中断未到, 计数已到一定值,
 65          * 2、第一个tick中断已触发, 但处于pend态, 第二个tick计数已到一定值,
 66          * 无论哪种情况都需要减去一个tick数, 再计算剩下的tick的计数值. */
 67         ulReloadValue = ulSysTickDecrementsLeft + ( ulTimerCountsForOneTick * ( xExpectedIdleTime - 1UL ) );
 68 
 69         /* 如果tick中断已pend了, 就清除中断,  再减去一个tick的计数值(即上面计算的值
 70          * 多算了一个tick计数值), 这样计算出来的休眠时间就比较准确. */
 71         if( ( portNVIC_INT_CTRL_REG & portNVIC_PEND_SYSTICK_SET_BIT ) != 0 )
 72         {
 73             portNVIC_INT_CTRL_REG = portNVIC_PEND_SYSTICK_CLEAR_BIT;
 74             ulReloadValue -= ulTimerCountsForOneTick;
 75         }
 76 
 77         /* 这是一个补偿值, 即停止tick中断后, 执行到这一条语句的大致tick计数值,
 78          * 这需要根据自己的工程去估算, 在vPortSetupTimerInterrupt中去修改. */
 79         if( ulReloadValue > ulStoppedTimerCompensation )
 80         {
 81             ulReloadValue -= ulStoppedTimerCompensation;
 82         }
 83 
 84         /* Set the new reload value. */
 85         /* portNVIC_SYSTICK_LOAD_REG: 0xE000E014, 重载寄存器, 从这个值减到0就触发tick中断 */
 86         portNVIC_SYSTICK_LOAD_REG = ulReloadValue;
 87 
 88         /* Clear the SysTick count flag and set the count value back to
 89          * zero. */
 90         /* 清除当前计数值, 一旦启动系统时钟, 这个寄存器的值就变成reload的值,
 91          * 再递减至0, 然后触发中断. */
 92         portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
 93 
 94         /* Restart SysTick. 使能系统定时器 */
 95         portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
 96 
 97         /* Sleep until something happens.  configPRE_SLEEP_PROCESSING() can
 98          * set its parameter to 0 to indicate that its implementation contains
 99          * its own wait for interrupt or wait for event instruction, and so wfi
100          * should not be executed again.  However, the original expected idle
101          * time variable must remain unmodified, so a copy is taken. */
102         /* configPRE_SLEEP_PROCESSING()可以自己实现休眠等待, 并将xModifiableIdleTime
103          * 设置成0, 则表示已经完成了休眠, 系统就不会执行wfi指令. */
104         xModifiableIdleTime = xExpectedIdleTime;
105         configPRE_SLEEP_PROCESSING( xModifiableIdleTime );
106 
107         if( xModifiableIdleTime > 0 )
108         {
109             __dsb( portSY_FULL_READ_WRITE );
110             __wfi();    // 等待中断指令, 即进入休眠模式
111             __isb( portSY_FULL_READ_WRITE );
112         }
113 
114         /* 到这里休眠就结束了, 和之前的configPRE_SLEEP_PROCESSING
115          * 是一对, 表示用户自己实现的休眠和结束 */
116         configPOST_SLEEP_PROCESSING( xExpectedIdleTime );
117 
118         /* Re-enable interrupts to allow the interrupt that brought the MCU
119          * out of sleep mode to execute immediately.  See comments above
120          * the __disable_irq() call above. */
121         /* 使能中断, 将会立即进入中断处理例程, 可能是外部中断也可能是tick中断. */
122         __enable_irq();
123         __dsb( portSY_FULL_READ_WRITE );
124         __isb( portSY_FULL_READ_WRITE );
125 
126         /* Disable interrupts again because the clock is about to be stopped
127          * and interrupts that execute while the clock is stopped will increase
128          * any slippage between the time maintained by the RTOS and calendar
129          * time. */
130         /* 后面要再次处理系统tick值, 如果期间出现中断的话, 会导致RTOS维护的时间
131          * 和日历时间出现偏差, 所以直接禁止中断可以防止这种偏差出现 */
132         __disable_irq();
133         __dsb( portSY_FULL_READ_WRITE );
134         __isb( portSY_FULL_READ_WRITE );
135 
136         /* Disable the SysTick clock without reading the
137          * portNVIC_SYSTICK_CTRL_REG register to ensure the
138          * portNVIC_SYSTICK_COUNT_FLAG_BIT is not cleared if it is set.  Again,
139          * the time the SysTick is stopped for is accounted for as best it can
140          * be, but using the tickless mode will inevitably result in some tiny
141          * drift of the time maintained by the kernel with respect to calendar
142          * time */
143         /* *0xE000E010=0x06, 与前面功效一样, 主要用于禁止systick.
144          * 虽然下面进一步校准了tick值, 但使用低功耗模式不可避免得会导致系统时钟
145          * 和日历时钟出现细微的偏差 */
146         portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT );
147 
148         /* Determine whether the SysTick has already counted to zero. */
149         /* 检查tick计数是否有减到0, bit16是读清的 */
150         if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
151         {
152             uint32_t ulCalculatedLoadValue;
153 
154             /* The tick interrupt ended the sleep (or is now pending), and
155              * a new tick period has started.  Reset portNVIC_SYSTICK_LOAD_REG
156              * with whatever remains of the new tick period. */
157             /* 需要恢复原先的tick计数, 所以需要减去目前已经计的数(休眠中触发
158              * tick中断后的时长), ulCalculatedLoadValue的值就是恢复后的计数值
159              * 需要继续计的剩下的值, 注意这里是已经减到0, 又重新开始倒计时了.
160              * 简单的假设, 原先一个tick需要500, 即499, 休眠总数是800, 这次休眠
161              * 了900, 那么当前计数寄存器的值就是700, 800-700=100, 那么当前一个
162              * tick需要计的剩下的数就是499-100=399, 这样就像是在休眠时tick仍在
163              * 计数一样, 虽然实际休眠时tick被禁止了 */
164             ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );
165 
166             /* Don't allow a tiny value, or values that have somehow
167              * underflowed because the post sleep hook did something
168              * that took too long or because the SysTick current-value register
169              * is zero. */
170             /* 处理下ulCalculatedLoadValue值可能溢出的问题, 因为ulReloadValue必然是大于
171              * 一个tick的计数值, 而如果唤醒的中断处理了太长时间, 或者用户的hook执行了太
172              * 长时间导致当前计数值正好为0或变得特别小, 那么计算的值就会溢出(减出负数).
173              * 如果小于ulStoppedTimerCompensation, 则正好减去了当前处理的时间(大约). */
174             if( ( ulCalculatedLoadValue <= ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )
175             {
176                 ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );
177             }
178 
179             /* 重载计数值 */
180             portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;
181 
182             /* As the pending tick will be processed as soon as this
183              * function exits, the tick value maintained by the tick is stepped
184              * forward by one less than the time spent waiting. */
185             /* 休眠前已经少算了一个tick, 如果是pend了, 在函数退出后会立即处理 */
186             ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
187         }
188         else
189         {
190             /* Something other than the tick interrupt ended the sleep. */
191 
192             /* Use the SysTick current-value register to determine the
193              * number of SysTick decrements remaining until the expected idle
194              * time would have ended. */
195             /* 不是tick中断唤醒的, 计算思路就相对简单一些 */
196             ulSysTickDecrementsLeft = portNVIC_SYSTICK_CURRENT_VALUE_REG;
197             #if ( portNVIC_SYSTICK_CLK_BIT_CONFIG != portNVIC_SYSTICK_CLK_BIT )
198             {
199                 /* If the SysTick is not using the core clock, the current-
200                  * value register might still be zero here.  In that case, the
201                  * SysTick didn't load from the reload register, and there are
202                  * ulReloadValue decrements remaining in the expected idle
203                  * time, not zero. */
204                 /* tick使用非内核时钟的特殊处理, 暂时不是很理解 */
205                 if( ulSysTickDecrementsLeft == 0 )
206                 {
207                     ulSysTickDecrementsLeft = ulReloadValue;
208                 }
209             }
210             #endif /* portNVIC_SYSTICK_CLK_BIT_CONFIG */
211 
212             /* Work out how long the sleep lasted rounded to complete tick
213              * periods (not the ulReload value which accounted for part
214              * ticks). */
215             /* 再次假设, 原先一个tick需要500, 休眠总数是900(2个tick), 这次休眠300
216              * 那么ulCompletedSysTickDecrements=(2*500)-(900-300)=400 */
217             ulCompletedSysTickDecrements = ( xExpectedIdleTime * ulTimerCountsForOneTick ) - ulSysTickDecrementsLeft;
218 
219             /* How many complete tick periods passed while the processor
220              * was waiting? */
221             /* ulCompleteTickPeriods = 400 / 500 = 0 */
222             ulCompleteTickPeriods = ulCompletedSysTickDecrements / ulTimerCountsForOneTick;
223 
224             /* The reload value is set to whatever fraction of a single tick
225              * period remains. */
226             /* 结果 = (0+1)*500-400=100. 简单计算下, 休眠总数是900, 说明睡眠前的当前值是400,
227              * 已经计数了100, 这次休眠300, 总计是400, 即还剩下100. 结果是相符的, 关键是这个
228              * 算法是怎么得来的, 我一时也不是很清楚, 但是结果是准确的 */
229             portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1UL ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;
230         }
231 
232         /* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG again,
233          * then set portNVIC_SYSTICK_LOAD_REG back to its standard value.  If
234          * the SysTick is not using the core clock, temporarily configure it to
235          * use the core clock.  This configuration forces the SysTick to load
236          * from portNVIC_SYSTICK_LOAD_REG immediately instead of at the next
237          * cycle of the other clock.  Then portNVIC_SYSTICK_LOAD_REG is ready
238          * to receive the standard value immediately. */
239         /* 这里当前计数寄存器的值已经更新了, 所以再设置reload值是安全的 */
240         portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
241         portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;
242         #if ( portNVIC_SYSTICK_CLK_BIT_CONFIG == portNVIC_SYSTICK_CLK_BIT )
243         {
244             portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
245         }
246         #else
247         {
248             /* The temporary usage of the core clock has served its purpose,
249              * as described above.  Resume usage of the other clock. */
250             portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT;
251 
252             if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
253             {
254                 /* The partial tick period already ended.  Be sure the SysTick
255                  * counts it only once. */
256                 portNVIC_SYSTICK_CURRENT_VALUE_REG = 0;
257             }
258 
259             portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
260             portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;
261         }
262         #endif /* portNVIC_SYSTICK_CLK_BIT_CONFIG */
263 
264         /* Step the tick to account for any tick periods that elapsed. */
265         vTaskStepTick( ulCompleteTickPeriods );
266 
267         /* Exit with interrupts enabled. */
268         __enable_irq();
269     }
270 }