If tx_semaphore_get() returns TX_NO_INSTANCE, the immediate call to tx_thread_sleep() also returns TX_NO_INSTANCE after the sleep duration even though the sleep is called from thread context. #433

void test_thread()
{
    while (1) {
        /* do something */

        rc_loc = tx_semaphore_get(sem_ptr, TX_WAIT_FOREVER); 
        printf("ret = %x", rc_loc);                             /* Prints - "ret = 0" => TX_SUCCESS - once semaphore is available */
        rc_loc = tx_thread_sleep(100);
        printf("ret = %x", rc_loc);                             /* Prints - "ret = 0" => TX_SUCCESS - after sleeping for 100 ticks*/

        rc_loc = tx_semaphore_get(sem_ptr, TX_NO_WAIT); 
        printf("ret = %x", rc_loc);                             /* Prints - "ret = D" => TX_NO_INSTANCE - immediatedly when there is no semaphore */
        rc_loc = tx_thread_sleep(100);
        printf("ret = %x", rc_loc);                             /* Prints - "ret = 0" => TX_SUCCESS - after sleeping for 100 ticks*/

        rc_loc = tx_semaphore_get(sem_ptr, 10); 
        printf("ret = %x", rc_loc);                             /* Prints - "ret = D" => TX_NO_INSTANCE - after waiting for 10 ticks */
        rc_loc = tx_thread_sleep(100);
        printf("ret = %x", rc_loc);                             /* Prints - "ret = D" => TX_NO_INSTANCE - after sleeping for 100 ticks*/

        /* do something */
    }
}

            /* Set the state to suspended.  */
            thread_ptr -> tx_thread_state =    TX_SLEEP;

#ifdef TX_NOT_INTERRUPTABLE

            /* Call actual non-interruptable thread suspension routine.  */
            _tx_thread_system_ni_suspend(thread_ptr, timer_ticks);

            /* Restore interrupts.  */
            TX_RESTORE
#else

            /* Set the suspending flag. */
            thread_ptr -> tx_thread_suspending =  TX_TRUE;

            /* Initialize the status to successful.  */
            thread_ptr -> tx_thread_suspend_status =  TX_SUCCESS;

            /* Setup the timeout period.  */
            thread_ptr -> tx_thread_timer.tx_timer_internal_remaining_ticks =  timer_ticks;

            /* Temporarily disable preemption.  */
            _tx_thread_preempt_disable++;

            /* Restore interrupts.  */
            TX_RESTORE

            /* Call actual thread suspension routine.  */
            _tx_thread_system_suspend(thread_ptr);
#endif

            /* Return status to the caller.  */
            status =  thread_ptr -> tx_thread_suspend_status;
        }
    }

    /* Return completion status.  */
    return(status);
}

void test_thread()
{
    while (1) {
        /* do something */

        rc_loc = tx_semaphore_get(sem_ptr, 10); 
        printf("ret = %x", rc_loc);                             /* Prints - "ret = D" => TX_NO_INSTANCE - after waiting for 10 ticks */
        thread_ptr->tx_thread_suspend_status = TX_SUCCESS;
        printf("ret = %x", rc_loc);                             /* Prints - "ret = 0" => TX_SUCCESS - */
        rc_loc = tx_thread_sleep(100);
        printf("ret = %x", rc_loc);                             /* Prints - "ret = 0" => TX_SUCCESS - after sleeping for 100 ticks*/

        /* do something */
    }
}