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
}
}