写点什么

FreeRTOS 记录(二、FreeRTOS 任务 API 认识和源码简析)

作者:矜辰所致
  • 2022 年 9 月 05 日
    江苏
  • 本文字数:12664 字

    阅读完需:约 42 分钟

FreeRTOS记录(二、FreeRTOS任务API认识和源码简析)
在了解了基本的环境和框架之后,对FreeRTOS 的任务,消息队列,信号量,事件,软件定时器这些基础的功能部分也得有个认识。 这篇文章主要介绍了一下关于任务的API以及源码的简单分析。 
复制代码


说明:FreeRTOS 专栏与我的 RT-Thread 专栏不同,我的 RT-Thread 专栏是从理论学习一步一步循序渐进,从 0 起步的 完整教学,而 FreeRTOS 更偏向于 我直接拿来使用,需要用到什么,然后引出知识点,在使用中发现问题,解然后再解决问题。


本 FreeRTOS 专栏记录的开发环境:

FreeRTOS 记录(一、熟悉开发环境以及 CubeMX 下 FreeRTOS 配置)

https://xie.infoq.cn/article/e82c7e10af242105b509bee2e

FreeRTOS 任务 API

来认识一下 FreeRTOS 的常用任务 API:



创建任务

任务创建分为动态xTaskCreate和静态xTaskCreateStatic ,但是在 CubeMX 中通过封装后统一使用的是osThreadCreate ,可以查看一下osThreadCreate 实现:


/*********************** Thread Management *****************************//*** @brief  Create a thread and add it to Active Threads and set it to state READY.* @param  thread_def    thread definition referenced with \ref osThread.* @param  argument      pointer that is passed to the thread function as start argument.* @retval thread ID for reference by other functions or NULL in case of error.* @note   MUST REMAIN UNCHANGED: \b osThreadCreate shall be consistent in every CMSIS-RTOS.*/osThreadId osThreadCreate (const osThreadDef_t *thread_def, void *argument){  TaskHandle_t handle;  #if( configSUPPORT_STATIC_ALLOCATION == 1 ) &&  ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )  if((thread_def->buffer != NULL) && (thread_def->controlblock != NULL)) {    handle = xTaskCreateStatic((TaskFunction_t)thread_def->pthread,(const portCHAR *)thread_def->name,              thread_def->stacksize, argument, makeFreeRtosPriority(thread_def->tpriority),              thread_def->buffer, thread_def->controlblock);  }  else {    if (xTaskCreate((TaskFunction_t)thread_def->pthread,(const portCHAR *)thread_def->name,              thread_def->stacksize, argument, makeFreeRtosPriority(thread_def->tpriority),              &handle) != pdPASS)  {      return NULL;    }   }#elif( configSUPPORT_STATIC_ALLOCATION == 1 )
handle = xTaskCreateStatic((TaskFunction_t)thread_def->pthread,(const portCHAR *)thread_def->name, thread_def->stacksize, argument, makeFreeRtosPriority(thread_def->tpriority), thread_def->buffer, thread_def->controlblock);#else if (xTaskCreate((TaskFunction_t)thread_def->pthread,(const portCHAR *)thread_def->name, thread_def->stacksize, argument, makeFreeRtosPriority(thread_def->tpriority), &handle) != pdPASS) { return NULL; } #endif return handle;}
复制代码


由上可以得知,CubeMX 生成的osThreadCreate 会根据我们在Config Parameters中的Memory Allocation内存分配中选择的配置结果自动的选择xTaskCreate还是xTaskCreateStatic


xTaskCreate



xTaskCreateStatic


删除任务

vTaskDelete封装后是osThreadTerminate ,如下:


osStatus osThreadTerminate (osThreadId thread_id){#if (INCLUDE_vTaskDelete == 1)  vTaskDelete(thread_id);  return osOK;#else  return osErrorOS;#endif}
复制代码


参数为 NULL vTaskDelete(NULL)是删除任务自己。

挂起任务

void vTaskSuspend( TaskHandle_t xTaskToSuspend )传入的参数是 任务句柄。


vTaskSuspend封装后是osThreadSuspend ,如下:


//osStatus osThreadSuspend (osThreadId thread_id){#if (INCLUDE_vTaskSuspend == 1)    vTaskSuspend(thread_id);    return osOK;#else  return osErrorResource;#endif}
复制代码


参数为 NULL vTaskSuspend(NULL)是挂起任务自己


osThreadSuspendAll 挂起所有任务


osStatus osThreadSuspendAll (void){  vTaskSuspendAll();    return osOK;}
复制代码

恢复任务

vTaskResume在任务中恢复任务(将任务从挂起状态恢复到就绪态)xTaskResumeFromISR在中断中恢复任务封装后是osThreadResume,如下:


osStatus osThreadResume (osThreadId thread_id){#if (INCLUDE_vTaskSuspend == 1)    if(inHandlerMode())  {    if (xTaskResumeFromISR(thread_id) == pdTRUE)    {      portYIELD_FROM_ISR(pdTRUE);    }  }  else  {    vTaskResume(thread_id);  }  return osOK;#else  return osErrorResource;#endif}
复制代码


osThreadResumeAll 恢复所有任务


osStatus osThreadResumeAll (void){  if (xTaskResumeAll() == pdTRUE)    return osOK;  else    return osErrorOS;  }
复制代码

任务优先级

uxTaskPriorityGet获取任务优先级 封装后是osThreadGetPriority,还有一个从中断中获取没有写出来,但是通过封装后的函数可以看出来:


osPriority osThreadGetPriority (osThreadId thread_id){#if (INCLUDE_uxTaskPriorityGet == 1)  if (inHandlerMode())  {    return makeCmsisPriority(uxTaskPriorityGetFromISR(thread_id));    }  else  {      return makeCmsisPriority(uxTaskPriorityGet(thread_id));  }#else  return osPriorityError;#endif}
复制代码


vTaskPrioritySet设置任务优先级 封装后是osThreadSetPriority,如下:


osStatus osThreadSetPriority (osThreadId thread_id, osPriority priority){#if (INCLUDE_vTaskPrioritySet == 1)  vTaskPrioritySet(thread_id, makeFreeRtosPriority(priority));  return osOK;#else  return osErrorOS;#endif}
复制代码

延时任务

vTaskDelay相对延时封装后osDelay,如下:


/*********************** Generic Wait Functions *******************************//*** @brief   Wait for Timeout (Time Delay)* @param   millisec      time delay value* @retval  status code that indicates the execution status of the function.*/osStatus osDelay (uint32_t millisec){#if INCLUDE_vTaskDelay  TickType_t ticks = millisec / portTICK_PERIOD_MS;    vTaskDelay(ticks ? ticks : 1);          /* Minimum delay = 1 tick */    return osOK;#else  (void) millisec;    return osErrorResource;#endif}
复制代码


vTaskDelayuntil绝对延时封装后osDelayUntil,如下:


/*** @brief  Delay a task until a specified time* @param   PreviousWakeTime   Pointer to a variable that holds the time at which the *          task was last unblocked. PreviousWakeTime must be initialised with the current time*          prior to its first use (PreviousWakeTime = osKernelSysTick() )* @param   millisec    time delay value* @retval  status code that indicates the execution status of the function.*/osStatus osDelayUntil (uint32_t *PreviousWakeTime, uint32_t millisec){#if INCLUDE_vTaskDelayUntil  TickType_t ticks = (millisec / portTICK_PERIOD_MS);  vTaskDelayUntil((TickType_t *) PreviousWakeTime, ticks ? ticks : 1);    return osOK;#else  (void) millisec;  (void) PreviousWakeTime;    return osErrorResource;#endif}
复制代码

FreeRTOS 任务源码简析

任务状态

在分析任务源码之前,先得了解一下 FreeRTOS 中任务的四种基本状态:运行态,挂起态,阻塞态,就绪态。


在官方文档中:


任务控制块

FreeRTOS 的每个任务都有一些属性需要存储,把这些属性集合在一起的结构体叫做任务控制块 TCB_t (Task control block),源码如下:


/* * Task control block.  A task control block (TCB) is allocated for each task, * and stores task state information, including a pointer to the task's context * (the task's run time environment, including register values) */typedef struct tskTaskControlBlock{  volatile StackType_t  *pxTopOfStack;  /*< Points to the location of the last item placed on the tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE TCB STRUCT. */
#if ( portUSING_MPU_WRAPPERS == 1 ) xMPU_SETTINGS xMPUSettings; /*< The MPU settings are defined as part of the port layer. THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */ #endif
ListItem_t xStateListItem; /*< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */ ListItem_t xEventListItem; /*< Used to reference a task from an event list. */ UBaseType_t uxPriority; /*< The priority of the task. 0 is the lowest priority. */ StackType_t *pxStack; /*< Points to the start of the stack. */ char pcTaskName[ configMAX_TASK_NAME_LEN ];/*< Descriptive name given to the task when created. Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
#if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) ) StackType_t *pxEndOfStack; /*< Points to the highest valid address for the stack. */ #endif
#if ( portCRITICAL_NESTING_IN_TCB == 1 ) UBaseType_t uxCriticalNesting; /*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */ #endif
#if ( configUSE_TRACE_FACILITY == 1 ) UBaseType_t uxTCBNumber; /*< Stores a number that increments each time a TCB is created. It allows debuggers to determine when a task has been deleted and then recreated. */ UBaseType_t uxTaskNumber; /*< Stores a number specifically for use by third party trace code. */ #endif
#if ( configUSE_MUTEXES == 1 ) UBaseType_t uxBasePriority; /*< The priority last assigned to the task - used by the priority inheritance mechanism. */ UBaseType_t uxMutexesHeld; #endif
#if ( configUSE_APPLICATION_TASK_TAG == 1 ) TaskHookFunction_t pxTaskTag; #endif
#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 ) void *pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ]; #endif
#if( configGENERATE_RUN_TIME_STATS == 1 ) uint32_t ulRunTimeCounter; /*< Stores the amount of time the task has spent in the Running state. */ #endif
#if ( configUSE_NEWLIB_REENTRANT == 1 ) /* Allocate a Newlib reent structure that is specific to this task. Note Newlib support has been included by popular demand, but is not used by the FreeRTOS maintainers themselves. FreeRTOS is not responsible for resulting newlib operation. User must be familiar with newlib and must provide system-wide implementations of the necessary stubs. Be warned that (at the time of writing) the current newlib design implements a system-wide malloc() that must be provided with locks. */ struct _reent xNewLib_reent; #endif
#if( configUSE_TASK_NOTIFICATIONS == 1 ) volatile uint32_t ulNotifiedValue; volatile uint8_t ucNotifyState; #endif
/* See the comments above the definition of tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */ #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 Macro has been consolidated for readability reasons. */ uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */ #endif
#if( INCLUDE_xTaskAbortDelay == 1 ) uint8_t ucDelayAborted; #endif
} tskTCB;
/* The old tskTCB name is maintained above then typedefed to the new TCB_t namebelow to enable the use of older kernel aware debuggers. */typedef tskTCB TCB_t;
复制代码



状态列表项 :每个任务都有 4 种状态,FreeRTOS 使用一种高效的数据结构双向链表保存任务的状态,Linux 中也是。


事件列表项 :信号量,消息队列,软件定时器等事件的管理

任务创建流程分析

任务创建流程如下图所示:



在分析 FreeRTOS 任务创建源码之前,我们得先了解一下栈的不同类型。

栈的四种类型

不同的硬件平台 stack 的增长方式不同,总的来说是有 4 种增长方式:


满减栈、满增栈、空减栈、空增栈。


满减栈:栈指针指向最后压入栈的数据,数据入栈时,sp 先减一再入栈。


满增栈:栈指针指向最后压入栈的数据,数据入栈时,sp 先加一再入栈。


空减栈:栈指针指向下一个将要放入数据的位置,数据入栈时,先入栈 sp 再减一。


空增栈:栈指针指向下一个将要放入数据的位置,数据入栈时,先入栈 sp 再加一。


满栈进栈是先移动指针再存;满栈出栈是先出数据再移动指针;


空栈进栈先存再移动指针;空栈出栈先移动指针再取数据。


ARM M3,M4 内核使用的是 满减栈。

任务创建源码分析

我们在源码中直接使用注释分析:


#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
BaseType_t xTaskCreate( TaskFunction_t pxTaskCode, const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ const configSTACK_DEPTH_TYPE usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask ) { TCB_t *pxNewTCB; BaseType_t xReturn;
/* If the stack grows down then allocate the stack then the TCB so the stack does not grow into the TCB. Likewise if the stack grows up then allocate the TCB then the stack. 根据自己的硬件平台堆栈增长方式来判断使用那一部分编译, 堆栈增长方式: 1、满减栈 2、满增栈 3、空减栈 4、空增栈 #define portSTACK_GROWTH ( -1 ) 表示满减栈 */ #if( portSTACK_GROWTH > 0 ) { /* Allocate space for the TCB. Where the memory comes from depends on the implementation of the port malloc function and whether or not static allocation is being used. 任务栈内存分配 */ pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );
if( pxNewTCB != NULL ) { /* Allocate space for the stack used by the task being created. The base of the stack memory stored in the TCB so the task can be deleted later if required. 任务控制块内存分配 */ pxNewTCB->pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
if( pxNewTCB->pxStack == NULL ) { /* Could not allocate the stack. Delete the allocated TCB. */ vPortFree( pxNewTCB ); pxNewTCB = NULL; } } } #else /* portSTACK_GROWTH */ /* M3,M4中使用的下面这种 #define portSTACK_TYPE uint32_t typedef portSTACK_TYPE StackType_t; 每个内存是4个字节(StackType_t),所以创建堆栈是按照字来分配的 默认的是128 x 4 = 512字节; */ { StackType_t *pxStack;
/* Allocate space for the stack used by the task being created. */ pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
if( pxStack != NULL ) { /* Allocate space for the TCB. 根据TCB的大小还得分配空间 */ pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /*lint !e961 MISRA exception as the casts are only redundant for some paths. */
if( pxNewTCB != NULL ) { /* Store the stack location in the TCB. 赋值栈地址 */ pxNewTCB->pxStack = pxStack; } else { /* The stack cannot be used as the TCB was not created. Free it again. 释放栈空间 */ vPortFree( pxStack ); } } else { pxNewTCB = NULL; } } #endif /* portSTACK_GROWTH */
if( pxNewTCB != NULL ) { #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 Macro has been consolidated for readability reasons. */ { /* Tasks can be created statically or dynamically, so note this task was created dynamically in case it is later deleted. */ pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB; } #endif /* configSUPPORT_STATIC_ALLOCATION */ /* 新建任务初始化 初始化任务控制块 初始化任务堆栈 */ prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL ); /* 把任务添加到就绪列表中 */ prvAddNewTaskToReadyList( pxNewTCB ); xReturn = pdPASS; } else { xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY; }
return xReturn; }
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
复制代码

任务删除流程分析

临界段

一种保护机制,代码的临界段也称为临界区,指处理时不可分割的代码区域,一旦这部分代码开始执行,则不允许任何中断打断。为确保临界段代码的执行不被中断,在进入临界段之前须关中断,而临界段代码执行完毕后,要立即打开中断。


在 OS 中,除了外部中断能将正在运行的代码打断,还有线程的调度——PendSV,系统产生 PendSV 中断,在 PendSV Handler 里面实现线程的切换。我们要将这项东西屏蔽掉,保证当前只有一个线程在使用临界资源。


FreeRTOS 对中断的开和关是通过操作 BASEPRI 寄存器来实现的,即大于等于 BASEPRI 的值的中断会被屏蔽,小于 BASEPRI 的值的中断则不会被屏蔽。这样子的好处就是用户可以设置 BASEPRI 的值来选择性的给一些非常紧急的中断留一条后路。


FreeRTOS 进入临界段 屏蔽中断:


/*-----------------------------------------------------------*/
portFORCE_INLINE static void vPortRaiseBASEPRI( void ){uint32_t ulNewBASEPRI;
__asm volatile ( " mov %0, %1 \n" \ " msr basepri, %0 \n" \ " isb \n" \ " dsb \n" \ :"=r" (ulNewBASEPRI) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory" );}
复制代码


FreeRTOS 退出临界段 打开中断:


*-----------------------------------------------------------*/
portFORCE_INLINE static void vPortSetBASEPRI( uint32_t ulNewMaskValue ){ __asm volatile ( " msr basepri, %0 " :: "r" ( ulNewMaskValue ) : "memory" );}
复制代码

任务删除源码分析

我们在源码中直接使用注释分析:


#if ( INCLUDE_vTaskDelete == 1 )
void vTaskDelete( TaskHandle_t xTaskToDelete ) { TCB_t *pxTCB; /* 进入临界段 */ taskENTER_CRITICAL(); { /* If null is passed in here then it is the calling task that is being deleted. 获取任务控制块 -----参数传入的是任务句柄 判断是任务本身,还是其他任务 */ pxTCB = prvGetTCBFromHandle( xTaskToDelete );
/* Remove task from the ready list. 从就绪列表中移除 */ if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) { taskRESET_READY_PRIORITY( pxTCB->uxPriority ); } else { mtCOVERAGE_TEST_MARKER(); }
/* Is the task waiting on an event also? 从事件列表中移除 */ if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL ) { ( void ) uxListRemove( &( pxTCB->xEventListItem ) ); } else { mtCOVERAGE_TEST_MARKER(); }
/* Increment the uxTaskNumber also so kernel aware debuggers can detect that the task lists need re-generating. This is done before portPRE_TASK_DELETE_HOOK() as in the Windows port that macro will not return. */ uxTaskNumber++; /* 如果是删除当前任务 */ if( pxTCB == pxCurrentTCB ) { /* A task is deleting itself. This cannot complete within the task itself, as a context switch to another task is required. Place the task in the termination list. The idle task will check the termination list and free up any memory allocated by the scheduler for the TCB and stack of the deleted task. 删除任务本身不能立即删除,在空闲任务中删除 就把任务添加到等待删除的任务列表中 */ vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xStateListItem ) );
/* Increment the ucTasksDeleted variable so the idle task knows there is a task that has been deleted and that it should therefore check the xTasksWaitingTermination list. 给空间任务一个标记 */ ++uxDeletedTasksWaitingCleanUp;
/* The pre-delete hook is primarily for the Windows simulator, in which Windows specific clean up operations are performed, after which it is not possible to yield away from this task - hence xYieldPending is used to latch that a context switch is required. 钩子函数----用户自己实现 */ portPRE_TASK_DELETE_HOOK( pxTCB, &xYieldPending ); } else { --uxCurrentNumberOfTasks; prvDeleteTCB( pxTCB );
/* Reset the next expected unblock time in case it referred to the task that has just been deleted. 复位任务锁定时间 ----时间片 操作系统会记录一个最新的时间, 根据最新的时间,进行调度,所以删除任务后,要更新锁定时间 */ prvResetNextTaskUnblockTime(); } traceTASK_DELETE( pxTCB ); } /*退出临界段*/ taskEXIT_CRITICAL();
/* Force a reschedule if it is the currently running task that has just been deleted. 判断调度器是否开启 */ if( xSchedulerRunning != pdFALSE ) { /* 如果是删除任务本身,马上进行任务调度(释放CPU的使用权) */ if( pxTCB == pxCurrentTCB ) { configASSERT( uxSchedulerSuspended == 0 ); portYIELD_WITHIN_API(); } else { mtCOVERAGE_TEST_MARKER(); } } }
#endif /* INCLUDE_vTaskDelete */
复制代码

任务挂起


我们在源码中直接使用注释分析:


#if ( INCLUDE_vTaskSuspend == 1 )
void vTaskSuspend( TaskHandle_t xTaskToSuspend ) { TCB_t *pxTCB; /* 进入临界段 */ taskENTER_CRITICAL(); { /* If null is passed in here then it is the running task that is being suspended. 获取任务控制块 */ pxTCB = prvGetTCBFromHandle( xTaskToSuspend );
traceTASK_SUSPEND( pxTCB );
/* Remove task from the ready/delayed list and place in the suspended list. 从就绪列表中删除 */ if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 ) { taskRESET_READY_PRIORITY( pxTCB->uxPriority ); } else { mtCOVERAGE_TEST_MARKER(); }
/* Is the task waiting on an event also? 从事件列表中移除 */ if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL ) { ( void ) uxListRemove( &( pxTCB->xEventListItem ) ); } else { mtCOVERAGE_TEST_MARKER(); } /* 把任务添加到挂起列表中 */ vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) );
#if( configUSE_TASK_NOTIFICATIONS == 1 ) { if( pxTCB->ucNotifyState == taskWAITING_NOTIFICATION ) { /* The task was blocked to wait for a notification, but is now suspended, so no notification was received. */ pxTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION; } } #endif } /* 退出临界段 */ taskEXIT_CRITICAL(); /* 判断调度器是否开始 看看是否有更高优先级的任务 */ if( xSchedulerRunning != pdFALSE ) { /* Reset the next expected unblock time in case it referred to the task that is now in the Suspended state. */ taskENTER_CRITICAL(); { prvResetNextTaskUnblockTime(); } taskEXIT_CRITICAL(); } else { mtCOVERAGE_TEST_MARKER(); }
if( pxTCB == pxCurrentTCB ) { if( xSchedulerRunning != pdFALSE ) { /* The current task has just been suspended. 直接进行任务调度,释放CPU */ configASSERT( uxSchedulerSuspended == 0 ); portYIELD_WITHIN_API(); } else { /* The scheduler is not running, but the task that was pointed to by pxCurrentTCB has just been suspended and pxCurrentTCB must be adjusted to point to a different task. 调度器没有开启,pxCurrentTCB必须指向另外一个不同的task 因为这个任务被挂起了 */ if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks ) { /* No other tasks are ready, so set pxCurrentTCB back to NULL so when the next task is created pxCurrentTCB will be set to point to it no matter what its relative priority is. 没有任务准备,把当前的任务控制块复制为NULL */ pxCurrentTCB = NULL; } else { /*手动进行调度,在就绪列表中找到优先级最高的任务*/ vTaskSwitchContext(); } } } else { mtCOVERAGE_TEST_MARKER(); } }
#endif /* INCLUDE_vTaskSuspend */
复制代码

任务恢复


我们在源码中直接使用注释分析:


#if ( INCLUDE_vTaskSuspend == 1 )
void vTaskResume( TaskHandle_t xTaskToResume ) { /*获取要恢复的任务控制块*/ TCB_t * const pxTCB = ( TCB_t * ) xTaskToResume;
/* It does not make sense to resume the calling task. 检查*/ configASSERT( xTaskToResume );
/* The parameter cannot be NULL as it is impossible to resume the currently executing task. 恢复的话不能是NULL或当前的任务 */ if( ( pxTCB != NULL ) && ( pxTCB != pxCurrentTCB ) ) { /*进入临界段*/ taskENTER_CRITICAL(); { /*判断任务是否已经挂起*/ if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE ) { traceTASK_RESUME( pxTCB );
/* The ready list can be accessed even if the scheduler is suspended because this is inside a critical section. 从挂起列表中移除 */ ( void ) uxListRemove( &( pxTCB->xStateListItem ) ); /*添加到就绪列表*/ prvAddTaskToReadyList( pxTCB );
/* A higher priority task may have just been resumed. 判断要恢复的任务优先级是否大于当前任务的优先级, 如果大于,释放CPU使用权,开始内核调度 */ if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority ) { /* This yield may not cause the task just resumed to run, but will leave the lists in the correct state for the next yield. */ taskYIELD_IF_USING_PREEMPTION(); } else { mtCOVERAGE_TEST_MARKER(); } } else { mtCOVERAGE_TEST_MARKER(); } } /*退出临界段*/ taskEXIT_CRITICAL(); } else { mtCOVERAGE_TEST_MARKER(); } }
#endif /* INCLUDE_vTaskSuspend */
复制代码


发布于: 刚刚阅读数: 3
用户头像

矜辰所致

关注

CSDN、知乎、微信公众号: 矜辰所致 2022.08.02 加入

不浮夸,不将就,认真对待学知识的我们,矜辰所致,金石为开! 为了活下去的嵌入式工程师,画画板子,敲敲代码,玩玩RTOS,搞搞Linux ...

评论

发布
暂无评论
FreeRTOS记录(二、FreeRTOS任务API认识和源码简析)_源码分析_矜辰所致_InfoQ写作社区