Express Logic Embedded RTOS Solutions Express Logic RTOS Embedded Solutions Partners ThreadX RTOS Real-Time Preemption Threshold TCP/IP White Papers
The Real Time Operating Systems Solutions Company - RTOS
Express Logic RTOS Embedded Solutions
ThreadX
FileX
NetX
PegX
USBX
ThreadX and Embedded RTOS Training
Files to Download
Files to Download

 
 

ThreadX API - Version 4
Copyright © 1996-2005

Easy to Understand!

The goal behind ThreadX is to provide the very best deeply embedded RTOS technology in a manner that is easy to understand - and more importantly - easy to use!

This all starts with the ThreadX Application Interface (API). Considerable effort has been made to make the services intuitive and consistent. Please see for yourself! Below is a complete list of the ThreadX Version 4 API.

Please click here for the ThreadX V4 Programmer's Reference Guide


ThreadX Entry

VOID     tx_kernel_enter(VOID);


Byte Pool Memory Services

UINT    tx_byte_allocate(TX_BYTE_POOL *pool_ptr,
            VOID **memory_ptr,
            ULONG memory_size,
            ULONG wait_option);
UINT    tx_byte_pool_create(TX_BYTE_POOL *pool_ptr,
            CHAR *name_ptr,
            VOID *pool_start,
            ULONG pool_size);
UINT    tx_byte_pool_delete(TX_BYTE_POOL *pool_ptr);
UINT    tx_byte_pool_info_get(TX_BYTE_POOL *pool_ptr,
            CHAR **name,
            ULONG *available_bytes,
            ULONG *fragments,
            TX_THREAD **first_suspended,
            ULONG *suspended_count,
            TX_BYTE_POOL **next_pool);
UINT    tx_byte_pool_prioritize(TX_BYTE_POOL *pool_ptr);
UINT    tx_byte_release(VOID *memory_ptr);


Block Pool Memory Services

UINT    tx_block_allocate(TX_BLOCK_POOL *pool_ptr,
            VOID **block_ptr,
            ULONG wait_option);
UINT    tx_block_pool_create(TX_BLOCK_POOL *pool_ptr,
            CHAR *name_ptr,
            ULONG block_size,
            VOID *pool_start,
            ULONG pool_size);
UINT    tx_block_pool_delete(TX_BLOCK_POOL *pool_ptr);
UINT    tx_block_pool_info_get(TX_BLOCK_POOL *pool_ptr,
            CHAR **name,
            ULONG *available_blocks,
            ULONG *total_blocks,
            TX_THREAD **first_suspended,
            ULONG *suspended_count,
            TX_BLOCK_POOL **next_pool);
UINT    tx_block_pool_prioritize(TX_BLOCK_POOL *pool_ptr);
UINT    tx_block_release(VOID *block_ptr);


Event Flag Services

UINT    tx_event_flags_create(TX_EVENT_FLAGS_GROUP *group_ptr,
            CHAR *name_ptr);
UINT    tx_event_flags_delete(TX_EVENT_FLAGS_GROUP *group_ptr);
UINT    tx_event_flags_get(TX_EVENT_FLAGS_GROUP *group_ptr,
            ULONG requested_flags,
            UINT get_option,
            ULONG *actual_flags_ptr,
            ULONG wait_option);
UINT    tx_event_flags_info_get(TX_EVENT_FLAGS_GROUP *group_ptr,
            CHAR **name,
            ULONG *current_flags,
            TX_THREAD **first_suspended,
            ULONG *suspended_count,
            TX_EVENT_FLAGS_GROUP **next_group);
UINT    tx_event_flags_set(TX_EVENT_FLAGS_GROUP *group_ptr,
            ULONG flags_to_set,
            UINT set_option);


Interrupt Control Service

UINT    tx_interrupt_control(UINT new_posture);


Message Queue Services

UINT    tx_queue_create(TX_QUEUE *queue_ptr,
            CHAR *name_ptr,
            UINT message_size,
            VOID *queue_start,
            ULONG queue_size);
UINT    tx_queue_delete(TX_QUEUE *queue_ptr);
UINT    tx_queue_flush(TX_QUEUE *queue_ptr);
UINT    tx_queue_info_get(TX_QUEUE *queue_ptr,
            CHAR **name,
            ULONG *enqueued,
            ULONG *available_storage,
            TX_THREAD **first_suspended,
            ULONG *suspended_count,
            TX_QUEUE **next_queue);
UINT    tx_queue_receive(TX_QUEUE *queue_ptr,
            VOID *destination_ptr,
            ULONG wait_option);
UINT    tx_queue_send(TX_QUEUE *queue_ptr,
            VOID *source_ptr,
            ULONG wait_option);
UINT    tx_queue_front_send(TX_QUEUE *queue_ptr,
            VOID *source_ptr,
            ULONG wait_option);
UINT    tx_queue_prioritize(TX_QUEUE *queue_ptr);


Semaphore Services

UINT    tx_semaphore_create(TX_SEMAPHORE *semaphore_ptr,
            CHAR *name_ptr,
            ULONG initial_count);
UINT    tx_semaphore_delete(TX_SEMAPHORE *semaphore_ptr);
UINT    tx_semaphore_get(TX_SEMAPHORE *semaphore_ptr,
            ULONG wait_option);
UINT    tx_semaphore_info_get(TX_SEMAPHORE *semaphore_ptr,
            CHAR **name,
            ULONG *current_value,
            TX_THREAD **first_suspended,
            ULONG *suspended_count,
            TX_SEMAPHORE **next_semaphore);
UINT    tx_semaphore_prioritize(TX_SEMAPHORE *semaphore_ptr);
UINT    tx_semaphore_put(TX_SEMAPHORE *semaphore_ptr);


Mutex Services

UINT    tx_mutex_create(TX_MUTEX *mutex_ptr,
            CHAR *name_ptr,
            UINT inherit);
UINT    tx_mutex_delete(TX_MUTEX *mutex_ptr);
UINT    tx_mutex_get(TX_MUTEX *mutex_ptr,
            ULONG wait_option);
UINT    tx_mutex_info_get(TX_MUTEX *mutex_ptr,
            CHAR **name,
            ULONG *count, TX_THREAD **owner,
            TX_THREAD **first_suspended,
            ULONG *suspended_count,
            TX_MUTEX **next_mutex);
UINT    tx_mutex_prioritize(TX_MUTEX *mutex_ptr);
UINT    tx_mutex_put(TX_MUTEX *mutex_ptr);


Thread Services

UINT    tx_thread_create(TX_THREAD *thread_ptr,
            CHAR *name_ptr,
            VOID (*entry_function)(ULONG),
            ULONG entry_input,
            VOID *stack_start,
            ULONG stack_size,
            UINT priority,
            UINT preempt_threshold,
            ULONG time_slice,
            UINT auto_start);
UINT    tx_thread_delete(TX_THREAD *thread_ptr);
            TX_THREAD *tx_thread_identify(VOID);
UINT    tx_thread_info_get(TX_THREAD *thread_ptr,
            CHAR **name,
            UINT *state,
            ULONG *run_count,
            UINT *priority,
            UINT *preemption_threshold,
            ULONG *time_slice,
            TX_THREAD **next_thread,
            TX_THREAD **next_suspended_thread);
UINT    tx_thread_preemption_change(TX_THREAD *thread_ptr,
            UINT new_threshold,
            UINT *old_threshold);
UINT    tx_thread_priority_change(TX_THREAD *thread_ptr,
            UINT new_priority,
            UINT *old_priority);
VOID    tx_thread_relinquish(VOID);
UINT    tx_thread_resume(TX_THREAD *thread_ptr);
UINT    tx_thread_sleep(ULONG timer_ticks);
UINT    tx_thread_suspend(TX_THREAD *thread_ptr);
UINT    tx_thread_terminate(TX_THREAD *thread_ptr);
UINT    tx_thread_time_slice_change(TX_THREAD *thread_ptr,
            ULONG new_time_slice,
            ULONG *old_time_slice);
UINT    tx_thread_wait_abort(TX_THREAD *thread_ptr);


Time Services

ULONG   tx_time_get(VOID);
VOID    tx_time_set(ULONG new_time);


Timer Services

UINT    tx_timer_activate(TX_TIMER *timer_ptr);
UINT    tx_timer_change(TX_TIMER *timer_ptr,
            ULONG initial_ticks,
            ULONG reschedule_ticks);
UINT    tx_timer_create(TX_TIMER *timer_ptr,
            CHAR *name_ptr,
            VOID (*expiration_function)(ULONG),
            ULONG expiration_input,
            ULONG initial_ticks,
            ULONG reschedule_ticks,
            UINT auto_activate);
UINT    tx_timer_deactivate(TX_TIMER *timer_ptr);
UINT    tx_timer_delete(TX_TIMER *timer_ptr);
UINT    tx_timer_info_get(TX_TIMER *timer_ptr,
            CHAR **name,
            UINT *active,
            ULONG *remaining_ticks,
            ULONG *reschedule_ticks,
            TX_TIMER **next_timer);

Copyright © 1996-2002 by Express Logic Inc. The ThreadX API is copyrighted by and is the sole property of Express Logic, Inc. All rights, title, ownership, or other interests in the ThreadX API belong to Express Logic, Inc. Any unauthorized use of this API, duplication, transmission, distribution, or disclosure is expressly forbidden.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 
ThreadX Embedded RTOS Home Page ThreadX Embedded RTOS Inquiry ThreadX RTOS Embedded News