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; }
char *task_getCurrentName(){ int i;TaskHandle_t handle; handle = xTaskGetCurrentTaskHandle(); for(i = 0; i < taskMax; i++){ if(RTOStasks[i].handle == handle){ return RTOStasks[i].name; } } 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_t sys_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; }