Thread::State Thread::get_state() { #if !defined(__MBED_CMSIS_RTOS_CA9) && !defined(__MBED_CMSIS_RTOS_CM) #ifdef CMSIS_OS_RTX State status = Deleted; _mutex.lock(); if (_tid != NULL) { status = (State)_thread_def.tcb.state; } _mutex.unlock(); return status; #endif #else State status = Deleted; _mutex.lock(); if (_tid != NULL) { status = (State)osThreadGetState(_tid); } _mutex.unlock(); return status; #endif }
Thread::State Thread::get_state() { #ifndef __MBED_CMSIS_RTOS_CA9 return ((State)_thread_def.tcb.state); #else uint8_t status; status = osThreadGetState(_tid); return ((State)status); #endif }
/** * @brief Mutex Medium Priority Thread. * @param argument: Not used * @retval None */ static void MutexMeduimPriorityThread(void const *argument) { /* Just to remove compiler warning */ (void) argument; for(;;) { /* This thread will run while the high-priority thread is blocked, and the high-priority thread will block only once it has the mutex - therefore this call should block until the high-priority thread has given up the mutex, and not actually execute past this call until the high-priority thread is suspended. */ if(osMutexWait(osMutex, osWaitForever) == osOK) { if(osThreadGetState(osHighPriorityThreadHandle) != osThreadSuspended) { /* Did not expect to execute until the high priority thread was suspended. Toggle LED 3 to indicate error */ BSP_LED_Toggle(LED3); } else { /* Give the mutex back before suspending ourselves to allow the low priority thread to obtain the mutex. */ if(osMutexRelease(osMutex) != osOK) { /* Toggle LED 3 to indicate error */ BSP_LED_Toggle(LED3); } osThreadSuspend(NULL); } } else { /* We should not leave the osMutexWait() function until the mutex was obtained. Toggle LED 3 to indicate error */ BSP_LED_Toggle(LED3); } /* The High and Medium priority threads should be in lock step. */ if(HighPriorityThreadCycles != (MediumPriorityThreadCycles + 1)) { /* Toggle LED 3 to indicate error */ BSP_LED_Toggle(LED3); } /* Keep count of the number of cycles this task has performed so a stall can be detected. */ MediumPriorityThreadCycles++; BSP_LED_Toggle(LED2); } }
THREADAPI_RESULT ThreadAPI_Join(THREAD_HANDLE threadHandle, int *res) { if (threadHandle == NULL) { LogError("(result = %s)\r\n", ENUM_TO_STRING(THREADAPI_RESULT, THREADAPI_INVALID_ARG)); return THREADAPI_INVALID_ARG; } else { (*res) = *((int*)threadHandle); while(osThreadGetState(listTaskRTOSHandle[(*res)].threadId)==osThreadRunning)// { osDelay(10); } } return THREADAPI_OK; }
/** * @brief Mutex Low Priority Thread. * @param argument: Not used * @retval None */ static void MutexLowPriorityThread(void const *argument) { /* Just to remove compiler warning. */ (void) argument; for(;;) { /* Keep attempting to obtain the mutex. We should only obtain it when the medium-priority thread has suspended itself, which in turn should only happen when the high-priority thread is also suspended. */ if(osMutexWait(osMutex, mutexNO_DELAY) == osOK) { /* Is the haigh and medium-priority threads suspended? */ if((osThreadGetState(osHighPriorityThreadHandle) != osThreadSuspended) || (osThreadGetState(osMediumPriorityThreadHandle) != osThreadSuspended)) { /* Toggle LED 3 to indicate error */ BSP_LED_Toggle(LED3); } else { /* Keep count of the number of cycles this task has performed so a stall can be detected. */ LowPriorityThreadCycles++; BSP_LED_Toggle(LED4); /* We can resume the other tasks here even though they have a higher priority than the this thread. When they execute they will attempt to obtain the mutex but fail because the low-priority thread is still the mutex holder. this thread will then inherit the higher priority. The medium-priority thread will block indefinitely when it attempts to obtain the mutex, the high-priority thread will only block for a fixed period and an error will be latched if the high-priority thread has not returned the mutex by the time this fixed period has expired. */ osThreadResume(osMediumPriorityThreadHandle); osThreadResume(osHighPriorityThreadHandle); /* The other two tasks should now have executed and no longer be suspended. */ if((osThreadGetState(osHighPriorityThreadHandle) == osThreadSuspended) || (osThreadGetState(osMediumPriorityThreadHandle) == osThreadSuspended)) { /* Toggle LED 3 to indicate error */ BSP_LED_Toggle(LED3); } /* Release the mutex, disinheriting the higher priority again. */ if(osMutexRelease(osMutex) != osOK) { /* Toggle LED 3 to indicate error */ BSP_LED_Toggle(LED3); } } } #if configUSE_PREEMPTION == 0 { taskYIELD(); } #endif } }