Macros
#define	TX_THREAD_ID ((ULONG) 0x54485244)
	ThreadX Component More...

#define	TX_THREAD_PRIORITY_GROUP_MASK ((ULONG) 0xFF)

#define	TX_THREAD_EXECUTE_LOG_SIZE ((UINT) 8)

#define	MAP_INDEX (0)

#define	TX_MOD32_BIT_SET(a, b) (b) = (((ULONG) 1) << ((a)));

#define	TX_THREAD_STATE_CHANGE(a, b)

#define	TX_THREAD_GET_CURRENT(a) (a) = _tx_thread_current_ptr;

#define	TX_THREAD_SET_CURRENT(a) _tx_thread_current_ptr = (a);

#define	TX_THREAD_SYSTEM_RETURN_CHECK(c) (c) = (ULONG) _tx_thread_preempt_disable; (c) = (c) \| TX_THREAD_GET_SYSTEM_STATE();

#define	TX_THREAD_CREATE_TIMEOUT_SETUP(t)

#define	TX_THREAD_TIMEOUT_POINTER_SETUP(t) (t) = TX_ULONG_TO_THREAD_POINTER_CONVERT(timeout_input);

#define	TX_LOWEST_SET_BIT_CALCULATE(m, b)

#define	TX_THREAD_STACK_CHECK(thread_ptr)

#define	TX_THREAD_DELETE_PORT_COMPLETION(t)

#define	TX_THREAD_RESET_PORT_COMPLETION(t)

#define	TX_THREAD_CREATE_INTERNAL_EXTENSION(t)

#define	THREAD_DECLARE extern

Functions
VOID	_tx_thread_initialize (VOID)

VOID	_tx_thread_schedule (VOID)

VOID	_tx_thread_shell_entry (VOID)

VOID	_tx_thread_stack_analyze (TX_THREAD *thread_ptr)

VOID	_tx_thread_stack_build (TX_THREAD thread_ptr, VOID(function_ptr)(VOID))

VOID	_tx_thread_stack_error (TX_THREAD *thread_ptr)

VOID	_tx_thread_stack_error_handler (TX_THREAD *thread_ptr)

VOID	_tx_thread_system_preempt_check (VOID)

VOID	_tx_thread_system_resume (TX_THREAD *thread_ptr)

VOID	_tx_thread_system_ni_resume (TX_THREAD *thread_ptr)

VOID	_tx_thread_system_return (VOID)

VOID	_tx_thread_system_suspend (TX_THREAD *thread_ptr)

VOID	_tx_thread_system_ni_suspend (TX_THREAD *thread_ptr, ULONG wait_option)

VOID	_tx_thread_time_slice (VOID)

VOID	_tx_thread_timeout (ULONG timeout_input)

Macro Definition Documentation

◆ MAP_INDEX

#define MAP_INDEX (0)

◆ THREAD_DECLARE

#define THREAD_DECLARE extern

◆ TX_LOWEST_SET_BIT_CALCULATE

#define TX_LOWEST_SET_BIT_CALCULATE	(	m,
		b
	)

◆ TX_MOD32_BIT_SET

#define TX_MOD32_BIT_SET	(	a,
		b
	)	(b) = (((ULONG) 1) << ((a)));

◆ TX_THREAD_CREATE_INTERNAL_EXTENSION

#define TX_THREAD_CREATE_INTERNAL_EXTENSION ( t )

◆ TX_THREAD_CREATE_TIMEOUT_SETUP

#define TX_THREAD_CREATE_TIMEOUT_SETUP ( t )

Value:

(t) -> tx_thread_timer.tx_timer_internal_timeout_function = &(_tx_thread_timeout); \

(t) -> tx_thread_timer.tx_timer_internal_timeout_param = TX_POINTER_TO_ULONG_CONVERT((t));

TX_POINTER_TO_ULONG_CONVERT

#define TX_POINTER_TO_ULONG_CONVERT(a)

Definition: tx_api.h:1933

_tx_thread_timeout

VOID _tx_thread_timeout(ULONG timeout_input)

◆ TX_THREAD_DELETE_PORT_COMPLETION

#define TX_THREAD_DELETE_PORT_COMPLETION ( t )

◆ TX_THREAD_EXECUTE_LOG_SIZE

#define TX_THREAD_EXECUTE_LOG_SIZE ((UINT) 8)

◆ TX_THREAD_GET_CURRENT

#define TX_THREAD_GET_CURRENT ( a ) (a) = _tx_thread_current_ptr;

◆ TX_THREAD_ID

#define TX_THREAD_ID ((ULONG) 0x54485244)

ThreadX Component

Thread

◆ TX_THREAD_PRIORITY_GROUP_MASK

#define TX_THREAD_PRIORITY_GROUP_MASK ((ULONG) 0xFF)

◆ TX_THREAD_RESET_PORT_COMPLETION

#define TX_THREAD_RESET_PORT_COMPLETION ( t )

◆ TX_THREAD_SET_CURRENT

#define TX_THREAD_SET_CURRENT ( a ) _tx_thread_current_ptr = (a);

◆ TX_THREAD_STACK_CHECK

#define TX_THREAD_STACK_CHECK ( thread_ptr )

Value:

    {                                                                                                                           \
    TX_INTERRUPT_SAVE_AREA                                                                                                      \
        TX_DISABLE                                                                                                              \
        if (((thread_ptr)) && ((thread_ptr) -> tx_thread_id == TX_THREAD_ID))                                                   \
        {                                                                                                                       \
            if (((ULONG *) (thread_ptr) -> tx_thread_stack_ptr) < ((ULONG *) (thread_ptr) -> tx_thread_stack_highest_ptr))      \
            {                                                                                                                   \
                (thread_ptr) -> tx_thread_stack_highest_ptr =  (thread_ptr) -> tx_thread_stack_ptr;                             \
            }                                                                                                                   \
            if ((*((ULONG *) (thread_ptr) -> tx_thread_stack_start) != TX_STACK_FILL) ||                                        \
                (*((ULONG *) (((UCHAR *) (thread_ptr) -> tx_thread_stack_end) + 1)) != TX_STACK_FILL) ||                        \
                (((ULONG *) (thread_ptr) -> tx_thread_stack_highest_ptr) < ((ULONG *) (thread_ptr) -> tx_thread_stack_start)))  \
            {                                                                                                                   \
                TX_RESTORE                                                                                                      \
                _tx_thread_stack_error_handler((thread_ptr));                                                                   \
                TX_DISABLE                                                                                                      \
            }                                                                                                                   \
            if (*(((ULONG *) (thread_ptr) -> tx_thread_stack_highest_ptr) - 1) != TX_STACK_FILL)                                \
            {                                                                                                                   \
                TX_RESTORE                                                                                                      \
                _tx_thread_stack_analyze((thread_ptr));                                                                         \
                TX_DISABLE                                                                                                      \
            }                                                                                                                   \
        }                                                                                                                       \
        TX_RESTORE                                                                                                              \
    }

◆ TX_THREAD_STATE_CHANGE

#define TX_THREAD_STATE_CHANGE	(	a,
		b
	)

◆ TX_THREAD_SYSTEM_RETURN_CHECK

#define TX_THREAD_SYSTEM_RETURN_CHECK ( c ) (c) = (ULONG) _tx_thread_preempt_disable; (c) = (c) | TX_THREAD_GET_SYSTEM_STATE();

◆ TX_THREAD_TIMEOUT_POINTER_SETUP

#define TX_THREAD_TIMEOUT_POINTER_SETUP ( t ) (t) = TX_ULONG_TO_THREAD_POINTER_CONVERT(timeout_input);

Function Documentation

◆ _tx_thread_initialize()

VOID _tx_thread_initialize ( VOID )

◆ _tx_thread_schedule()

VOID _tx_thread_schedule ( VOID )

◆ _tx_thread_shell_entry()

VOID _tx_thread_shell_entry ( VOID )

◆ _tx_thread_stack_analyze()

VOID _tx_thread_stack_analyze ( TX_THREAD * thread_ptr )

◆ _tx_thread_stack_build()

VOID _tx_thread_stack_build	(	TX_THREAD *	thread_ptr,
		VOID(*)(VOID)	function_ptr
	)

◆ _tx_thread_stack_error()

VOID _tx_thread_stack_error ( TX_THREAD * thread_ptr )

◆ _tx_thread_stack_error_handler()

VOID _tx_thread_stack_error_handler ( TX_THREAD * thread_ptr )

◆ _tx_thread_system_ni_resume()

VOID _tx_thread_system_ni_resume ( TX_THREAD * thread_ptr )

◆ _tx_thread_system_ni_suspend()

VOID _tx_thread_system_ni_suspend	(	TX_THREAD *	thread_ptr,
		ULONG	wait_option
	)

◆ _tx_thread_system_preempt_check()

VOID _tx_thread_system_preempt_check ( VOID )

◆ _tx_thread_system_resume()

VOID _tx_thread_system_resume ( TX_THREAD * thread_ptr )

◆ _tx_thread_system_return()

VOID _tx_thread_system_return ( VOID )

◆ _tx_thread_system_suspend()

VOID _tx_thread_system_suspend ( TX_THREAD * thread_ptr )

◆ _tx_thread_time_slice()

VOID _tx_thread_time_slice ( VOID )

◆ _tx_thread_timeout()

VOID _tx_thread_timeout ( ULONG timeout_input )

Variable Documentation

◆ _tx_build_options

THREAD_DECLARE ULONG _tx_build_options

◆ _tx_thread_created_count

THREAD_DECLARE ULONG _tx_thread_created_count

◆ _tx_thread_created_ptr

THREAD_DECLARE TX_THREAD* _tx_thread_created_ptr

◆ _tx_thread_current_ptr

THREAD_DECLARE TX_THREAD* _tx_thread_current_ptr

◆ _tx_thread_execute_ptr

THREAD_DECLARE TX_THREAD* _tx_thread_execute_ptr

◆ _tx_thread_highest_priority

THREAD_DECLARE UINT _tx_thread_highest_priority

◆ _tx_thread_mutex_release

THREAD_DECLARE VOID(* _tx_thread_mutex_release) (TX_THREAD *thread_ptr) ( TX_THREAD * thread_ptr )

◆ _tx_thread_preempt_disable

THREAD_DECLARE volatile UINT _tx_thread_preempt_disable

◆ _tx_thread_preempted_maps

THREAD_DECLARE ULONG _tx_thread_preempted_maps[TX_MAX_PRIORITIES/32]

◆ _tx_thread_priority_list

THREAD_DECLARE TX_THREAD* _tx_thread_priority_list[TX_MAX_PRIORITIES]

◆ _tx_thread_priority_maps

THREAD_DECLARE ULONG _tx_thread_priority_maps[TX_MAX_PRIORITIES/32]

◆ _tx_thread_system_stack_ptr

THREAD_DECLARE VOID* _tx_thread_system_stack_ptr

◆ _tx_thread_system_state

THREAD_DECLARE volatile ULONG _tx_thread_system_state

Variables
THREAD_DECLARE VOID *	_tx_thread_system_stack_ptr

THREAD_DECLARE TX_THREAD *	_tx_thread_current_ptr

THREAD_DECLARE TX_THREAD *	_tx_thread_execute_ptr

THREAD_DECLARE TX_THREAD *	_tx_thread_created_ptr

THREAD_DECLARE ULONG	_tx_thread_created_count

THREAD_DECLARE volatile ULONG	_tx_thread_system_state

THREAD_DECLARE ULONG	_tx_thread_priority_maps [TX_MAX_PRIORITIES/32]

THREAD_DECLARE ULONG	_tx_thread_preempted_maps [TX_MAX_PRIORITIES/32]

THREAD_DECLARE UINT	_tx_thread_highest_priority

THREAD_DECLARE TX_THREAD *	_tx_thread_priority_list [TX_MAX_PRIORITIES]

THREAD_DECLARE volatile UINT	_tx_thread_preempt_disable

THREAD_DECLARE VOID(*	_tx_thread_mutex_release )(TX_THREAD *thread_ptr)

THREAD_DECLARE ULONG	_tx_build_options

Macros

Functions

Variables