LMCH的个人空间 http://bbs.21ic.com/?1407155 [收藏] [复制] [分享] [RSS]

日志

FreeRTOS----任务及任务调度(二)

已有 301 次阅读2017-6-6 18:14 |个人分类:RTOS|系统分类:嵌入式系统

3.4.14       xTaskGetTaskHandle(const char *pcNameToQuery )

根据给出的任务名称查询任务的句柄。依次调用prvSearchForNameWithinSingleList()pxReadyTasksListspxDelayedTaskListpxOverflowDelayedTaskListxSuspendedTaskListxTasksWaitingTermination列表中查询是否含有指定名称的任务。

                

pcNameToQuery      任务名称的指针

         搜索到任务,返回其指针;否则返回NULL
TaskHandle_t xTaskGetTaskHandle( const char *pcNameToQuery )

    {
UBaseType_t uxQueue = configMAX_PRIORITIES;//
用于按优先级查找就绪列表
TCB_t* pxTCB;

/*
任务名称的长度应合法 */
configASSERT( strlen( pcNameToQuery ) < configMAX_TASK_NAME_LEN );

vTaskSuspendAll();//
挂起调度器
{

/*
搜索就绪列表 */
do

{

                uxQueue--;

                pxTCB = prvSearchForNameWithinSingleList( ( List_t * )&( pxReadyTasksLists[ uxQueue ] ),  pcNameToQuery);

                if( pxTCB != NULL )//找到了任务

                {

                    /* 退出循环 */

                    break;

                }
} while( uxQueue > ( UBaseType_t ) tskIDLE_PRIORITY );

/*
如果就绪列表中没有找到,搜索延时列表 */
if( pxTCB == NULL )
 
{

                pxTCB =prvSearchForNameWithinSingleList(   ( List_t * )pxDelayedTaskList, pcNameToQuery );
}
   
if( pxTCB == NULL )

{

                pxTCB =prvSearchForNameWithinSingleList(    ( List_t * )pxOverflowDelayedTaskList, pcNameToQuery );
}

/*
如果延时列表中也没找到,搜索挂起任务列表 */
#if ( INCLUDE_vTaskSuspend == 1 )

{

                if( pxTCB == NULL )

                {

                    pxTCB =prvSearchForNameWithinSingleList(  &xSuspendedTaskList,pcNameToQuery );

                }
}
    
#endif

/*
如果以上都没找到,搜索待删除任务列表 */
#if( INCLUDE_vTaskDelete == 1 )

{

                if( pxTCB == NULL )

                {

                    pxTCB =prvSearchForNameWithinSingleList( &xTasksWaitingTermination, pcNameToQuery );

                }
}

#endif

}

( void ) xTaskResumeAll();//
恢复调度器
return ( TaskHandle_t ) pxTCB;//
返回任务句柄
 }

3.1.14.1   *prvSearchForNameWithinSingleList(List_t *pxList, const char pcNameToQuery[] )

在指定列表中按名称搜索任务。根据给定的任务名称,对列表中的任务名称逐字母检查,直到完全匹配便返回任务TCB的指针。

                

pxList        列表指针

pcNameToQuery[]   任务名称字符数组

         搜索到任务,返回其指针;否则返回NULL
static TCB_t *prvSearchForNameWithinSingleList( List_t *pxList, const char pcNameToQuery[] )

 {
TCB_t *pxNextTCB, *pxFirstTCB, *pxReturn = NULL;

UBaseType_t x;

char cNextChar;

/*
本函数应在调度器挂起后调用 */

        if( listCURRENT_LIST_LENGTH( pxList ) > ( UBaseType_t ) 0 )
{

/*
如果指定的列表中有任务 */
listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );

do
       
{

                listGET_OWNER_OF_NEXT_ENTRY(pxNextTCB, pxList );

                /* 逐个检查任务名称的字符,一旦发现不同的字符,便退出循环, 处理下一个任务,如果查到了任务名称最后一个字符都一致,则 返回任务的指针;如果没有查到任务,则返回NULL */

                for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )

                {

                    cNextChar = pxNextTCB->pcTaskName[ x ];

                    if( cNextChar != pcNameToQuery[ x ] )

                    {

                        break;

                    }

                    else if( cNextChar == 0x00)

                    {

                        pxReturn = pxNextTCB;

                        break;

                    }

                    else

                    {

                        mtCOVERAGE_TEST_MARKER();//nothing

                    }

                }

                if( pxReturn != NULL )

                {

                    break;

                }
} while( pxNextTCB != pxFirstTCB );

}
 
else

{
    
mtCOVERAGE_TEST_MARKER();//nothing

}
  
return pxReturn;

    }

3.4.15       xTaskGetCurrentTaskHandle( void )

获取当前任务的句柄,直接返回pxCurrentTCB

                

xTask        任务句柄

         当前任务句柄
TaskHandle_t xTaskGetCurrentTaskHandle( void )

    {

    TaskHandle_t xReturn;
xReturn = pxCurrentTCB;

return xReturn;

    }

3.4.16       xTaskGetIdleTaskHandle(void )

获取空闲任务的句柄,直接返回xIdleTaskHandle

                

xTask       

         空闲任务的句柄
TaskHandle_t xTaskGetIdleTaskHandle( void )

    {
configASSERT( ( xIdleTaskHandle != NULL ) );

return xIdleTaskHandle;

    }

3.4.17       uxTaskGetNumberOfTasks(void )

获取系统中任务数量,直接返回uxCurrentNumberOfTasks

                

xTask        任务句柄

         钩子函数的指针

UBaseType_t uxTaskGetNumberOfTasks( void )

{

    return uxCurrentNumberOfTasks;

}

3.4.18       xTaskGetSchedulerState(void )

获取调度器状态。

                

    

         taskSCHEDULER_SUSPENDED,调度器挂起

                       taskSCHEDULER_NOT_STARTED,调度器没有启动

                       taskSCHEDULER_RUNNING,调度器正在运行
BaseType_t xTaskGetSchedulerState( void )

    {

    BaseType_t xReturn;
/*
如果调度器没有启动 */
if( xSchedulerRunning == pdFALSE )
  
{
  
xReturn = taskSCHEDULER_NOT_STARTED;

}
     
else

{
   
/*
调度器正在运行 */
if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )

{

                xReturn =taskSCHEDULER_RUNNING;      
}
       
/*
调度器已启动但挂起 */
else
    
{

                xReturn =taskSCHEDULER_SUSPENDED;

            }
}

return xReturn;

    }

3.4.19       uxTaskGetStackHighWaterMark(TaskHandle_t xTask )

获取任务栈最高历史水位(任务栈使用空间最高时栈空间的剩余量)。首先根据栈的生长方向获取任务的任务栈末地址,然后调用prvTaskCheckFreeStackSpace()函数获取未被使用的栈的数量。

                

xTask        任务句柄

         任务运行过程中栈的剩余空间最小的时候的剩余数量,以4字节为单位
UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask )

    {
TCB_t *pxTCB;

uint8_t *pucEndOfStack;

UBaseType_t uxReturn;

/*
获取任务TCB指针 */
pxTCB = prvGetTCBFromHandle( xTask );

#if portSTACK_GROWTH < 0
    
{
 
pucEndOfStack = ( uint8_t * ) pxTCB->pxStack;

}

#else

{

pucEndOfStack = ( uint8_t * ) pxTCB->pxEndOfStack;
 
}
  
#endif

uxReturn = ( UBaseType_t ) prvTaskCheckFreeStackSpace( pucEndOfStack );

return uxReturn;

    }

3.1.19.1   prvTaskCheckFreeStackSpace(const uint8_t * pucStackByte )

计算任务栈水位。prvInitialiseNewTask()(见3.4.3.1)初始化任务时,将任务栈的整个空间以0xa5U填满,某地址的值如果不为0xa5U,则说明该地址的栈被任务使用过。计算任务水位时,便是从栈末尾开始,逐字节检查内存的值,并计算没有使用的栈空间的数量。

                

pucStackByte   任务栈的末地址

         任务运行过程中栈的剩余空间最小的时候的剩余数量,以4字节为单位
static uint16_t prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte)

    {
uint32_t ulCount = 0U;

/*
在任务初始化的时候,栈被填写了0xa5U */
  while( *pucStackByte == (uint8_t ) tskSTACK_FILL_BYTE/*0xa5U*/ )

{
  
pucStackByte -= portSTACK_GROWTH/*-1*/;

ulCount++;

}

ulCount /= ( uint32_t ) sizeof( StackType_t );

return ( uint16_t ) ulCount;

    }

3.4.20       eTaskGetState(TaskHandle_t xTask )

获取任务的状态。通过任务TCB的状态列表Item和事件列表ItemContainer判断任务的状态。

                

xTask        任务句柄

         任务状态:

                        eRunning,任务正在运行

                        eReady,任务就绪等待运行

                        eBlocked,任务阻塞

                        eSuspended,任务被挂起

                        eDeleted,任务正等待删除
eTaskState eTaskGetState( TaskHandle_t xTask )

    {
eTaskState eReturn;
 
List_t *pxStateList;

const TCB_t * const pxTCB = ( TCB_t * ) xTask;

configASSERT( pxTCB );

if( pxTCB == pxCurrentTCB )//
如果获取运行中的任务状态
{
 
/*
运行中的任务获得自己的状态,得到eRunning */

            eReturn = eRunning;   
}

else

{
   
taskENTER_CRITICAL();//
进入临界段    
{

                /* 获取任务的状态列表 */

                pxStateList = ( List_t * )listLIST_ITEM_CONTAINER( &( pxTCB->xStateListItem ) );
}

taskEXIT_CRITICAL();//
退出临界段
/*
如果任务在延时列表 */
if( ( pxStateList == pxDelayedTaskList ) || ( pxStateList ==pxOverflowDelayedTaskList ) )

{

                /* 将返回eBlocked

                eReturn = eBlocked;
}

#if ( INCLUDE_vTaskSuspend == 1 )//
如果启用了挂起任务功能

                else if( pxStateList ==&xSuspendedTaskList )//如果任务在挂起列表中

                {

                    /* 如果不在任务事件列表中,则任务状态为eSuspended;如果任务也在某个事件列表中,任务状态为eBlocked */

                    if(listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL )

                    {

                        eReturn = eSuspended;

                    }

                    else

                    {
                eReturn =eBlocked;

                    }

                }
#endif

#if ( INCLUDE_vTaskDelete == 1 )//
如果启用了删除任务功能

                else if( ( pxStateList ==&xTasksWaitingTermination ) || ( pxStateList == NULL ) )

                {

                    /* 任务的状态列表在等待终止列表或状态列表为NULL,返回eDeleted

                    eReturn = eDeleted;

                }
#endif

else

{

                /* 任务属于以上任何情况,它一定在就绪列表中,包括就绪等待状态,返回eReady* /

                eReturn = eReady;
}
   
}

return eReturn;

    }

3.4.21       uxTaskGetSystemState(TaskStatus_t * const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t * const pulTotalRunTime )

获得系统任务信息。调用函数prvListTasksWithinSingleList()逐个获取列表pxReadyTasksListspxDelayedTaskListpxOverflowDelayedTaskListxTasksWaitingTerminationxSuspendedTaskList中的任务信息;根据系统配置读取系统总运行时间,保存在pulTotalRunTime中。

                

pxTaskStatusArray  保存任务状态的数组指针

uxArraySize      数组大小

pulTotalRunTime      保存总的运行时间的指针

         系统任务的数量
UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t * const  pulTotalRunTime )

    {
UBaseType_t uxTask = 0, uxQueue = configMAX_PRIORITIES;

vTaskSuspendAll();//
挂起调度器
{
    
/*
数组空间是否能放下系统中所有任务 */
if( uxArraySize >= uxCurrentNumberOfTasks )

{

                /* 用就绪状态任务的信息填充TaskStatus_t结构体 */

                do

                {

                    uxQueue--;

                    uxTask +=prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), &(pxReadyTasksLists[ uxQueue ] ), eReady );

                } while( uxQueue > (UBaseType_t ) tskIDLE_PRIORITY );

                /* 用阻塞状态任务的信息填充TaskStatus_t结构体 */

                uxTask +=prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), ( List_t *) pxDelayedTaskList, eBlocked );

                uxTask +=prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), ( List_t *) pxOverflowDelayedTaskList, eBlocked );

                #if( INCLUDE_vTaskDelete == 1 )

                {

                    /* 用待删除的任务信息填充TaskStatus_t结构体 */

                    uxTask +=prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ),&xTasksWaitingTermination, eDeleted );

                }

                #endif

                #if ( INCLUDE_vTaskSuspend == 1)

                {

                    /* 用挂起状态任务的信息填充TaskStatus_t结构体 */

                    uxTask +=prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ),&xSuspendedTaskList, eSuspended );

                }

                #endif

                #if (configGENERATE_RUN_TIME_STATS/*0*/ == 1)//括号中的宏没有定义

                {

                    if( pulTotalRunTime != NULL)

                    {

                        #ifdef portALT_GET_RUN_TIME_COUNTER_VALUE 

                                  portALT_GET_RUN_TIME_COUNTER_VALUE( ( *pulTotalRunTime ) );

                        #else

                            *pulTotalRunTime =portGET_RUN_TIME_COUNTER_VALUE();

                        #endif

                    }

                }

                #else

                {

                    if( pulTotalRunTime != NULL)

                    {

                        *pulTotalRunTime = 0;

                    }

                }

                #endif
}

else
  
{
   
mtCOVERAGE_TEST_MARKER();//nothing

}

}

( void ) xTaskResumeAll();//
恢复调度器
return uxTask;

    }

3.1.21.1   结构体TaskStatus_t

该结构体用于保存任务状态信息,定义在task.h文件中。

typedef struct xTASK_STATUS

{
TaskHandle_t xHandle;           /*
任务句柄 */
const char *pcTaskName;         /*
任务名称的指针 */
UBaseType_t xTaskNumber;        /*
任务序号 */
eTaskState eCurrentState;       /*
任务当前状态 */
UBaseType_t uxCurrentPriority;  /*
任务当前优先级 */
UBaseType_t uxBasePriority;     /*
继承优先级的任务原来的优先级 */
uint32_t ulRunTimeCounter;      /*
任务运行的总时间 */

    StackType_t *pxStackBase;       /* 任务栈最低地址 */
uint16_t usStackHighWaterMark;  /*
任务执行过程中栈的最高水位,数值为任务创建后剩余栈的数量的最小值 */

} TaskStatus_t;

3.1.21.2   pulTotalRunTime

从函数中可以看到是否更新该值取决于用户对configGENERATE_RUN_TIME_STATS的配置,默认情况下该值为0,即不对该值进行更新。configGENERATE_RUN_TIME_STATSFreeRTOSConfig.h文件中进行配置。

3.1.21.3   prvListTasksWithinSingleList(TaskStatus_t *pxTaskStatusArray, List_t *pxList, eTaskState eState )

将指定的列表中的所有任务信息填充到TaskStatus_t结构体中,它是循环调用函数vTaskGetTaskInfo()3.4.22)读取指定任务列表中的任务状态并填充结构体。

                

pxTaskStatusArray  保存任务状态的数组指针

pxList        任务列表指针

eState      任务状态

         列表中的任务数量
static UBaseType_t prvListTasksWithinSingleList( TaskStatus_t *pxTaskStatusArray, List_t *pxList, eTaskState eState )

    {
volatile TCB_t *pxNextTCB, *pxFirstTCB;

UBaseType_t uxTask = 0;

/*
列表中是否有任务 */
if( listCURRENT_LIST_LENGTH( pxList ) > ( UBaseType_t ) 0 )

{

/*
从列表中获取第一个ItemOwner,即TCB */
listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );

do

{

                /* pxFirstTCB的下一个任务开始,直到回到pxFirstTCB,用任务填充pxTaskStatusArray */

                listGET_OWNER_OF_NEXT_ENTRY(pxNextTCB, pxList );

                vTaskGetTaskInfo( (TaskHandle_t ) pxNextTCB, &( pxTaskStatusArray[ uxTask ] ), pdTRUE, eState);

                uxTask++;
} while( pxNextTCB != pxFirstTCB );
  
}

else

{

mtCOVERAGE_TEST_MARKER();//nothing

}

return uxTask;

    }

3.4.22       vTaskGetTaskInfo(TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace,eTaskState eState )

获取任务的信息,填入到任务状态结构体中。

                

xTask        任务句柄

pxTaskStatus   任务状态信息结构体

xGetFreeStackSpace        是否获取任务栈的空闲空间

eState      任务状态

        
void vTaskGetTaskInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus,BaseType_t xGetFreeStackSpace, eTaskState eState )

    {
TCB_t *pxTCB;

/*
获取任务的指针,如果参数为NULL,则获取当前任务 */
pxTCB = prvGetTCBFromHandle( xTask );

/*
填充任务信息 */
pxTaskStatus->xHandle = ( TaskHandle_t ) pxTCB;

pxTaskStatus->pcTaskName = ( const char * ) &(pxTCB->pcTaskName [ 0 ] );

pxTaskStatus->uxCurrentPriority = pxTCB->uxPriority;

pxTaskStatus->pxStackBase = pxTCB->pxStack;

        pxTaskStatus->xTaskNumber =pxTCB->uxTCBNumber;
#if ( INCLUDE_vTaskSuspend == 1 )

{

/*
如果任务在挂起任务列表中,有可能任务只是由于无限期地阻塞状态,因此它应该被划为阻塞状态 */
if( pxTaskStatus->eCurrentState == eSuspended )/* eState == eSuspended*/

{

                vTaskSuspendAll();//挂起调度器

                {

                    /* 判断任务的事件列表Itemcontainer是否为NULL,不为NULL说明任务阻塞在等待某一事件上,只是是无限期等待,而不是真的挂起了任务 */

                    if( listLIST_ITEM_CONTAINER(&( pxTCB->xEventListItem ) ) != NULL )

                    {
                        pxTaskStatus->eCurrentState = eBlocked;

                    }

                }

                xTaskResumeAll();//恢复调度器
}

}

        #endif /* INCLUDE_vTaskSuspend */
#if ( configUSE_MUTEXES == 1 )

{

pxTaskStatus->uxBasePriority = pxTCB->uxBasePriority;

}

#else

{

pxTaskStatus->uxBasePriority = 0;

}

#endif

#if ( configGENERATE_RUN_TIME_STATS == 1 )

{

pxTaskStatus->ulRunTimeCounter = pxTCB->ulRunTimeCounter;

}

#else

{

pxTaskStatus->ulRunTimeCounter = 0;

}

#endif

        /* 如果eState有效,填写eCurrentState字段;否则获取任务的状态*/
if( eState != eInvalid )

{
      
pxTaskStatus->eCurrentState = eState;

}

else

{

pxTaskStatus->eCurrentState = eTaskGetState( xTask );

}

        /* 获取任务栈最小剩余空间需要一些时间,参数xGetFreeStackSpacepdTRUE表示要获取该值;否则跳过该步骤 */
if( xGetFreeStackSpace != pdFALSE )

{

#if ( portSTACK_GROWTH/*-1*/ > 0 )

{

pxTaskStatus->usStackHighWaterMark = prvTaskCheckFreeStackSpace( (uint8_t * ) pxTCB->pxEndOfStack );

}

#else

{

pxTaskStatus->usStackHighWaterMark = prvTaskCheckFreeStackSpace( (uint8_t * ) pxTCB->pxStack );
     
}

#endif

}

else

{

pxTaskStatus->usStackHighWaterMark = 0;

}

    }

3.4.23       *pcTaskGetName(TaskHandle_t xTaskToQuery )

获取任务名称,直接获取任务TCB名称的指针。

                

xTaskToQuery  任务句柄

         任务名称的指针

char *pcTaskGetName( TaskHandle_t xTaskToQuery )

{

TCB_t *pxTCB;
pxTCB = prvGetTCBFromHandle( xTaskToQuery );

configASSERT( pxTCB );

return &( pxTCB->pcTaskName[ 0 ] );

}

3.4.24       xTaskGetTickCount(void )

获得系统内核时基计数值xTickCount,它代表了内核时间。调用到了portTICK_TYPE_ENTER_CRITICAL(),因为获取xTickCount时需要确保不被修改,如果是在16位或8位机中,读取该值可能需要两到四次操作,因此要进入临界段保护;而如果是在32位系统中,获取该值是一次原子操作,无需进入临界段保护。

                

    

         时基计数值

TickType_t xTaskGetTickCount( void )

{

TickType_t xTicks;

    /* 如果在16位系统中,需要进入临界段保护 */
portTICK_TYPE_ENTER_CRITICAL();

    {
xTicks = xTickCount;

    }
portTICK_TYPE_EXIT_CRITICAL();

return xTicks;

}

3.4.25       xTaskGetTickCountFromISR(void )

中断服务中获得系统内核时基计数值xTickCount。方法同上一节。

                

    

         时基计数值

TickType_t xTaskGetTickCountFromISR( void )

{

TickType_t xReturn;

UBaseType_t uxSavedInterruptStatus;
/*
检查中断优先级的有效性 */
portASSERT_IF_INTERRUPT_PRIORITY_INVALID();

uxSavedInterruptStatus =portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();/*0*/

    {
xReturn = xTickCount;

    }
portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus
);/*0*/

return xReturn;

}

3.4.26       vTaskList(char * pcWriteBuffer )

将系统所有任务信息整理成格式化表格向指定地址输出。这个函数是个条件编译函数,需要在FreeRTOSConfig.h文件中对configUSE_TRACE_FACILITY配置为1且在FreeRTOS.h文件中将configUSE_STATS_FORMATTING_FUNCTIONS配置为非0值,该函数才能被编译。它首先为任务的列表分配足够的内存,然后调用函数uxTaskGetSystemState()(见3.4.21)获取任务状态信息,最后将任务名称、状态、当前优先级、任务栈水位、和任务编号格式化输出到制定的内存中。

                

pcWriteBuffer 输出任务列表的内存指针

        

#if ( ( configUSE_TRACE_FACILITY/* 1 */ ==1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS/* 0 */ > 0 ) )
void vTaskList( char * pcWriteBuffer )

    {
TaskStatus_t *pxTaskStatusArray;

    volatile UBaseType_t uxArraySize, x;
char cStatus;
   
/*
确保缓存不包含字符串,第一个字节写0 */
*pcWriteBuffer = 0x00;

/*
列数为当前系统的任务数 */
uxArraySize = uxCurrentNumberOfTasks;

/*
为每个任务分配一个数组。注意,如果configSUPPORT_DYNAMIC_ALLOCATION设为0 pvPortMalloc()等于0 */
pxTaskStatusArray = pvPortMalloc( uxCurrentNumberOfTasks * sizeof(TaskStatus_t ) );

if( pxTaskStatusArray != NULL )

{
  
/*
内存分配成功,获得任务状态数据 */
uxArraySize = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, NULL);
  
/*
创建人们易读的表格 */
for( x = 0; x < uxArraySize; x++ )

{

                switch( pxTaskStatusArray[ x].eCurrentState )

                {

                    case eReady:        cStatus = tskREADY_CHAR/*'R'*/;

                                        break;

                    case eBlocked:      cStatus = tskBLOCKED_CHAR/*'B'*/;

                                        break;

                    case eSuspended:    cStatus = tskSUSPENDED_CHAR/*'S'*/;

                                        break;

                    case eDeleted:      cStatus = tskDELETED_CHAR/*'D'*/;

                                        break;

                    default:

                                        cStatus= 0x00;

                                        break;

                }

                /* 将任务名称写到字符串中,并以空格填充字符串 */

                pcWriteBuffer =prvWriteNameToBuffer( pcWriteBuffer, pxTaskStatusArray[ x ].pcTaskName );

                /* 将其它信息写入字符串 */

                sprintf( pcWriteBuffer,"\t%c\t%u\t%u\t%u\r\n", cStatus, ( unsigned int ) pxTaskStatusArray[x ].uxCurrentPriority, ( unsigned int ) pxTaskStatusArray[ x].usStackHighWaterMark, ( unsigned int ) pxTaskStatusArray[ x ].xTaskNumber );

                pcWriteBuffer += strlen(pcWriteBuffer );
}

/*
处理完毕,释放存放任务状态的内存 */
vPortFree( pxTaskStatusArray );

}

else

{

mtCOVERAGE_TEST_MARKER();//nothing

}

}

#endif


路过

鸡蛋

鲜花

握手

雷人

发表评论 评论 (1 个评论)

回复 LMCH 2017-6-7 18:32
从我的word复制过来,格式太难调了,麻烦的要死

facelist

您需要登录后才可以评论 登录 | 注册

返回顶部