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

/* called in each task but currently disabled */void CheckStackUsage(xTaskHandle TaskHandle, tString *TaskName){#if CHECK_STACK_USAGE  portBASE_TYPE HighWater = uxTaskGetStackHighWaterMark(TaskHandle);  if (HighWater < 20) PrintF("%s Water:%d", TaskName, HighWater);#endif}

void CheckStackAndQueueUsage(unsigned char Index){  portBASE_TYPE Water = uxTaskGetStackHighWaterMark(NULL);  portBASE_TYPE QueLen = QueueHandles[Index]->uxMessagesWaiting;  if (Water < 10 || QueLen > 8)    PrintF("~%c S:%d Q:%u", Index == DISPLAY_QINDEX ? 'D' : 'W', Water, QueLen);}

void SystemStats(void){	char buf[120];//, buf2[300];	unsigned portBASE_TYPE Shoutcast, Vs, Heartbeat, lwIP, ETH, TP, WM;	if (pdTRUE == xSemaphoreTake(xButton_pushed_Semaphore, 0)) {		printf("/r/n-----------Run time stats-----------/r/n");		vTaskGetRunTimeStats((signed char*) buf);		UART_PrintBuf(buf, strlen(buf));		//		vTaskList((signed char*)buf2);		//		UART_PrintBuf (buf2, strlen(buf2));		printf("/r/n------------------------------------/r/n");		//		Heartbeat = uxTaskGetStackHighWaterMark(NULL);		Shoutcast = uxTaskGetStackHighWaterMark(xShoutcastTaskHandle);		Vs = uxTaskGetStackHighWaterMark(xVsTskHandle);		lwIP = uxTaskGetStackHighWaterMark(xLWIPTskHandler);		ETH = uxTaskGetStackHighWaterMark(xETHTsk);		TP = uxTaskGetStackHighWaterMark(xTouchPanelTskHandle);		WM = uxTaskGetStackHighWaterMark(xWinMngTskHandle);		printf("/r/n--------Tasks stack watermark-------/r/n");		printf("Hearbeat:   %d/r/n", Heartbeat);		printf("Shoutcast:  %d/r/n", Shoutcast);		printf("VS:         %d/r/n", Vs);		printf("lwIP:       %d/r/n", lwIP);		printf("ETH:        %d/r/n", ETH);		printf("TouchP:     %d/r/n", TP);		printf("WinMan:    %d/r/n", WM);		printf("/r/n------------------------------------/r/n");	}	LED_Toggle(2);}

	UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask )	{	UBaseType_t uxReturn;	BaseType_t xRunningPrivileged = xPortRaisePrivilege();		uxReturn = uxTaskGetStackHighWaterMark( xTask );		vPortResetPrivilege( xRunningPrivileged );		return uxReturn;	}

UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ){    UBaseType_t uxReturn;    BaseType_t xRunningPrivileged = prvRaisePrivilege();    uxReturn = uxTaskGetStackHighWaterMark( xTask );    portRESET_PRIVILEGE( xRunningPrivileged );    return uxReturn;}

/** * * @brief   Returns stack usage of a thread. * * @param[in] threadp      pointer to instance of @p struct pios_thread * * @return stack usage in bytes * */uint32_t PIOS_Thread_Get_Stack_Usage(struct pios_thread *threadp){#if (INCLUDE_uxTaskGetStackHighWaterMark == 1)	/* @note: This will fail when FreeRTOS TCB structure changes. */	return uxTaskGetStackHighWaterMark((xTaskHandle)threadp->task_handle) * 4;#else	return 1024;#endif /* (INCLUDE_uxTaskGetStackHighWaterMark == 1) */}

	unsigned portBASE_TYPE MPU_uxTaskGetStackHighWaterMark( xTaskHandle xTask )	{	unsigned portBASE_TYPE uxReturn;    portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();		uxReturn = uxTaskGetStackHighWaterMark( xTask );        portRESET_PRIVILEGE( xRunningPrivileged );		return uxReturn;	}

/** * Update the status of all tasks */void TaskMonitorUpdateAll(void){#if defined(DIAGNOSTICS)	TaskInfoData data;	int n;	// Lock	xSemaphoreTakeRecursive(lock, portMAX_DELAY);#if ( configGENERATE_RUN_TIME_STATS == 1 )	uint32_t currentTime;	uint32_t deltaTime;		/*	 * Calculate the amount of elapsed run time between the last time we	 * measured and now. Scale so that we can convert task run times	 * directly to percentages.	 */	currentTime = portGET_RUN_TIME_COUNTER_VALUE();	deltaTime = ((currentTime - lastMonitorTime) / 100) ? : 1; /* avoid divide-by-zero if the interval is too small */	lastMonitorTime = currentTime;			#endif		// Update all task information	for (n = 0; n < TASKINFO_RUNNING_NUMELEM; ++n)	{		if (handles[n] != 0)		{			data.Running[n] = TASKINFO_RUNNING_TRUE;#if defined(ARCH_POSIX) || defined(ARCH_WIN32)			data.StackRemaining[n] = 10000;#else			data.StackRemaining[n] = uxTaskGetStackHighWaterMark(handles[n]) * 4;#if ( configGENERATE_RUN_TIME_STATS == 1 )			/* Generate run time stats */			data.RunningTime[n] = uxTaskGetRunTime(handles[n]) / deltaTime;			#endif#endif					}		else		{			data.Running[n] = TASKINFO_RUNNING_FALSE;			data.StackRemaining[n] = 0;			data.RunningTime[n] = 0;		}	}	// Update object	TaskInfoSet(&data);	// Done	xSemaphoreGiveRecursive(lock);#endif}

/***********************************************************************       _cbSendTaskList()**  Function description*    This function is part of the link between FreeRTOS and SYSVIEW.*    Called from SystemView when asked by the host, it uses SYSVIEW*    functions to send the entire task list to the host.*/static void _cbSendTaskList(void) {  unsigned n;  for (n = 0; n < _NumTasks; n++) {#if INCLUDE_uxTaskGetStackHighWaterMark // Report Task Stack High Watermark    _aTasks[n].uStackHighWaterMark = uxTaskGetStackHighWaterMark((TaskHandle_t)_aTasks[n].xHandle);#endif    SYSVIEW_SendTaskInfo((U32)_aTasks[n].xHandle, _aTasks[n].pcTaskName, (unsigned)_aTasks[n].uxCurrentPriority, (U32)_aTasks[n].pxStack, (unsigned)_aTasks[n].uStackHighWaterMark);  }}

void vOLEDTask( void *pvParameters ){    xOLEDMessage xMessage;    unsigned portLONG ulY, ulMaxY;    static portCHAR cMessage[ mainMAX_MSG_LEN ];    extern volatile unsigned portLONG ulMaxJitter;    unsigned portBASE_TYPE uxUnusedStackOnEntry;    const unsigned portCHAR *pucImage;// Functions to access the OLED.     void ( *vOLEDInit )( unsigned portLONG ) = NULL;    void ( *vOLEDStringDraw )( const portCHAR *, unsigned portLONG, unsigned portLONG, unsigned portCHAR ) = NULL;    void ( *vOLEDImageDraw )( const unsigned portCHAR *, unsigned portLONG, unsigned portLONG, unsigned portLONG, unsigned portLONG ) = NULL;    void ( *vOLEDClear )( void ) = NULL;        vOLEDInit = RIT128x96x4Init;    vOLEDStringDraw = RIT128x96x4StringDraw;    vOLEDImageDraw = RIT128x96x4ImageDraw;    vOLEDClear = RIT128x96x4Clear;    ulMaxY = mainMAX_ROWS_96;    pucImage = pucBasicBitmap;              // Just for demo purposes.    uxUnusedStackOnEntry = uxTaskGetStackHighWaterMark( NULL );      ulY = ulMaxY;        /* Initialise the OLED  */    vOLEDInit( ulSSI_FREQUENCY );	        while( 1 )    {      // Wait for a message to arrive that requires displaying.            xQueueReceive( xOLEDQueue, &xMessage, portMAX_DELAY );        // Write the message on the next available row.             ulY += mainCHARACTER_HEIGHT;      if( ulY >= ulMaxY )      {          ulY = mainCHARACTER_HEIGHT;          vOLEDClear();      }        // Display the message                              sprintf( cMessage, "%s", xMessage.pcMessage);            vOLEDStringDraw( cMessage, 0, ulY, mainFULL_SCALE );        }}

/******************************************************************************* * TASK: taskShutdownWatchdog * * DESCRIPTIONS: * Watchdog for auto shutdown. * This task should be killed if the touch screen is touched before timeout. * *******************************************************************************/void taskShutdownWatchdog (void *pvParameters){    portTickType xTimeoutPeriod;                while (1) {        // Read the stack watermark and record it if it's below threshold.        unsigned portBASE_TYPE uxHighWaterMark = uxTaskGetStackHighWaterMark(NULL);        if (uxHighWaterMark < MIN_STACK_WATERMARK) {            xSystemError.bStackLowError = 1;            // Only log it when the watermark value changed.            static portBASE_TYPE uxPreviousWatermark = 0;            if (uxHighWaterMark != uxPreviousWatermark) {                vLogStackWatermark("Shutdown Watchdog Task", (unsigned short)uxHighWaterMark);            }            uxPreviousWatermark = uxHighWaterMark;        }                            // Get the timeout period base on auto shutdown setting.        switch (eAutoShutdown) {            case AUTO_SHUTDOWN_1_MIN:   xTimeoutPeriod = 60000 / portTICK_RATE_MS;      break;            case AUTO_SHUTDOWN_5_MIN:   xTimeoutPeriod = 300000 / portTICK_RATE_MS;     break;            case AUTO_SHUTDOWN_10_MIN:  xTimeoutPeriod = 600000 / portTICK_RATE_MS;     break;            case AUTO_SHUTDOWN_20_MIN:  xTimeoutPeriod = 1200000 / portTICK_RATE_MS;    break;            case AUTO_SHUTDOWN_30_MIN:  xTimeoutPeriod = 1800000 / portTICK_RATE_MS;    break;            case AUTO_SHUTDOWN_60_MIN:  xTimeoutPeriod = 3600000 / portTICK_RATE_MS;    break;            case AUTO_SLEEP_NEVER:      xTimeoutPeriod = portMAX_DELAY;                 break;        }                                // Wait for timeout.        vTaskDelay(xTimeoutPeriod);                // After timeout, shut down if these conditions are met.        // - Bluetooth is not connected.        // - USB is not connected.        if ( (BT_CONNECTED == 0) &&             (xSystemState.bUsbMode == 0) ) {            // Shutting down.            vPowerOff();            vTaskSuspend(NULL);            // Program should stop here.        }                // Program will loop again if the shutdown conditions are not met.    }}

void uartadapter_tcp_control_server_handler(void *param){	unsigned short port = UA_CONTROL_SOCKET_PORT;		ua_printf(UA_DEBUG, "Uart Adapter: Start Tcp Control Server!");       uartadapter_tcpserver(port, 1);	#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)	ua_printf(UA_DEBUG, "Min available stack size of %s = %d * %d bytes", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));#endif	ua_printf(UA_DEBUG, "TCP: Tcp control server stopped!");	vTaskDelete(NULL);}

STATIC mp_obj_t machine_info(uint n_args, const mp_obj_t *args) {    // FreeRTOS info    {        printf("---------------------------------------------/n");        printf("FreeRTOS/n");        printf("---------------------------------------------/n");        printf("Total heap: %u/n", configTOTAL_HEAP_SIZE);        printf("Free heap: %u/n", xPortGetFreeHeapSize());        printf("MpTask min free stack: %u/n", (unsigned int)uxTaskGetStackHighWaterMark((TaskHandle_t)mpTaskHandle));        printf("ServersTask min free stack: %u/n", (unsigned int)uxTaskGetStackHighWaterMark((TaskHandle_t)svTaskHandle));        printf("SlTask min free stack: %u/n", (unsigned int)uxTaskGetStackHighWaterMark(xSimpleLinkSpawnTaskHndl));        printf("IdleTask min free stack: %u/n", (unsigned int)uxTaskGetStackHighWaterMark(xTaskGetIdleTaskHandle()));        uint32_t *pstack = (uint32_t *)&_stack;        while (*pstack == 0x55555555) {            pstack++;        }        printf("MAIN min free stack: %u/n", pstack - ((uint32_t *)&_stack));        printf("---------------------------------------------/n");    }    return mp_const_none;}

/** * Callback for tcpip_init() */static void tcpip_init_cb(void *args){/*{{{*/    ip_addr_t ip_addr;    ip_addr_t netmask;    ip_addr_t gw_addr;    BaseType_t retval;    eth_int_q_handle = xQueueCreate(1, sizeof(uint32_t));    retval = xTaskCreate( eth_int_task,            "eth_int",            ETH_INT_STACK,            NULL,            tskIDLE_PRIORITY+ETH_PRIO,            &eth_int_task_handle);    LOOP_ERRMSG(retval != pdPASS, "Could not start lwip eth_int task/n" );#if XBH_IP4_STATIC    ip_addr.addr = htonl(XBH_IP4_ADDR);    netmask.addr = htonl(XBH_IP4_NETMASK);    gw_addr.addr = 0;#else    ip_addr.addr = 0;    netmask.addr = 0;    gw_addr.addr = 0;#endif    netif_add(&lwip_netif, &ip_addr, &netmask, &gw_addr, NULL, tivaif_init,            tcpip_input);    //netif_add sets everything to defaults, so run after netif_add    netif_set_hostname(&lwip_netif, XBH_HOSTNAME);    netif_set_status_callback(&lwip_netif, link_status);    netif_set_default(&lwip_netif);#if LWIP_IPV6    lwip_netif.ip6_autoconfig_enabled = 1;    lwip_netif.output_ip6 = ethip6_output;    //IPv6, enable linklocal addresses and SLAAC    netif_create_ip6_linklocal_address(&lwip_netif, 1);    netif_ip6_addr_set_state((&lwip_netif), 0, IP6_ADDR_TENTATIVE); #endif#if XBH_IP4_STATIC    netif_set_up(&lwip_netif);#else    dhcp_start(&lwip_netif);#endif    #if DEBUG_STACK    DEBUG_OUT("Stack Usage: %s: %d/n", __PRETTY_FUNCTION__, uxTaskGetStackHighWaterMark(NULL));#endif}/*}}}*/

void Udpserverhandler(void *param){	/*here gives the udp demo code*/	vTaskDelay(1000);	printf("/n/rUdp server test");		udpserver();	#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)	printf("/n/rMin available stack size of %s = %d * %d bytes", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));#endif	printf("/n/rUDP: udp client stopped!");	udpserver_task = NULL;	vTaskDelete(NULL);	}

void cek_stack(void){	printf("Sisa stack masing2 task (bytes)/r/n");	garis_bawah();	printf(" Shell    : %d/r/n", uxTaskGetStackHighWaterMark(hdl_shell));	printf(" Led      : %d/r/n", uxTaskGetStackHighWaterMark(hdl_led));		#ifdef BOARD_TAMPILAN	//#ifdef CARI_SUMBERNYA	printf(" Tampilan : %d/r/n", uxTaskGetStackHighWaterMark(hdl_tampilan));	printf(" LCD      : %d/r/n", uxTaskGetStackHighWaterMark(hdl_lcd));	#endif		#if (TAMPILAN_MALINGPING == 1)	//extern xTaskHandle hdl_proses_pm;  matikan dulu, pm belum diaktifkan		printf(" Tampilan : %d/r/n", uxTaskGetStackHighWaterMark(hdl_tampilan));	printf(" LCD      : %d/r/n", uxTaskGetStackHighWaterMark(hdl_lcd));	#endif		printf(" Ether    : %d/r/n", uxTaskGetStackHighWaterMark(hdl_ether));	#ifdef PAKAI_SELENOID		printf(" Relay    : %d/r/n", uxTaskGetStackHighWaterMark(hdl_relay));	#endif			#if defined(PAKAI_GSM_FTP) || defined(PAKAI_SMS)		printf(" GSM      : %d/r/n", uxTaskGetStackHighWaterMark(hdl_modem));	#endif		#ifdef PAKAI_CRON		printf(" CRON     : %d/r/n", uxTaskGetStackHighWaterMark(hdl_cron));	#endif		#ifdef AMBIL_PM//		printf(" Proses PM: %d/r/n", uxTaskGetStackHighWaterMark(hdl_proses_pm));	#endif}							 

static void TcpClientHandler(void *param){	unsigned short port = 5001;	vTaskDelay(1000);	printf("/n/rTCP: Start tcp client!");	if(g_start_client)		BsdTcpClient(g_server_ip, port);		#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)	printf("/n/rMin available stack size of %s = %d * %d bytes/n/r", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));#endif	printf("/n/rTCP: Tcp client stopped!");	g_client_task = NULL;	vTaskDelete(NULL);}

static inline void mqtt_task(){    struct Network network;    char client_id[20];    uint8_t mqtt_buf[100];    uint8_t mqtt_readbuf[100];    MQTTPacket_connectData data = MQTTPacket_connectData_initializer;    NewNetwork( &network );    strcpy(client_id, "esp-gizmo-ir");    if (ConnectNetwork(&network, config_get_mqtt_host(),                config_get_mqtt_port()) != 0) {        printf("Connect to MQTT server failed/n");        return;    }    NewMQTTClient(&mqtt_client, &network, 5000, mqtt_buf, 100, mqtt_readbuf, 100);    data.willFlag       = 0;    data.MQTTVersion    = 3;    data.clientID.cstring   = client_id;    data.username.cstring   = NULL;    data.password.cstring   = NULL;    data.keepAliveInterval  = 10;    data.cleansession   = 0;    printf("Send MQTT connect ... /n");    if (MQTTConnect(&mqtt_client, &data) != 0) {        printf("MQTT connect failed/n");        return;    }    const char *topic = config_get_cmd_topic();    printf("Sibscribe to topic: %s/n", topic);    if (MQTTSubscribe(&mqtt_client, topic, QOS1, topic_received) != 0) {        printf("Subscription failed/n");        return;    }    while (MQTTYield(&mqtt_client, 1000) != DISCONNECTED) {        printf("free heap: %d bytes/n", xPortGetFreeHeapSize());        uint16_t free_stack = uxTaskGetStackHighWaterMark(xTaskGetCurrentTaskHandle());        printf("minimum free stack: %d bytes/n", free_stack);    };    printf("Connection dropped, request restart/n");}

void TcpServerHandler_test(void *param){	unsigned short port = 5555;	vTaskDelay(10000);	printf("/n/rTCP: Start tcp Server!");        g_start_server = 1;	if(g_start_server)		BsdTcpServer(port);	#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)	printf("/n/rMin available stack size of %s = %d * %d bytes/n/r", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));#endif	printf("/n/rTCP: Tcp server stopped!");	g_server_task = NULL;	vTaskDelete(NULL);}

void TaskBase::print_status (emstream& ser_dev){	ser_dev.puts (pcTaskGetTaskName (handle));	ser_dev.putchar ('/t');	if (strlen ((const char*)(pcTaskGetTaskName (handle))) < 8)	{		ser_dev.putchar ('/t');	}	ser_dev << (uint8_t)(uxTaskPriorityGet (handle)) << PMS ("/t")			<< get_state ()		#if (INCLUDE_uxTaskGetStackHighWaterMark == 1)			<< PMS ("/t") << uxTaskGetStackHighWaterMark(handle) << PMS ("/") 			<< (size_t)(get_total_stack ()) << PMS ("/t")		#endif			<< PMS ("/t") << runs;}

void vDTMFDetectTask( void *pvParameters ) {	struct DTMFDetectTaskParam_t* params = (struct DTMFDetectTaskParam_t *)pvParameters;	char output[50];	vPrintString( "DTMF Detector started/n" );	init_Wn();	for( ;; )	{		BaseType_t status = xQueuePeek( params->sampQ, &s, portMAX_DELAY );		if(status == pdPASS) {#ifdef __DTMF_PERF__		UBaseType_t stack_max = uxTaskGetStackHighWaterMark( 0 );		TickType_t t0 = xTaskGetTickCount();		TickType_t t1;#endif			int ii;			for (ii=0; ii<DTMFSampleSize; ii++) {				cs[ii].Re = (float)s[ii] / 16384.0f;				cs[ii].Im = 0.0f;			}			xQueueReceive( params->sampQ, &s, portMAX_DELAY );			/* Do real work here */			fft(cs, DTMFSampleSize); // Need to ensure second arg is log2(DTMFSampleSize)			pick_peaks(cs, 5.0f, &r.toneA, &r.toneB);			r.code = decode_tones(r.toneA,r.toneB);#ifdef __DTMF_PERF__		t1 = xTaskGetTickCount();		printf("DTMF STACK %d TIME %d/n", stack_max, t1-t0);#endif			// Send, but allow dropping			if(r.code != ' ')			{				sprintf(output,"Detected code %c/r/n",r.code);				uart_send_noblock(output,strlen(output));				printf("Detected code %c/n",r.code);			}		}	}}

static void tcp_server_handler(void *param){    vTaskDelay(100);    if(tcp_server_data.port == 0)        tcp_server_data.port = DEFAULT_PORT;    if(tcp_server_data.buf_size == 0)        tcp_server_data.buf_size = SERVER_BUF_SIZE;    printf("/n/rTCP: Start TCP server!");    tcp_server_func(tcp_server_data);#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)    printf("/n/rMin available stack size of %s = %d * %d bytes/n/r", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));#endif    printf("/n/rTCP: TCP server stopped!");    g_tcp_server_task = NULL;    vTaskDelete(NULL);}

void detect_task(void const *argu){  uint32_t detect_wake_time = osKernelSysTick();  while(1)  {    detect_time_ms = HAL_GetTick() - detect_time_last;    detect_time_last = HAL_GetTick();        /* module offline detect */    module_offline_detect();        if (glb_err_exit == 1)    {      if (pc_glb_cnt++ > 50)        pc_glb_cnt = 0;            if (pc_glb_cnt < 15)        g_err.beep_ctrl = g_err.beep_tune/2;      else        g_err.beep_ctrl = 0;    }    else    {      if (g_err.err_now != NULL)      {        //LED_G_OFF;        module_offline_callback();      }      else      {        g_err.beep_ctrl = 0;        //LED_G_ON;      }    }        beep_ctrl(g_err.beep_tune, g_err.beep_ctrl);        detect_stack_surplus = uxTaskGetStackHighWaterMark(NULL);        osDelayUntil(&detect_wake_time, DETECT_TASK_PERIOD);  }}

/*---------------------------------------------------------------------------------------------------------*/static void SW_UART_WRAPPER_Send_Task( void *aHandle ){	uint8_t *pData;	xMessage_t xRxMessage;	os_queue_t xQueue ;	xQueue = os_create_queue( SW_UART_WRAPPER_CONFIG_MAX_QUEUE_LEN , sizeof(xMessage_t ) );	INSTANCE(aHandle)->xQueue = xQueue ;	if( 0 == xQueue  ) return ;	for( ;; )	{		if( OS_QUEUE_RECEIVE_SUCCESS == os_queue_receive_infinite_wait( xQueue , &( xRxMessage )) )		{			pData = xRxMessage.pData;			sw_uart_send_and_wait_for_end(INSTANCE(aHandle), os_delay_ms,pData,xRxMessage.len);#ifdef SW_UART_WRAPPER_CONFIG_USE_MALLOC			free( pData );#endif		}#if ((1==INCLUDE_uxTaskGetStackHighWaterMark ) && (1==OS_FREE_RTOS))		{			static  size_t stackLeft,minStackLeft=0xffffffff;			stackLeft = uxTaskGetStackHighWaterMark( NULL );			if(minStackLeft > stackLeft)			{				minStackLeft = stackLeft;				PRINTF_DBG("%s   stack left = %d  /r/n" ,						__FUNCTION__   ,minStackLeft);			}		}#endif	}}

	void vShowAllTaskUnusedStack(void)	{		unsigned portSHORT usIndex;		vDebugPrint(&TaskTokens[TASK_COMMAND],					"********** Unused Stack Table ***********/n/r",					0, 0, 0);		for (usIndex = 0; usIndex < NUM_TASKID; usIndex++)		{			if (TaskTokens[usIndex].pcTaskName != NULL)			{				vDebugPrint(&TaskTokens[TASK_COMMAND],							"%16s/t/t%d/n/r",							(unsigned portLONG)TaskTokens[usIndex].pcTaskName,							(unsigned portLONG)uxTaskGetStackHighWaterMark(TaskHandles[usIndex]),0);			}		}	}

void UTL_FreeRtosTaskStackCheck(void){  taskInfoArray[PrintTaskIndex].FreeEntries =     uxTaskGetStackHighWaterMark(taskInfoArray[PrintTaskIndex].taskHandle);    /* free, used, total */  PrintF("%s %d %d %d",    (char*)pcTaskGetTaskName(taskInfoArray[PrintTaskIndex].taskHandle),     taskInfoArray[PrintTaskIndex].FreeEntries,     taskInfoArray[PrintTaskIndex].Depth - taskInfoArray[PrintTaskIndex].FreeEntries,     taskInfoArray[PrintTaskIndex].Depth));                 PrintTaskIndex ++;  if (rintTaskIndex >= TaskIndex)  {    PrintTaskIndex = 3;        CreateAndSendMessage(&Msg, QueryMemoryMsg, MSG_OPT_NONE);  }}

static void prvTaskToDelete( void *pvParameters ){	/* Remove compiler warnings about unused parameters. */	( void ) pvParameters;	/* Check the enter and exit critical macros are working correctly.  If the	SVC priority is below configMAX_SYSCALL_INTERRUPT_PRIORITY then this will	fault. */	taskENTER_CRITICAL();	taskEXIT_CRITICAL();	/* Exercise the API of various RTOS objects. */	prvExerciseEventGroupAPI();	prvExerciseSemaphoreAPI();	prvExerciseTaskNotificationAPI();	/* For code coverage test purposes it is deleted by the Idle task. */	configASSERT( uxTaskGetStackHighWaterMark( NULL ) > 0 );	vTaskSuspend( NULL );}

void print_task_list (emstream* ser_dev){	// Print the first line with the top of the headings	*ser_dev << PMS ("Task/t/t  /t ")		#if (INCLUDE_uxTaskGetStackHighWaterMark == 1)			<< PMS ("/tStack")		#endif			<< endl;	// Print the second line with the rest of the headings	*ser_dev << PMS ("Name/t/tPri./tState")		#if (INCLUDE_uxTaskGetStackHighWaterMark == 1)			<< PMS ("/tFree/Total")		#endif			<< PMS ("/tRuns") << endl;	// Print the third line which shows separators between headers and data	*ser_dev << PMS ("----/t/t----/t-----")		#if (INCLUDE_uxTaskGetStackHighWaterMark == 1)			<< PMS ("/t----------")		#endif			<< PMS ("/t----") << endl;	// Now have the tasks each print out their status. Tasks form a linked list, so	// we only need to get the last task started and it will call the next, etc.	if (last_created_task_pointer != NULL)	{		last_created_task_pointer->print_status_in_list (ser_dev);	}	// Have the idle task print out its information	*ser_dev << PMS ("IDLE/t/t0/t-/t")		#if (INCLUDE_uxTaskGetStackHighWaterMark == 1)			<< uxTaskGetStackHighWaterMark (xTaskGetIdleTaskHandle ())			<< PMS ("/") << configMINIMAL_STACK_SIZE << PMS ("/t/t")		#endif		#ifdef TASK_SETUP_AND_LOOP			<< PMS ("-")		#endif			<< endl;}

/** * Task for feeding packets from ISR to lwIP * Loops forever blocking on queue waiting for next status from ISR * @param arg Unused */static void eth_int_task(void* arg){/*{{{*/    uint32_t status;    while(1){        //Loop waiting max time between loops until queue item received        while(xQueueReceive(eth_int_q_handle, &status, portMAX_DELAY)!=pdPASS);        tivaif_interrupt(&lwip_netif, status);        // Reenable interrupts disabled in lwIP_eth_isr()        MAP_EMACIntEnable(EMAC0_BASE, (EMAC_INT_PHY|                    EMAC_INT_RECEIVE|                    EMAC_INT_RX_NO_BUFFER|                    EMAC_INT_RX_STOPPED|                    EMAC_INT_TRANSMIT|                    EMAC_INT_TX_STOPPED));#if DEBUG_STACK        DEBUG_OUT("Stack Usage: %s: %d/n", __PRETTY_FUNCTION__, uxTaskGetStackHighWaterMark(NULL));#endif    }}/*}}}*/