登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›FreeRTOS挂起和恢复任务相关函数解析

FreeRTOS挂起和恢复任务相关函数解析

呵烘稿 昨天 12:49
目录

  • 函数 vTaskSuspend()

    • 函数 vTaskSwitchContext()

  • 函数 vTaskResume()
  • 函数 xTaskResumeFromISR()

以下FreeRTOS源码函数使用的版本是9.0.0，不同版本的源码会有部分不同如10.4.6，注意甑别。
挂起和恢复任务相关 API 函数有以下几个：
1.png

函数 vTaskSuspend()

此函数用于挂起任务，若使用此函数，需要在 FreeRTOSConfig.h 文件中将宏INCLUDE_vTaskSuspend 配置为 1。无论优先级如何，被挂起的任务都将不再被执行，直到任务被恢复。此函数不支持嵌套，不论使用此函数重复挂起任务多少次，只需调用一次恢复任务的函数，那么任务就不再被挂起。传递空句柄将导致调用任务被挂起。
函数如下：
  1. void vTaskSuspend(TaskHandle_t xTaskToSuspend)
  2. {
  3.     TCB_t *pxTCB;
  5.     taskENTER_CRITICAL();
  6.     {
  7.         /* 获取要挂起的任务的任务控制块,传入 NULL 则挂起任务自身 */
  8.         pxTCB = prvGetTCBFromHandle(xTaskToSuspend);
  10.         traceTASK_SUSPEND(pxTCB);
  12.         /* 将任务从任务所在任务状态列表（就绪态任务列表或阻塞态任务列表）中移除 */
  13.         if (uxListRemove(&(pxTCB->xStateListItem)) == (UBaseType_t)0)
  14.         {
  15.             /* 成功移除掉了那就重新设置任务对应优先级的就绪位图，以确保其他任务能够正确地继续运行 */
  16.             taskRESET_READY_PRIORITY(pxTCB->uxPriority);
  17.         }
  18.         else
  19.         {
  20.             mtCOVERAGE_TEST_MARKER();
  21.         }
  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.         /* 将TCB的状态列表项插入挂起列表项末尾，实现挂起任务 */
  33.         vListInsertEnd(&xSuspendedTaskList, &(pxTCB->xStateListItem));
  34.     }
  35.     taskEXIT_CRITICAL();
  36.     /* 调度器在运行，则需要更新下一个任务的阻塞超时时间 */
  37.     if (xSchedulerRunning != pdFALSE)
  38.     {
  39.         /* Reset the next expected unblock time in case it referred to the
  40.         task that is now in the Suspended state. */
  41.         taskENTER_CRITICAL();
  42.         {
  43.             /* 更新下个任务解除阻塞时间 */
  44.             prvResetNextTaskUnblockTime();
  45.         }
  46.         taskEXIT_CRITICAL();
  47.     }
  48.     else
  49.     {
  50.         mtCOVERAGE_TEST_MARKER();
  51.     }
  53.     if (pxTCB == pxCurrentTCB)
  54.     {
  55.         /* 如果要挂起的是自己，且调度器在运行，那么表示当前任务自身被挂起，需要进行任务调度 */
  56.         if (xSchedulerRunning != pdFALSE)
  57.         {
  58.             /* The current task has just been suspended. */
  59.             /* 首先进行断言验证确保调度器没有被挂起 */
  60.             configASSERT(uxSchedulerSuspended == 0);
  61.             /* 调用 portYIELD_WITHIN_API 函数主动触发任务切换，使其他就绪任务有机会被调度执行 */
  62.             portYIELD_WITHIN_API();
  63.             /* 主要用于任务级别的 API 函数内部，用于特定情况下主动触发任务切换 */
  64.         }
  65.         /* 调度器没运行 */
  66.         else
  67.         {
  68.             /* 调度器没有运行，但是 pxCurrentTCB 所指向的任务刚刚挂起，
  69.             必须调整 pxCurrentTCB 以指向不同的任务
  70.             当任务被挂起后，如果没有其他就绪任务，即挂起列表中的任务数等于当前任务数 */
  71.             if (listCURRENT_LIST_LENGTH(&xSuspendedTaskList) == uxCurrentNumberOfTasks)
  72.             {
  73.                 /* 没有就绪的任务，将 pxCurrentTCB 设置为 NULL。这样，在下次创建任务时，
  74.                 无论其相对优先级如何，pxCurrentTCB 都会被设置为指向新任务*/
  75.                 pxCurrentTCB = NULL;
  76.             }
  77.             else
  78.             {
  79.                 /* 调用函数进行任务切换。这将导致上下文切换，并将执行权交给另一个就绪任务 */
  80.                 vTaskSwitchContext();
  81.             }
  82.         }
  83.     }
  84.     else
  85.     {
  86.         mtCOVERAGE_TEST_MARKER();
  87.     }
  88. }
复制代码
1.该函数先获取了待挂起的任务的任务控制块，以便进行列表项移除、添加操作。
2.将待挂起任务从所在的状态列表中移除，如果移除后列表项数量为0则需要更新任务优先级记录。
3.将任务插入至挂起任务列表当中。
4.更新下一个任务解除阻塞的时间，以防被挂起的任务就是下一个阻塞超时的任务。
5.如果要挂起的是自身，并且调度器在运行中，那就需要要求调度器进行任务调度。如果调度器没有在运行，就需要调整当前任务控制块的指向。更新 pxCurrentTCB 的操作，是通过调用函数 vTaskSwitchContext()实现的。
函数 vTaskSwitchContext()
  1. void vTaskSwitchContext( void )
  2. {
  3.         if( uxSchedulerSuspended != ( UBaseType_t ) pdFALSE )
  4.         {
  5.                 /* The scheduler is currently suspended - do not allow a context
  6.                 switch. */
  7.                 /* 调度程序当前挂起-不允许进行上下文切换，直接退出函数 */
  8.                 xYieldPending = pdTRUE;
  9.         }
  10.         else
  11.         {
  12.                 xYieldPending = pdFALSE;
  13.                 traceTASK_SWITCHED_OUT();
  15.                 #if ( configGENERATE_RUN_TIME_STATS == 1 )
  16.                 {
  17.                                 #ifdef portALT_GET_RUN_TIME_COUNTER_VALUE
  18.                                         portALT_GET_RUN_TIME_COUNTER_VALUE( ulTotalRunTime );
  19.                                 #else
  20.                                         ulTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();
  21.                                 #endif
  23.                                 /* Add the amount of time the task has been running to the
  24.                                 accumulated time so far.  The time the task started running was
  25.                                 stored in ulTaskSwitchedInTime.  Note that there is no overflow
  26.                                 protection here so count values are only valid until the timer
  27.                                 overflows.  The guard against negative values is to protect
  28.                                 against suspect run time stat counter implementations - which
  29.                                 are provided by the application, not the kernel. */
  30.                                 if( ulTotalRunTime > ulTaskSwitchedInTime )
  31.                                 {
  32.                                         pxCurrentTCB->ulRunTimeCounter += ( ulTotalRunTime - ulTaskSwitchedInTime );
  33.                                 }
  34.                                 else
  35.                                 {
  36.                                         mtCOVERAGE_TEST_MARKER();
  37.                                 }
  38.                                 ulTaskSwitchedInTime = ulTotalRunTime;
  39.                 }
  40.                 #endif /* configGENERATE_RUN_TIME_STATS */
  42.                 /* Check for stack overflow, if configured. */
  43.                 taskCHECK_FOR_STACK_OVERFLOW();
  45.                 /* Select a new task to run using either the generic C or port
  46.                 optimised asm code. */
  47.                 /* 此函数用于将 pxCurrentTCB 更新为指向优先级最高的就绪态任务 */
  48.                 taskSELECT_HIGHEST_PRIORITY_TASK();
  49.                 traceTASK_SWITCHED_IN();
  51.                 #if ( configUSE_NEWLIB_REENTRANT == 1 )
  52.                 {
  53.                         /* Switch Newlib's _impure_ptr variable to point to the _reent
  54.                         structure specific to this task. */
  55.                         _impure_ptr = &( pxCurrentTCB->xNewLib_reent );
  56.                 }
  57.                 #endif /* configUSE_NEWLIB_REENTRANT */
  58.         }
  59. }
复制代码
此函数的重点在于调用了函数 taskSELETE_HIGHEST_PRIORITY_TASK() 更新pxCurrentTCB 指向优先级最高的就绪态任务，函数 taskSELETE_HIGHEST_PRIORITY_TASK()实际上是一个宏定义，task.c 文件中有定义。
  1. #define taskSELECT_HIGHEST_PRIORITY_TASK()                                               \
  2.     {                                                                                    \
  3.         UBaseType_t uxTopPriority;                                                       \
  4.                                                                                          \
  5.         /* Find the highest priority list that contains ready tasks. */                  \
  6.         /* 查找就绪态任务列表中最高的任务优先级 */                     \
  7.         portGET_HIGHEST_PRIORITY(uxTopPriority, uxTopReadyPriority);                     \
  8.         /* 此任务优先级不能是最低的任务优先级 */                        \
  9.         configASSERT(listCURRENT_LIST_LENGTH(&(pxReadyTasksLists[uxTopPriority])) > 0);  \
  10.         /* 让 pxCurrentTCB 指向该任务优先级就绪态任务列表中的任务 */ \
  11.         listGET_OWNER_OF_NEXT_ENTRY(pxCurrentTCB, &(pxReadyTasksLists[uxTopPriority]));  \
  12.     } /* taskSELECT_HIGHEST_PRIORITY_TASK() */
复制代码
以上便是任务挂起函数的执行流程，如果挂起的是其他任务，就将其他任务添加至挂起列表当中，如果挂起的是自身，就需要触发一次任务调度进行任务切换。注意：任务挂起后只能由其他任务进行恢复，如果一直不恢复任务将无法得到执行，如果其他任务也进行了挂起，那将永远无法恢复。
函数 vTaskResume()

此函数用于在任务中恢复被挂起的任务，若使用此函数，需要在 FreeRTOSConfig.h 文件中将宏 INCLUDE_vTaskSuspend 配置为 1。不论一个任务被函数 vTaskSuspend()挂起多少次，只需要使用函数 vTakResume()恢复一次，就可以继续运行。
  1. void vTaskResume(TaskHandle_t xTaskToResume)
  2. {
  3.     TCB_t *const pxTCB = (TCB_t *)xTaskToResume;
  5.     /* It does not make sense to resume the calling task. */
  6.     configASSERT(xTaskToResume);
  8.     /* The parameter cannot be NULL as it is impossible to resume the
  9.     currently executing task. */
  10.     /* 恢复的任务不能是自己，恢复的是被挂起的任务 */
  11.     if ((pxTCB != NULL) && (pxTCB != pxCurrentTCB))
  12.     {
  13.         taskENTER_CRITICAL();
  14.         {
  15.             /* 判断恢复的任务是否被挂起，只有被挂起才会恢复，即返回的是pdTRUE */
  16.             if (prvTaskIsTaskSuspended(pxTCB) != pdFALSE)
  17.             {
  18.                 traceTASK_RESUME(pxTCB);
  20.                 /* As we are in a critical section we can access the ready
  21.                 lists even if the scheduler is suspended.
  22.                 由于我们处于临界区，即使调度器被挂起，我们也可以访问就绪列表 */
  23.                 /* 将任务从挂起状态列表中移除，并添加到就绪列表中 */
  24.                 (void)uxListRemove(&(pxTCB->xStateListItem));
  25.                 prvAddTaskToReadyList(pxTCB);
  27.                 /* We may have just resumed a higher priority task. */
  28.                 /* 任务优先级大于等于当前任务优先级就进行任务切换 */
  29.                 if (pxTCB->uxPriority >= pxCurrentTCB->uxPriority)
  30.                 {
  31.                     /* This yield may not cause the task just resumed to run,
  32.                     but will leave the lists in the correct state for the
  33.                     next yield. */
  34.                     taskYIELD_IF_USING_PREEMPTION();
  35.                 }
  36.                 else
  37.                 {
  38.                     mtCOVERAGE_TEST_MARKER();
  39.                 }
  40.             }
  41.             else
  42.             {
  43.                 mtCOVERAGE_TEST_MARKER();
  44.             }
  45.         }
  46.         taskEXIT_CRITICAL();
  47.     }
  48.     else
  49.     {
  50.         mtCOVERAGE_TEST_MARKER();
  51.     }
  52. }
复制代码
该函数很简单，首先判断恢复的任务是不是任务自身，任务自身都在运行着了，谈何恢复？随后判断待恢复的任务是不是正在被挂起的，被挂起的才会进行恢复。将待恢复任务从挂起列表当中移除，并添加至就绪列表等待调度器调度，如果恢复的任务优先级大于当前正在运行的任务的优先级则需要进行任务切换。
函数 xTaskResumeFromISR()

此函数用于在中断中恢复被挂起的任务，若使用此函数，需要在 FreeRTOSConfig.h 文件中将宏 INCLUDE_xTaskResumeFromISR 配置为 1。不论一个任务被函数 vTaskSuspend()挂起多少次，只需要使用函数 vTakResumeFromISR()恢复一次，就可以继续运行。
  1. BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume)
复制代码
使用该函数需要判断返回值，根据返回值进行任务切换。函数 xTaskResumeFromISR()的返回值，如下所示：
2.png

FreeRTOS官方：xTaskResumeFromISR()通常被视为危险函数，因为其操作未被锁定。因此，如果中断可能在任务被挂起之前到达，从而中断丢失，则绝对不应使用该函数来同步任务与中断。可使用信号量，或者最好是直达任务通知，来避免这种可能性。
这也就是说如果在中断中不对任务状态进行判断是否处于挂起态就调用从中断中恢复的函数，那么任务在还没挂起的时候就被恢复，这将导致恢复丢失，所以不应该用该函数来进行任务同步，推荐使用信号量、任务通知来进行。
  1. BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume)
  2. {
  3.     /* xYieldRequired返回的值指示是否需要进行上下文切换 */
  4.     BaseType_t xYieldRequired = pdFALSE;
  5.     TCB_t *const pxTCB = (TCB_t *)xTaskToResume;
  6.     /* 保存中断当前状态 */
  7.     UBaseType_t uxSavedInterruptStatus;
  9.     configASSERT(xTaskToResume);
  11.     /* RTOS ports that support interrupt nesting have the concept of a
  12.     maximum        system call (or maximum API call) interrupt priority.
  13.     Interrupts that are        above the maximum system call priority are keep
  14.     permanently enabled, even when the RTOS kernel is in a critical section,
  15.     but cannot make any calls to FreeRTOS API functions.  If configASSERT()
  16.     is defined in FreeRTOSConfig.h then
  17.     portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
  18.     failure if a FreeRTOS API function is called from an interrupt that has
  19.     been assigned a priority above the configured maximum system call
  20.     priority.  Only FreeRTOS functions that end in FromISR can be called
  21.     from interrupts        that have been assigned a priority at or (logically)
  22.     below the maximum system call interrupt priority.  FreeRTOS maintains a
  23.     separate interrupt safe API to ensure interrupt entry is as fast and as
  24.     simple as possible.  More information (albeit Cortex-M specific) is
  25.     provided on the following link:
  26.     http://www.freertos.org/RTOS-Cortex-M3-M4.html
  27.     由于FreeRTOS有中断屏蔽的概念，但高于某个值的中断优先级无法屏蔽。如果定义了configASSERT()，
  28.     那么如果一个API函数在一个不在FreeRTOS管理范围之内的中断服务例程中被调用，将导致断言失败。
  29.     只有以FromISR结尾的API函数可以从FreeRTOS可管理的中断中进行调用，不受它管理的调用也会有问题 */
  30.     /* 验证中断的优先级设置是否符合 FreeRTOS 的要求，是否在管理范围内 */
  31.     portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
  32.     /* 保存中断当前状态 */
  33.     uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
  34.     {
  35.         /* 判断任务是否被挂起 */
  36.         if (prvTaskIsTaskSuspended(pxTCB) != pdFALSE)
  37.         {
  38.             traceTASK_RESUME_FROM_ISR(pxTCB);
  40.             /* Check the ready lists can be accessed. */
  41.             /* 任务调度器没被挂起，在运行 */
  42.             if (uxSchedulerSuspended == (UBaseType_t)pdFALSE)
  43.             {
  44.                 /* Ready lists can be accessed so move the task from the
  45.                 suspended list to the ready list directly.
  46.                 任务调度器没被挂起，可以访问就绪列表，因此可以直接将任务从挂起列表移动到就绪列表 */
  47.                 if (pxTCB->uxPriority >= pxCurrentTCB->uxPriority)
  48.                 {
  49.                     xYieldRequired = pdTRUE;
  50.                 }
  51.                 else
  52.                 {
  53.                     mtCOVERAGE_TEST_MARKER();
  54.                 }
  56.                 (void)uxListRemove(&(pxTCB->xStateListItem));
  57.                 prvAddTaskToReadyList(pxTCB);
  58.             }
  59.             /* 调度器没运行 */
  60.             else
  61.             {
  62.                 /* The delayed or ready lists cannot be accessed so the task
  63.                 is held in the pending ready list until the scheduler is
  64.                 unsuspended.
  65.                 延迟列表或就绪列表无法访问，因此任务将保持在挂起的就绪列表中，直到调度器解除挂起
  66.                 */
  67.                 /* 因为调度器被挂起了，所以就将被恢复的任务插入到等待就绪列表当中
  68.                 直到调度器被恢复才执行任务的处理，添加到就绪列表当中 */
  69.                 vListInsertEnd(&(xPendingReadyList), &(pxTCB->xEventListItem));
  70.             }
  71.         }
  72.         else
  73.         {
  74.             mtCOVERAGE_TEST_MARKER();
  75.         }
  76.     }
  77.     /* 使用此宏函数可以在中断服务程序中恢复中断屏蔽，以允许其他具有较高优先级的中断被处理 */
  78.     portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
  80.     return xYieldRequired;
  81. }
复制代码
该函数的逻辑与普通恢复函数差不多，只不过是在中断中运行，判断任务是否被挂起，判断调度器是否被挂起，没被挂起则从挂起列表移除添加到就绪列表。调度器被挂起了则先将该任务添加到等待就绪列表当中，待到调度器恢复之后将这些任务添加到就绪列表中等待执行。
该函数还有官方的一大串描述，大概说的是FreeRTOS某些函数在调用的时候会屏蔽中断，以达到临界区的访问执行，但FreeRTOS屏蔽的中断范围是由一个阈值的，如果在一个中断屏蔽的阈值之外的中断服务例程中调用API函数这通常会触发断言，只有以FromISR结尾的API函数可以从FreeRTOS管理的中断中进行调用。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
呵烘稿
昨天 12:49

0

粉丝关注

11

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫