自学教程：C++ vTaskList函数代码示例

/*ref ref zzz0072, PJayChen*/void show_task_info(int argc, char* argv[]){#if 0	char ch;	/* 38 = & */	if (argv[1][0] == '&'){		/*use hardcoded array*/		portCHAR buf[MAX_CMDHELP];		vTaskList(buf);		printf("Name/t/tState Priority Stack/tNum");		printf("%s", buf); 		while (1){			if (receive_byte_noblock(&ch) == 1){ 				printf("DONE/n/r");         		break;			}        		}			}	else {			/*use hardcoded array*/		portCHAR buf[MAX_CMDHELP];		vTaskList(buf);		printf("Name/t/tState Priority Stack/tNum");		printf("%s", buf); 	}#endif}

int csp_sys_tasklist(char * out) {#if FREERTOS_VERSION < 8	vTaskList((signed portCHAR *) out);#else	vTaskList(out);#endif	return CSP_ERR_NONE;}

	void MPU_vTaskList( char *pcWriteBuffer )	{	BaseType_t xRunningPrivileged = xPortRaisePrivilege();		vTaskList( pcWriteBuffer );		vPortResetPrivilege( xRunningPrivileged );	}

/**  * @brief  Create and send a dynamic Web Page. This page contains the list of  *         running tasks and the number of page hits.   * @param  conn pointer on connection structure   * @retval None  */static void DynWebPage(struct netconn *conn){  portCHAR PAGE_BODY[800];  portCHAR pagehits[10] = {0};  memset(PAGE_BODY, 0,512);  /* Update the hit count */  nPageHits++;  sprintf(pagehits, "%d", (int)nPageHits);  strcat(PAGE_BODY, pagehits);  strcat((char *)PAGE_BODY, "<pre><br>Name          State  Priority  Stack   Num" );  strcat((char *)PAGE_BODY, "<br>---------------------------------------------<br>");  /* The list of tasks and their status */  vTaskList((signed char *)PAGE_BODY + strlen(PAGE_BODY));  strcat((char *)PAGE_BODY, "<br><br>---------------------------------------------");  strcat((char *)PAGE_BODY, "<br>B : Blocked, R : Ready, D : Deleted, S : Suspended<br>");  /* Send the dynamically generated page */  if((Global_Config.b.DistantControlEnabled != 0) && /     (Global_Config.b.BackgroundModeEnabled != 0) && /     (EthernetSettings.DistantControlEnabled == 1))  {    netconn_write(conn, PAGE_START_DC, strlen((char*)PAGE_START_DC), NETCONN_COPY);  }  else  {    netconn_write(conn, PAGE_START, strlen((char*)PAGE_START), NETCONN_COPY);  }  netconn_write(conn, PAGE_BODY, strlen(PAGE_BODY), NETCONN_COPY);}

void ps_command(int n, char *argv[]){	signed char buf[1024];	vTaskList(buf);        fio_printf(1, "/n/rName          State   Priority  Stack  Num/n/r");        fio_printf(1, "*******************************************/n/r");	fio_printf(1, "%s/r/n", buf + 2);	}

void MPU_vTaskList( char *pcWriteBuffer ){    BaseType_t xRunningPrivileged = prvRaisePrivilege();    vTaskList( pcWriteBuffer );    portRESET_PRIVILEGE( xRunningPrivileged );}

	void MPU_vTaskList( signed char *pcWriteBuffer )	{	portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();		vTaskList( pcWriteBuffer );		portRESET_PRIVILEGE( xRunningPrivileged );	}

void ShowTaskInfo(Serial *serial, unsigned int argc, char **argv){    putHeader(serial, "Task Info");    serial->put_s("Status/tPri/tStackHR/tTask#/tName");    put_crlf(serial);    /*     * Memory info from vTaskList can be misleading.  See     * http://www.freertos.org/uxTaskGetSystemState.html for     * more detail about how it works and value meanings.     */    char *taskList = (char *) portMalloc(1024);    if (NULL != taskList) {        vTaskList(taskList);        serial->put_s(taskList);        portFree(taskList);    } else {        serial->put_s("Out of Memory!");    }    put_crlf(serial);    put_crlf(serial);    serial->put_s("[Note] StackHR: If StackHR < 0; then stack smash");    put_crlf(serial);}

/* * Show all tasks and their states that are * running on the OS. */void cmd_ps(){	char listBuf[512] = {0};	sPuts( "Name/t      State Priority   Stack   Num" );	vTaskList( listBuf );	print_to_console( listBuf );}

void vPrintRtosStats(void){	uint8_t numTasks = uxTaskGetNumberOfTasks();	volatile size_t xFreeHeapSpace;	printf("Task Count %d:/n/n", numTasks);	#if ( configUSE_TRACE_FACILITY == 1 ) || ( configGENERATE_RUN_TIME_STATS == 1 )		char* strBuffer = (char*)pvPortMalloc(80 * numTasks);		if(strBuffer)		{			#if ( configUSE_TRACE_FACILITY == 1 )				strBuffer[0] = '/0';				vTaskList(strBuffer);				printf("%s/n", strBuffer);			#endif			#if ( configGENERATE_RUN_TIME_STATS == 1 )				strBuffer[0] = '/0';				vTaskGetRunTimeStats(strBuffer);				printf("%s/n", strBuffer);			#endif			vPortFree(strBuffer);		}	#endif	xFreeHeapSpace = xPortGetFreeHeapSize();	printf("Free Heap: %d bytes/n", xFreeHeapSpace);}

static unsigned short uslwIPAppsSSIHandler( int iIndex, char *pcBuffer, int iBufferLength ){static unsigned int uiUpdateCount = 0;static char cUpdateString[ 200 ];extern char *pcMainGetTaskStatusMessage( void );	/* Unused parameter. */	( void ) iBufferLength;	/* The SSI handler function that generates text depending on the index of	the SSI tag encountered. */		switch( iIndex )	{		case ssiTASK_STATS_INDEX :			vTaskList( pcBuffer );			break;		case ssiRUN_TIME_STATS_INDEX :			vTaskGetRunTimeStats( pcBuffer );			break;	}	/* Include a count of the number of times an SSI function has been executed	in the returned string. */	uiUpdateCount++;	sprintf( cUpdateString, "/r/n/r/n%u/r/nStatus - %s", uiUpdateCount, pcMainGetTaskStatusMessage() );	strcat( pcBuffer, cUpdateString );	return strlen( pcBuffer );}

static BaseType_t prvTaskStatsCommand( char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString ){const char *const pcHeader = "     State   Priority  Stack    #/r/n************************************************/r/n";BaseType_t xSpacePadding;	/* Remove compile time warnings about unused parameters, and check the	write buffer is not NULL.  NOTE - for simplicity, this example assumes the	write buffer length is adequate, so does not check for buffer overflows. */	( void ) pcCommandString;	( void ) xWriteBufferLen;	configASSERT( pcWriteBuffer );	/* Generate a table of task stats. */	strcpy( pcWriteBuffer, "Task" );	pcWriteBuffer += strlen( pcWriteBuffer );	/* Minus three for the null terminator and half the number of characters in	"Task" so the column lines up with the centre of the heading. */	configASSERT( configMAX_TASK_NAME_LEN > 3 );	for( xSpacePadding = strlen( "Task" ); xSpacePadding < ( configMAX_TASK_NAME_LEN - 3 ); xSpacePadding++ )	{		/* Add a space to align columns after the task's name. */		*pcWriteBuffer = ' ';		pcWriteBuffer++;		/* Ensure always terminated. */		*pcWriteBuffer = 0x00;	}	strcpy( pcWriteBuffer, pcHeader );	vTaskList( pcWriteBuffer + strlen( pcHeader ) );	/* There is no more data to return after this single string, so return	pdFALSE. */	return pdFALSE;}

void unit_test_task(void *pvParameters){    char msg1[] = "Start/n/r";    char msg2[512] = "Start testing.../n/r";    puts(msg1);    puts(msg2);    if (strcmp(msg1, msg2)) {        puts("msg1 and msg2 are diff/n/r");    }    else {        puts("strcpy result is not match/n/r");    }    if (strncmp(msg1, msg2, 5) == 0) {        puts("msg1 and msg2 first 5 chars are the same/n/r");    }    else {        puts("strncpy result is not match/n/r");    }    printf("test htoi(255):%s/n/r", htoa(255));    printf("test atoi(100):%s/n/r", itoa(100));    printf("/n");    strcat(msg2, msg1);    printf("strcat:%s/n/r", msg2);    sprintf(msg2, "==>test sprintf %s:%s:%d/n", msg1, "zzz", 122);    printf("sprintf:%s/n/r", msg2);        vTaskList(msg2);    printf("vTaskList:%s/n/r", msg2);}

/*** @brief   Lists all the current threads, along with their current state *          and stack usage high water mark.* @param   buffer   A buffer into which the above mentioned details*          will be written* @retval  status code that indicates the execution status of the function.*/osStatus osThreadList (uint8_t *buffer){#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) )  vTaskList((char *)buffer);#endif  return osOK;}

void ps_command(int n, char *argv[]){	int rnt;	signed char buf[1024];	vTaskList(buf);	fio_printf(1, "/r/n%s/r/n", buf);	rnt = host_savefile(argv[1], buf);	fio_printf(1, "/r/nfinish with exit code %d./r/n", rnt);	}

/*! /brief parse the incoming request *         parse the HTML request and send file * *  /param pxNetCon   Input. The netconn to use to send and receive data. * */static void prvweb_ParseHTMLRequest( struct netconn *pxNetCon ){struct netbuf *pxRxBuffer;portCHAR *pcRxString;unsigned portSHORT usLength;static unsigned portLONG ulPageHits = 0;#if ( (LWIP_VERSION) == ((1U << 24) | (3U << 16) | (2U << 8) | (LWIP_VERSION_RC)) )	/* We expect to immediately get data. */	pxRxBuffer = netconn_recv( pxNetCon );#else    while(netconn_recv( pxNetCon, &pxRxBuffer) != ERR_OK)    {		vTaskDelay( webSHORT_DELAY );	}#endif	if( pxRxBuffer != NULL )	{		/* Where is the data? */		netbuf_data( pxRxBuffer, ( void * ) &pcRxString, &usLength );		/* Is this a GET?  We don't handle anything else. */		if(( NULL != pcRxString               )		&& ( !strncmp( pcRxString, "GET", 3 ) ))		{			/* Update the hit count. */			ulPageHits++;			sprintf( cPageHits, "%d", (int)ulPageHits );			/* Write out the HTTP OK header. */			netconn_write( pxNetCon, webHTTP_OK, (u16_t) strlen( webHTTP_OK ), NETCONN_COPY );			/* Generate the dynamic page... First the page header. */			strcpy( cDynamicPage, webHTML_START );			/* ... Then the hit count... */			strcat( cDynamicPage, cPageHits );			strcat( cDynamicPage, "<p><pre>Task          State  Priority  Stack	#<br>************************************************<br>" );			/* ... Then the list of tasks and their status... */			vTaskList( ( signed portCHAR * ) cDynamicPage + strlen( cDynamicPage ) );			/* ... Finally the page footer. */			strcat( cDynamicPage, webHTML_END );			/* Write out the dynamically generated page. */			netconn_write( pxNetCon, cDynamicPage, (u16_t) strlen( cDynamicPage ), NETCONN_COPY );		}		netbuf_delete( pxRxBuffer );	}	netconn_close( pxNetCon );	netconn_delete( pxNetCon );}

static unsigned short generate_rtos_stats( void *arg ){	( void ) arg;	lRefreshCount++;	sprintf( cCountBuf, "<p><br>Refresh count = %d<p><br>%s", ( int ) lRefreshCount, pcGetTaskStatusMessage() );	vTaskList( uip_appdata );	strcat( uip_appdata, cCountBuf );	return strlen( uip_appdata );}

static unsigned shortgenerate_rtos_stats(void *arg){	lRefreshCount++;	sprintf( cCountBuf, "<p><br>Refresh count = %ld", lRefreshCount );    vTaskList( ( char * ) uip_appdata );	strcat( uip_appdata, cCountBuf );	return strlen( uip_appdata );}

portBASE_TYPE prvTaskStatsCommand(int8_t *pcWriteBuffer,								  size_t xWriteBufferLen,								  const int8_t *pcCommandString){	sprintf(pcWriteBuffer, taskListHdr);	pcWriteBuffer += strlen(taskListHdr);	vTaskList(pcWriteBuffer);	return pdFALSE;}

/***********************************			TASK USAGE CMD ***********************************/static portBASE_TYPE prvTaskUsageCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString ) {	static portCHAR buffer[400];	// get current running tasks	vTaskList((signed char *)(buffer));	debug_printf("NAME          STATE  PRIORITY  STACK   NUM/r/n");	debug_printf("*********************************************/r/n");	debug_printf("%s", buffer);	xWriteBufferLen = sprintf((char *) pcWriteBuffer, "/n/r");	return pdFALSE;}

static unsigned shortgenerate_rtos_stats(void *arg){	( void ) arg;	lRefreshCount++;	sprintf( cCountBuf, "<p><br>Refresh count = %d, Error code = %d (0 = no errors)", (int)lRefreshCount, (int)ulGetErrorCode() );    vTaskList( uip_appdata );	strcat( uip_appdata, cCountBuf );	return strlen( uip_appdata );}

/** * /brief This task, when activated, send every ten seconds on debug UART * the whole report of free heap and total tasks status */static void task_monitor(void *pvParameters){    static portCHAR szList[256];    UNUSED(pvParameters);    for (;;) {        printf("--- task ## %u", (unsigned int)uxTaskGetNumberOfTasks());        vTaskList((signed portCHAR *)szList);        printf(szList);        vTaskDelay(1000);    }}

/* * Process an incoming connection on port 80. * * This simply checks to see if the incoming data contains a GET request, and * if so sends back a single dynamically created page.  The connection is then * closed.  A more complete implementation could create a task for each * connection. */static voidvProcessConnection( struct netconn *pxNetCon ){    static char cDynamicPage[webMAX_PAGE_SIZE], cPageHits[11];    struct netbuf  *pxRxBuffer;    char       *pcRxString;    unsigned short usLength;    static unsigned long ulPageHits = 0;    /* We expect to immediately get data. */    pxRxBuffer = netconn_recv( pxNetCon );    if( pxRxBuffer != NULL )    {        /* Where is the data? */        netbuf_data( pxRxBuffer, ( void * )&pcRxString, &usLength );        /* Is this a GET?  We don't handle anything else. */        if( !strncmp( pcRxString, "GET", 3 ) )        {            pcRxString = cDynamicPage;            /* Update the hit count. */            ulPageHits++;            sprintf( cPageHits, "%lu", ulPageHits );            /* Write out the HTTP OK header. */            netconn_write( pxNetCon, webHTTP_OK, ( u16_t ) strlen( webHTTP_OK ), NETCONN_COPY );            /* Generate the dynamic page...               ... First the page header. */            strcpy( cDynamicPage, webHTML_START );            /* ... Then the hit count... */            strcat( cDynamicPage, cPageHits );            strcat( cDynamicPage,                    "<p><pre>Task          State  Priority  Stack #<br>************************************************<br>" );            /* ... Then the list of tasks and their status... */            vTaskList( ( signed char * )cDynamicPage + strlen( cDynamicPage ) );            /* ... Finally the page footer. */            strcat( cDynamicPage, webHTML_END );            /* Write out the dynamically generated page. */            netconn_write( pxNetCon, cDynamicPage, ( u16_t ) strlen( cDynamicPage ), NETCONN_COPY );        }        netbuf_delete( pxRxBuffer );    }    netconn_close( pxNetCon );}

void semihost_sysinfo(void *pvParameters){	int rnt = host_system("echo /'Write system info to /"./sysinfo/" periodically./'");	char buf[1024];	while(1) {		/* Clear buf */		strcpy (buf, "echo /'");		/* Retrieve task list */		vTaskList((signed char *)&buf[strlen(buf)], "/0");		strcat (&buf[ strlen(buf) ], (const char*) "/' > ./sysinfo");		rnt = host_system(buf);		vTaskDelay(200);	}}

static unsigned shortgenerate_rtos_stats(void *arg){	( void ) arg;	lRefreshCount++;	sprintf( cCountBuf, "<p><br>Refresh count = %d<p><br>%s<br>%s",	         (int)lRefreshCount,	         "All OK!",	         XXX_glbl_msg );    vTaskList( uip_appdata );	strcat( uip_appdata, cCountBuf );	return strlen( uip_appdata );}

static void vHelloWorld( void *pvParameters ) {	xTaskHandle thisTask = xTaskGetCurrentTaskHandle();	char buf[64];	/* The parameters are not used. */	( void ) pvParameters;	consoleInit();	vTaskList(buf);	printf("%s", buf);	for( ;; ) {		printf("Running: %u/r/n", xTaskGetTickCount());		vTaskDelay( 5000 );	}}

void ShowTaskInfo(Serial *serial, unsigned int argc, char **argv){	serial->put_s("Task Info");	put_crlf(serial);	serial->put_s("Status/tPri/tStack/tTask#/tName");	put_crlf(serial);	char *taskList = (char *)portMalloc(1024);	if (NULL != taskList){		vTaskList(taskList);		serial->put_s(taskList);		portFree(taskList);	}	else{		serial->put_s("Out of Memory!");	}	put_crlf(serial);}

static void vButtonHandlerTask( void *pvParameters ){static char cListBuffer[ mainLIST_BUFFER_SIZE ];const char *pcList = &( cListBuffer[ 0 ] );const char * const pcHeader = "/nTask          State  Priority  Stack	#/n************************************************";extern void (vButtonISRWrapper) ( void );	/* Just to stop compiler warnings. */	( void ) pvParameters;	/* Configure the interrupt. */	portENTER_CRITICAL();	{		/* Configure P0.14 to generate interrupts. */		PINSEL0 |= mainP0_14__EINT_1;		EXTMODE = mainEINT_1_EDGE_SENSITIVE;		EXTPOLAR = mainEINT_1_FALLING_EDGE_SENSITIVE;		/* Setup the VIC for EINT 1. */		VICIntSelect &= ~mainEINT_1_VIC_CHANNEL_BIT;		VICIntEnable |= mainEINT_1_VIC_CHANNEL_BIT;		VICVectAddr1 = ( long ) vButtonISRWrapper;		VICVectCntl1 = mainEINT_1_ENABLE_BIT | mainEINT_1_CHANNEL;	}	portEXIT_CRITICAL();	for( ;; )	{		/* For debouncing, wait a while then clear the semaphore. */		vTaskDelay( mainSHORT_DELAY );		xSemaphoreTake( xButtonSemaphore, mainNO_DELAY );		/* Wait for an interrupt. */		xSemaphoreTake( xButtonSemaphore, portMAX_DELAY );		/* Send the column headers to the print task for display. */		xQueueSend( xPrintQueue, &pcHeader, portMAX_DELAY );		/* Create the list of task states. */		vTaskList( cListBuffer );		/* Send the task status information to the print task for display. */		xQueueSend( xPrintQueue, &pcList, portMAX_DELAY );	}}

static void	prvCheckForKeyPresses( void ){short sIn;	taskENTER_CRITICAL();		#ifdef DEBUG_BUILD			/* kbhit can be used in .exe's that are executed from the command			line, but not if executed through the debugger. */			sIn = 0;		#else			sIn = kbhit();		#endif	taskEXIT_CRITICAL();	if( sIn )	{		/* Key presses can be used to start/stop the trace utility, or end the 		program. */		sIn = getch();		switch( sIn )		{			/* Only define keys for turning on and off the trace if the trace			is being used. */			#if configUSE_TRACE_FACILITY == 1				case 't' :	vTaskList( pcWriteBuffer );							vWriteMessageToDisk( pcWriteBuffer );							break;				/* The legacy trace is no longer supported.  Use FreeRTOS+Trace instead				case 's' :	vTaskStartTrace( pcWriteBuffer, mainDEBUG_LOG_BUFFER_SIZE );							break;				case 'e' :	{								unsigned long ulBufferLength;								ulBufferLength = ulTaskEndTrace();								vWriteBufferToDisk( pcWriteBuffer, ulBufferLength );							}							break;				*/			#endif			default  :	vTaskEndScheduler();						break;		}	}}

static void	 prvCheckForKeyPresses( void ){	#ifdef USE_STDIO	short sIn;			taskENTER_CRITICAL();			sIn = kbhit();		taskEXIT_CRITICAL();		if( sIn )		{			unsigned long ulBufferLength;			/* Key presses can be used to start/stop the trace utility, or end the			program. */			sIn = getch();			switch( sIn )			{				/* Only define keys for turning on and off the trace if the trace				is being used. */				#if configUSE_TRACE_FACILITY == 1					case 't' :	vTaskList( pcWriteBuffer );								vWriteMessageToDisk( pcWriteBuffer );								break;					/* The legacy trace is no longer supported.  Use FreeRTOS+Trace instead.					case 's' :	vTaskStartTrace( pcWriteBuffer, mainDEBUG_LOG_BUFFER_SIZE );								break;					case 'e' :	ulBufferLength = ulTaskEndTrace();								vWriteBufferToDisk( pcWriteBuffer, ulBufferLength );								break;*/				#endif				default  :	vTaskEndScheduler();							break;			}		}	#else		( void ) pcWriteBuffer;	#endif}