4.2.9 周期任务用的延迟--xTaskDelayUntil
接口：BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement )
形参1：pxPreviousWakeTime，上一次唤醒时间，第一次需要用接口xTaskGetTickCount()获取；
形参2：xTimeIncrement，想要延迟的时间。
返回值：用于判读任务是否确实需要delay。
1 BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
2 const TickType_t xTimeIncrement )
3 {
4 TickType_t xTimeToWake;
5 BaseType_t xAlreadyYielded, xShouldDelay = pdFALSE;
6
7 configASSERT( pxPreviousWakeTime );
8 configASSERT( ( xTimeIncrement > 0U ) );
9
10 vTaskSuspendAll();
11 {
12 /* Minor optimisation. The tick count cannot change in this
13 * block. */
14 const TickType_t xConstTickCount = xTickCount;
15
16 configASSERT( uxSchedulerSuspended == 1U );
17
18 /* Generate the tick time at which the task wants to wake. */
19 /* 计算任务下次唤醒的时间 */
20 xTimeToWake = *pxPreviousWakeTime + xTimeIncrement;
21
22 if( xConstTickCount < *pxPreviousWakeTime )
23 {
24 /* The tick count has overflowed since this function was
25 * lasted called. In this case the only time we should ever
26 * actually delay is if the wake time has also overflowed,
27 * and the wake time is greater than the tick time. When this
28 * is the case it is as if neither time had overflowed. */
29 /* tick值已经溢出了, 只有xTimeToWake也溢出并大于xConstTickCount
30 * 时, 才需要延迟 */
31 /* 假设tick是8位的, 当前值为0x5(从FF加到5), pxPreviousWakeTime为0xFD,
32 * 当xTimeIncrement为1时, xTimeToWake未溢出, 当xTimeIncrement为0x15时,
33 * xTimeToWake溢出。 显然当xTimeIncrement为1时, xTimeToWake比
34 * pxPreviousWakeTime和xConstTickCount都大, 但不需要延迟, 因为tick已过,
35 * 当xTimeIncrement为0x15时, xTimeToWake比pxPreviousWakeTime小但比xConstTickCount
36 * 大, tick要等到0x12才到延迟时间, 所以需要进行延迟. */
37 if( ( xTimeToWake < *pxPreviousWakeTime ) && ( xTimeToWake > xConstTickCount ) )
38 {
39 xShouldDelay = pdTRUE;
40 }
41 else
42 {
43 mtCOVERAGE_TEST_MARKER();
44 }
45 }
46 else
47 {
48 /* The tick time has not overflowed. In this case we will
49 * delay if either the wake time has overflowed, and/or the
50 * tick time is less than the wake time. */
51 /* tick没有溢出, 那么xTimeToWake溢出或比xConstTickCount小,
52 * 必然是需要延迟的. */
53 if( ( xTimeToWake < *pxPreviousWakeTime ) || ( xTimeToWake > xConstTickCount ) )
54 {
55 xShouldDelay = pdTRUE;
56 }
57 else
58 {
59 mtCOVERAGE_TEST_MARKER();
60 }
61 }
62
63 /* Update the wake time ready for the next call. */
64 *pxPreviousWakeTime = xTimeToWake;
65
66 if( xShouldDelay != pdFALSE )
67 {
68 /* prvAddCurrentTaskToDelayedList() needs the block time, not
69 * the time to wake, so subtract the current tick count. */
70 /* 延迟列表记录的是阻塞时间而不是唤醒时间, 所以需要减去tick. */
71 prvAddCurrentTaskToDelayedList( xTimeToWake - xConstTickCount, pdFALSE );
72 }
73 else
74 {
75 mtCOVERAGE_TEST_MARKER();
76 }
77 }
78 xAlreadyYielded = xTaskResumeAll();
79
80 /* Force a reschedule if xTaskResumeAll has not already done so, we may
81 * have put ourselves to sleep. */
82 if( xAlreadyYielded == pdFALSE )
83 {
84 taskYIELD_WITHIN_API();
85 }
86 else
87 {
88 mtCOVERAGE_TEST_MARKER();
89 }
90
91 return xShouldDelay;
92 }
xTaskDelayUntil
4.2.10 成对的信息获取接口，一般的和带有FromISR后缀的
这类接口比较简单，主要用于获取TCB中的某些参数，这里挑选任务优先级获取接口为例，重点在于带有FromISR的接口。一般的接口很简单，这里就直接放出来即可。
1 UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask )
2 {
3 TCB_t const * pxTCB;
4 UBaseType_t uxReturn;
5
6 taskENTER_CRITICAL();
7 {
8 /* If null is passed in here then it is the priority of the task
9 * that called uxTaskPriorityGet() that is being queried. */
10 pxTCB = prvGetTCBFromHandle( xTask );
11 uxReturn = pxTCB->uxPriority;
12 }
13 taskEXIT_CRITICAL();
14
15 return uxReturn;
16 }
1 UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask )
2 {
3 TCB_t const * pxTCB;
4 UBaseType_t uxReturn;
5 UBaseType_t uxSavedInterruptStatus;
6
7 /* RTOS ports that support interrupt nesting have the concept of a
8 * maximum system call (or maximum API call) interrupt priority.
9 * Interrupts that are above the maximum system call priority are keep
10 * permanently enabled, even when the RTOS kernel is in a critical section,
11 * but cannot make any calls to FreeRTOS API functions. If configASSERT()
12 * is defined in FreeRTOSConfig.h then
13 * portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
14 * failure if a FreeRTOS API function is called from an interrupt that has
15 * been assigned a priority above the configured maximum system call
16 * priority. Only FreeRTOS functions that end in FromISR can be called
17 * from interrupts that have been assigned a priority at or (logically)
18 * below the maximum system call interrupt priority. FreeRTOS maintains a
19 * separate interrupt safe API to ensure interrupt entry is as fast and as
20 * simple as possible. More information (albeit Cortex-M specific) is
21 * provided on the following link:
22 * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
23 /* 检查调用带有FromISR后缀的中断优先级是否高于
24 * configMAX_SYSCALL_INTERRUPT_PRIORITY, 是的话会进入assert */
25 portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
26
27 /* MISRA Ref 4.7.1 [Return value shall be checked] */
28 /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#dir-47 */
29 /* coverity[misra_c_2012_directive_4_7_violation] */
30 /* 获取当前中断屏蔽优先级, 并设置中断屏蔽优先级为configMAX_SYSCALL_INTERRUPT_PRIORITY
31 * 相当于进入了临界区并返回了当前中断屏蔽优先级 */
32 uxSavedInterruptStatus = ( UBaseType_t ) taskENTER_CRITICAL_FROM_ISR();
33 {
34 /* If null is passed in here then it is the priority of the calling
35 * task that is being queried. */
36 pxTCB = prvGetTCBFromHandle( xTask );
37 uxReturn = pxTCB->uxPriority;
38 }
39 /* 将保存的中断屏蔽优先级设置回去, 相当于退出临界区 */
40 taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus );
41
42 return uxReturn;
43 }
4.2.11 设置任务优先级--vTaskPrioritySet
接口虽然较长，但注释较多，且逻辑较为简单，直接看代码里的注释即可。
1 void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority )
2 {
3 TCB_t * pxTCB;
4 UBaseType_t uxCurrentBasePriority, uxPriorityUsedOnEntry;
5 BaseType_t xYieldRequired = pdFALSE;
6
7 configASSERT( uxNewPriority < configMAX_PRIORITIES );
8
9 /* Ensure the new priority is valid. */
10 if( uxNewPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
11 {
12 uxNewPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
13 }
14 else
15 {
16 mtCOVERAGE_TEST_MARKER();
17 }
18
19 taskENTER_CRITICAL();
20 {
21 /* If null is passed in here then it is the priority of the calling
22 * task that is being changed. */
23 pxTCB = prvGetTCBFromHandle( xTask );
24
25 #if ( configUSE_MUTEXES == 1 )
26 {
27 uxCurrentBasePriority = pxTCB->uxBasePriority;
28 }
29 #else
30 {
31 uxCurrentBasePriority = pxTCB->uxPriority;
32 }
33 #endif
34
35 if( uxCurrentBasePriority != uxNewPriority )
36 {
37 /* The priority change may have readied a task of higher
38 * priority than a running task. */
39 if( uxNewPriority > uxCurrentBasePriority )
40 {
41 /* 提升优先级 */
42 #if ( configNUMBER_OF_CORES == 1 )
43 {
44 if( pxTCB != pxCurrentTCB )
45 {
46 /* The priority of a task other than the currently
47 * running task is being raised. Is the priority being
48 * raised above that of the running task? */
49 /* 设置的优先级比当前运行的任务高, 需要yield */
50 if( uxNewPriority > pxCurrentTCB->uxPriority )
51 {
52 xYieldRequired = pdTRUE;
53 }
54 else
55 {
56 mtCOVERAGE_TEST_MARKER();
57 }
58 }
59 else
60 {
61 /* The priority of the running task is being raised,
62 * but the running task must already be the highest
63 * priority task able to run so no yield is required. */
64 }
65 }
66 #endif /* #if ( configNUMBER_OF_CORES == 1 ) */
67 }
68 else if( taskTASK_IS_RUNNING( pxTCB ) == pdTRUE )
69 {
70 /* Setting the priority of a running task down means
71 * there may now be another task of higher priority that
72 * is ready to execute. */
73 /* 降低当前运行任务的优先级, 则更高优先级的就绪任务需要抢占 */
74 #if ( configUSE_TASK_PREEMPTION_DISABLE == 1 )
75 if( pxTCB->xPreemptionDisable == pdFALSE )
76 #endif
77 {
78 xYieldRequired = pdTRUE;
79 }
80 }
81 else
82 {
83 /* Setting the priority of any other task down does not
84 * require a yield as the running task must be above the
85 * new priority of the task being modified. */
86 }
87
88 /* Remember the ready list the task might be referenced from
89 * before its uxPriority member is changed so the
90 * taskRESET_READY_PRIORITY() macro can function correctly. */
91 /* 获取任务当前的优先级, 有可能是继承来的优先级 */
92 uxPriorityUsedOnEntry = pxTCB->uxPriority;
93
94 #if ( configUSE_MUTEXES == 1 )
95 {
96 /* Only change the priority being used if the task is not
97 * currently using an inherited priority or the new priority
98 * is bigger than the inherited priority. */
99 /* 只有非继承来的优先级, 或提升优先级才可以直接修改pxTCB->uxPriority */
100 if( ( pxTCB->uxBasePriority == pxTCB->uxPriority ) || ( uxNewPriority > pxTCB->uxPriority ) )
101 {
102 pxTCB->uxPriority = uxNewPriority;
103 }
104 else
105 {
106 mtCOVERAGE_TEST_MARKER();
107 }
108
109 /* The base priority gets set whatever. */
110 pxTCB->uxBasePriority = uxNewPriority;
111 }
112 #else /* if ( configUSE_MUTEXES == 1 ) */
113 {
114 pxTCB->uxPriority = uxNewPriority;
115 }
116 #endif /* if ( configUSE_MUTEXES == 1 ) */
117
118 /* Only reset the event list item value if the value is not
119 * being used for anything else. */
120 /* xEventListItem的值未被使用, 才允许更新这个值 */
121 if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == ( ( TickType_t ) 0U ) )
122 {
123 listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxNewPriority ) );
124 }
125 else
126 {
127 mtCOVERAGE_TEST_MARKER();
128 }
129
130 /* If the task is in the blocked or suspended list we need do
131 * nothing more than change its priority variable. However, if
132 * the task is in a ready list it needs to be removed and placed
133 * in the list appropriate to its new priority. */
134 /* 如果任务处于就绪列表, 则需要将其放到修改后的优先级就绪列表 */
135 if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xStateListItem ) ) != pdFALSE )
136 {
137 /* The task is currently in its ready list - remove before
138 * adding it to its new ready list. As we are in a critical
139 * section we can do this even if the scheduler is suspended. */
140 if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
141 {
142 /* It is known that the task is in its ready list so
143 * there is no need to check again and the port level
144 * reset macro can be called directly. */
145 portRESET_READY_PRIORITY( uxPriorityUsedOnEntry, uxTopReadyPriority );
146 }
147 else
148 {
149 mtCOVERAGE_TEST_MARKER();
150 }
151
152 prvAddTaskToReadyList( pxTCB );
153 }
154 else
155 {
156 #if ( configNUMBER_OF_CORES == 1 )
157 {
158 mtCOVERAGE_TEST_MARKER();
159 }
160 #endif
161 }
162
163 if( xYieldRequired != pdFALSE )
164 {
165 /* The running task priority is set down. Request the task to yield. */
166 /* 开始yield, 但是在退出临界区后才会进入sv中断？ */
167 taskYIELD_TASK_CORE_IF_USING_PREEMPTION( pxTCB );
168 }
169 else
170 {
171 mtCOVERAGE_TEST_MARKER();
172 }
173
174 /* Remove compiler warning about unused variables when the port
175 * optimised task selection is not being used. */
176 ( void ) uxPriorityUsedOnEntry;
177 }
178 }
179 taskEXIT_CRITICAL();
180 }
vTaskPrioritySet
4.2.12 挂起任务--vTaskSuspend
还是直接看代码注释，解释得比较清楚了，接口功能可以顾名思义，逻辑也还好不复杂。
1 void vTaskSuspend( TaskHandle_t xTaskToSuspend )
2 {
3 TCB_t * pxTCB;
4
5 taskENTER_CRITICAL();
6 {
7 /* If null is passed in here then it is the running task that is
8 * being suspended. */
9 pxTCB = prvGetTCBFromHandle( xTaskToSuspend );
10
11 /* Remove task from the ready/delayed list and place in the
12 * suspended list. */
13 if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
14 {
15 taskRESET_READY_PRIORITY( pxTCB->uxPriority );
16 }
17 else
18 {
19 mtCOVERAGE_TEST_MARKER();
20 }
21
22 /* Is the task waiting on an event also? */
23 /* 任务挂起, 任务就不管是否在等待事件 */
24 if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
25 {
26 ( void ) uxListRemove( &( pxTCB->xEventListItem ) );
27 }
28 else
29 {
30 mtCOVERAGE_TEST_MARKER();
31 }
32
33 vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) );
34
35 /* 如果在等待通知, 也直接退出等待 */
36 #if ( configUSE_TASK_NOTIFICATIONS == 1 )
37 {
38 BaseType_t x;
39
40 for( x = ( BaseType_t ) 0; x < ( BaseType_t ) configTASK_NOTIFICATION_ARRAY_ENTRIES; x++ )
41 {
42 if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION )
43 {
44 /* The task was blocked to wait for a notification, but is
45 * now suspended, so no notification was received. */
46 pxTCB->ucNotifyState[ x ] = taskNOT_WAITING_NOTIFICATION;
47 }
48 }
49 }
50 #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
51 }
52 taskEXIT_CRITICAL();
53
54 #if ( configNUMBER_OF_CORES == 1 )
55 {
56 UBaseType_t uxCurrentListLength;
57
58 if( xSchedulerRunning != pdFALSE )
59 {
60 /* Reset the next expected unblock time in case it referred to the
61 * task that is now in the Suspended state. */
62 /* 如果下个解除阻塞的时间对应的任务正好是挂起的任务,
63 * 无论如何重置一下下个解除阻塞的时间 */
64 taskENTER_CRITICAL();
65 {
66 prvResetNextTaskUnblockTime();
67 }
68 taskEXIT_CRITICAL();
69 }
70 else
71 {
72 mtCOVERAGE_TEST_MARKER();
73 }
74
75 if( pxTCB == pxCurrentTCB )
76 {
77 if( xSchedulerRunning != pdFALSE )
78 {
79 /* The current task has just been suspended. */
80 /* 当前运行的任务挂起, 需要yield */
81 configASSERT( uxSchedulerSuspended == 0 );
82 portYIELD_WITHIN_API();
83 }
84 else
85 {
86 /* The scheduler is not running, but the task that was pointed
87 * to by pxCurrentTCB has just been suspended and pxCurrentTCB
88 * must be adjusted to point to a different task. */
89
90 /* Use a temp variable as a distinct sequence point for reading
91 * volatile variables prior to a comparison to ensure compliance
92 * with MISRA C 2012 Rule 13.2. */
93 uxCurrentListLength = listCURRENT_LIST_LENGTH( &xSuspendedTaskList );
94
95 if( uxCurrentListLength == uxCurrentNumberOfTasks )
96 {
97 /* No other tasks are ready, so set pxCurrentTCB back to
98 * NULL so when the next task is created pxCurrentTCB will
99 * be set to point to it no matter what its relative priority
100 * is. */
101 /* 所有创建的任务处于挂起状态, 只能等新任务创建了 */
102 pxCurrentTCB = NULL;
103 }
104 else
105 {
106 /* 切换下上下文, 因为挂起的是当前任务, 也有可能就绪列表为空,
107 * 会导致pxCurrentTCB = idle, 否则会选择就绪列表中优先级最高
108 * 任务, 这个接口在这里只是设置了pxCurrentTCB参数, 并pend了
109 * yield, 因为当前调度器处于暂停状态 */
110 vTaskSwitchContext();
111 }
112 }
113 }
114 else
115 {
116 mtCOVERAGE_TEST_MARKER();
117 }
118 }
119 #endif /* #if ( configNUMBER_OF_CORES == 1 ) */
120 }
vTaskSuspend
这篇就到这里了，内容也比较多，下篇开始vTaskResume和vTaskStartScheduler。
下篇再见！
标签：task,优先级,freeRTOS,mtCOVERAGE,--,else,priority,pxTCB,源码 From： https://www.cnblogs.com/freeManX1807/p/18403493