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

	TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void )	{	TaskHandle_t xReturn;    BaseType_t xRunningPrivileged = prvRaisePrivilege();		xReturn = xTaskGetCurrentTaskHandle();        portRESET_PRIVILEGE( xRunningPrivileged );		return xReturn;	}

/**  * @brief  Stop Idle monitor  * @param  None  * @retval None  */void EndIdleMonitor (void){  if( xTaskGetCurrentTaskHandle() == xIdleHandle )  {    /* Store the handle to the idle task. */    osCPU_IdleSpentTime = xTaskGetTickCountFromISR() - osCPU_IdleStartTime;    osCPU_TotalIdleTime += osCPU_IdleSpentTime;  }}

	xTaskHandle MPU_xTaskGetCurrentTaskHandle( void )	{	xTaskHandle xReturn;    portBASE_TYPE xRunningPrivileged = prvRaisePrivilege();		xReturn = xTaskGetCurrentTaskHandle();        portRESET_PRIVILEGE( xRunningPrivileged );		return xReturn;	}

	TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void )	{	TaskHandle_t xReturn;	BaseType_t xRunningPrivileged = xPortRaisePrivilege();		xReturn = xTaskGetCurrentTaskHandle();		vPortResetPrivilege( xRunningPrivileged );		return xReturn;	}

void vPortForciblyEndThread( void *pxTaskToDelete ){xTaskHandle hTaskToDelete = ( xTaskHandle )pxTaskToDelete;pthread_t xTaskToDelete;pthread_t xTaskToResume;	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )	{		xTaskToDelete = prvGetThreadHandle( hTaskToDelete );		xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );		if ( xTaskToResume == xTaskToDelete )		{			/* This is a suicidal thread, need to select a different task to run. */			vTaskSwitchContext();			xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );		}		if ( pthread_self() != xTaskToDelete )		{			/* Cancelling a thread that is not me. */			if ( xTaskToDelete != ( pthread_t )NULL )			{				/* Send a signal to wake the task so that it definitely cancels. */				pthread_testcancel();				pthread_cancel( xTaskToDelete );				/* Pthread Clean-up function will note the cancellation. */			}			(void)pthread_mutex_unlock( &xSingleThreadMutex );		}		else		{			/* Resume the other thread. */			prvResumeThread( xTaskToResume );			/* Pthread Clean-up function will note the cancellation. */			/* Release the execution. */			uxCriticalNesting = 0;			vPortEnableInterrupts();			(void)pthread_mutex_unlock( &xSingleThreadMutex );			/* Commit suicide */			pthread_exit( (void *)1 );		}	}}

signed portBASE_TYPE xDoIOwnTheMutex( xMutexHandle pxMutex ){    portBASE_TYPE c;    portENTER_CRITICAL( );    c = pxMutex->pxOwner == xTaskGetCurrentTaskHandle( );    portEXIT_CRITICAL( );    return c;}

int *task_getCurrentIndex(){  int i;TaskHandle_t handle;  handle = xTaskGetCurrentTaskHandle();  for(i = 0; i < taskMax; i++){	if(RTOStasks[i].handle == handle){	  return i;	}  }  return NULL;}

void mp_thread_start(void) {    mp_thread_mutex_lock(&thread_mutex, 1);    for (thread_t *th = thread; th != NULL; th = th->next) {        if (th->id == xTaskGetCurrentTaskHandle()) {            th->ready = 1;            break;        }    }    mp_thread_mutex_unlock(&thread_mutex);}

void mp_thread_finish(void) {    mp_thread_mutex_lock(&thread_mutex, 1);    // TODO unlink from list    for (thread_t *th = thread; th != NULL; th = th->next) {        if (th->id == xTaskGetCurrentTaskHandle()) {            th->ready = 0;            break;        }    }    mp_thread_mutex_unlock(&thread_mutex);}

void *aos_task_getspecific(aos_task_key_t key){    AosStaticTask_t *task = (AosStaticTask_t *)xTaskGetCurrentTaskHandle();    if (key >= 4)        return NULL;    if (task->magic != AOS_MAGIC)        return NULL;    return task->keys[key];}

void vPortStartFirstTask( void ){	/* Initialise the critical nesting count ready for the first task. */	uxCriticalNesting = 0;	/* Start the first task. */	vPortEnableInterrupts();	/* Start the first task. */	prvResumeThread( prvGetThreadHandle( xTaskGetCurrentTaskHandle() ) );}

/**  * @brief  This function handles Hard Fault exception.  * @param  None  * @retval None  */void HardFault_Handler(void){#ifdef FREERTOS_CONFIG_H  CurrentTaskHandle = xTaskGetCurrentTaskHandle();  pNameCurrentTask = pcTaskGetTaskName(CurrentTaskHandle);    #endif    /* Go to infinite loop when Hard Fault exception occurs */  while (1)  {  }}

int aos_task_setspecific(aos_task_key_t key, void *vp){    AosStaticTask_t *task = (AosStaticTask_t *)xTaskGetCurrentTaskHandle();    if (key >= 4)        return -1;    if (task->magic != AOS_MAGIC)        return -1;    task->keys[key] = vp;    return 0;}

int mp_thread_gc_others(void) {/*    mp_thread_mutex_lock(&thread_mutex, 1);    for (thread_t *th = thread; th != NULL; th = th->next) {        gc_collect_root((void**)&th, 1);        gc_collect_root(&th->arg, 1); // probably not needed        if (th->id == xTaskGetCurrentTaskHandle()) {            continue;        }        if (!th->ready) {            continue;        }        gc_collect_root(th->stack, th->stack_len); // probably not needed    }    mp_thread_mutex_unlock(&thread_mutex);*/    int n_th = 0;    void **ptrs;    mp_state_thread_t *state;    mp_thread_mutex_lock(&thread_mutex, 1);    for (thread_t *th = thread; th != NULL; th = th->next) {        if (!th->ready) continue;                               // thread not ready		//if (th->type == THREAD_TYPE_SERVICE) continue;          // Only scan PYTHON threads        if (th->id == xTaskGetCurrentTaskHandle()) continue;    // Do not process the running thread        //state = (mp_state_thread_t *)th->state_thread;        n_th++;        // Mark the root pointers on thread        //gc_collect_root((void **)state->dict_locals, 1);        if (th->arg) {            // Mark the pointers on thread arguments            ptrs = (void**)(void*)&th->arg;            gc_collect_root(ptrs, 1);        }        #if MICROPY_ENABLE_PYSTACK        // Mark the pointers on thread pystack        //ptrs = (void**)(void*)state->pystack_start;        //gc_collect_root(ptrs, (state->pystack_cur - state->pystack_start) / sizeof(void*));        #endif        // If PyStack is used, no pointers to MPy heap are placed on tasks stack        #if !MICROPY_ENABLE_PYSTACK        // Mark the pointers on thread stack        //gc_collect_root(th->curr_sp, ((void *)state->stack_top - th->curr_sp) / sizeof(void*)); // probably not needed        #endif    }    mp_thread_mutex_unlock(&thread_mutex);    return n_th;	}

signed portBASE_TYPE xMutexTake( xMutexHandle pxMutex, portTickType xTicksToWait ){    portENTER_CRITICAL( );    if ( pxMutex->pxOwner == xTaskGetCurrentTaskHandle( ) )    {        pxMutex->uxCount++;        portEXIT_CRITICAL( );        return pdTRUE;    }    if ( ( xTicksToWait > ( portTickType ) 0 ) && ( pxMutex->pxOwner != NULL ) )    {        vTaskPlaceOnEventList( &( pxMutex->xTasksWaitingToTake ), xTicksToWait );        taskYIELD( );        if ( pxMutex->pxOwner == xTaskGetCurrentTaskHandle( ) )        {            pxMutex->uxCount = 1;            portEXIT_CRITICAL( );            return pdTRUE;        }        else        {            portEXIT_CRITICAL( );            return pdFALSE;        }    }    if ( pxMutex->pxOwner == NULL )    {        pxMutex->pxOwner = xTaskGetCurrentTaskHandle( );        pxMutex->uxCount = 1;        portEXIT_CRITICAL( );        return pdTRUE;    }    portEXIT_CRITICAL( );    return pdFALSE;}

void mp_thread_init(void) {    mp_thread_mutex_init(&thread_mutex);    mp_thread_set_state(&mp_state_ctx.thread);    // create first entry in linked list of all threads    thread = &thread_entry0;    thread->id = xTaskGetCurrentTaskHandle();    thread->ready = 1;    thread->arg = NULL;    thread->stack = mpTaskStack;    thread->stack_len = MICROPY_TASK_STACK_LEN;    thread->next = NULL;}

void mp_thread_init(void *stack, uint32_t stack_len) {    mp_thread_set_state(&mp_state_ctx.thread);    // create the first entry in the linked list of all threads    thread = &thread_entry0;    thread->id = xTaskGetCurrentTaskHandle();    thread->ready = 1;    thread->arg = NULL;    thread->stack = stack;    thread->stack_len = stack_len;    thread->next = NULL;    mp_thread_mutex_init(&thread_mutex);   // MP_THREAD_GIL_EXIT();}

void test_task_get_state(void* arg){    //Current task should return eRunning    TEST_ASSERT(eTaskGetState(xTaskGetCurrentTaskHandle()) == eRunning);    //Idle task of current core should return eReady    TEST_ASSERT(eTaskGetState(xTaskGetIdleTaskHandle()) == eReady);    //Blocked Task should return eBlocked    TEST_ASSERT(eTaskGetState(blocked_task_handle) == eBlocked);    //Suspended Task should return eSuspended    TEST_ASSERT(eTaskGetState(suspended_task_handle) == eSuspended);    xSemaphoreGive(done_sem);    vTaskDelete(NULL);}

void mp_thread_finish(void) {    mp_thread_mutex_lock(&thread_mutex, 1);    thread_t *th = thread;    thread_t *pre_th = NULL;    for (th = thread; th != NULL; th = th->next) {        if (th->id == xTaskGetCurrentTaskHandle()) {            th->ready = 0;            //mp_thread_delete(pre_th,th);//TODO:wether need to delete threand to free memory            break;        }        pre_th = th;    }    mp_thread_mutex_unlock(&thread_mutex);}

/* * Returns the thread control block for the currently active task. In case * of an error the functions returns NULL. */sys_thread_tsys_arch_thread_current( void ){    sys_tcb_t      *p = tasks;    xTaskHandle     pid = xTaskGetCurrentTaskHandle(  );    vPortEnterCritical(  );    while( ( p != NULL ) && ( p->pid != pid ) )    {        p = p->next;    }    vPortExitCritical(  );    return p;}

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 mp_thread_gc_others(void) {    mp_thread_mutex_lock(&thread_mutex, 1);    for (thread_t *th = thread; th != NULL; th = th->next) {        gc_collect_root((void**)&th, 1);        gc_collect_root(&th->arg, 1); // probably not needed        if (th->id == xTaskGetCurrentTaskHandle()) {            continue;        }        if (!th->ready) {            continue;        }        gc_collect_root(th->stack, th->stack_len); // probably not needed    }    mp_thread_mutex_unlock(&thread_mutex);}

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");}

uint CreatorThread_GetThreadID(CreatorThread self){    uint result = 0;    xTaskHandle currentTask;    if (self)    {        ThreadInfo *threadInfo = (ThreadInfo*)self;        currentTask = threadInfo->ThreadID;    }    else    {        currentTask = xTaskGetCurrentTaskHandle();    }    result = (uint)uxTaskGetTaskNumber(currentTask);    return result;}

void vSerialPutString( xComPortHandle pxPort, const signed char * const pcString, unsigned short usStringLength ){const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 150UL );	( void ) pxPort;	/* Note this is the currently sending task. */	xUARTSendingTask = xTaskGetCurrentTaskHandle();	/* Output uxStringLength bytes starting from pcString. */	XUartLite_Send( &xUartLiteInstance, ( unsigned char * ) pcString, usStringLength );	/* Wait in the Blocked state (so not using any CPU time) for the Tx to	complete. */	ulTaskNotifyTake( pdTRUE, xMaxBlockTime );}

/* * Returns the thread control block for the currently active task. In case * of an error the functions returns NULL. */sys_tcb_t*sys_arch_thread_current( void ){	OS_SR_SAVE_VAR	sys_tcb_t      *p = tasks;	sys_thread_t   pid = xTaskGetCurrentTaskHandle();    // Enter Critical Section    OSEnterCritical();    while( ( p != NULL ) && ( p->pid != pid ) )    {        p = p->next;    }    // Exit Critical Section    OSExitCritical();    return p;}

void mp_thread_deinit(void) {    mp_thread_mutex_lock(&thread_mutex, 1);    for (thread_t *th = thread; th != NULL; th = th->next) {        // don't delete the current task        if (th->id == xTaskGetCurrentTaskHandle()) {            continue;        }        vTaskDelete(th->id);        // m_del_obj(thread_t,th);        free(th);    }    mp_thread_mutex_unlock(&thread_mutex);    // allow FreeRTOS to clean-up the threads    vTaskDelay(2);}

bool CreatorThread_SleepTicks(CreatorThread self, uint ticks){    bool result = false;    if (ticks > 0)    {        if (self)        {            ThreadInfo *threadInfo = (ThreadInfo*)self;            xTaskHandle currentTask = xTaskGetCurrentTaskHandle();            result = (currentTask == threadInfo->ThreadID);        }        else        result = true;        if (result)        vTaskDelay(ticks);    }    return result;}

int aos_task_key_create(aos_task_key_t *key){    AosStaticTask_t *task = (AosStaticTask_t *)xTaskGetCurrentTaskHandle();    int i;    if (task->magic != AOS_MAGIC)        return -1;    for (i=0;i<4;i++) {        if (task->key_bitmap & (1 << i))            continue;        task->key_bitmap |= 1 << i;        *key = i;        return 0;    }    return -1;}