osal.h

Go to the documentation of this file.

 
#ifndef OSAL_H_
#define OSAL_H_
 
#ifdef OS_PRESENT
 
#if defined(OS_FREERTOS)
#include "osal_freertos.h"
#else
#error "No Operating System is defined."
#endif /* OS defined */
 
/*
 * OSAL CONFIGURATION FORWARD MACROS
 *****************************************************************************************
 */
 
#define OS_USE_TICKLESS_IDLE            _OS_USE_TICKLESS_IDLE
 
#define OS_TOTAL_HEAP_SIZE              _OS_TOTAL_HEAP_SIZE
 
#define OS_STACK_WORD_SIZE              _OS_STACK_WORD_SIZE
 
#define OS_MINIMAL_TASK_STACK_SIZE      _OS_MINIMAL_TASK_STACK_SIZE
 
#define OS_DAEMON_TASK_PRIORITY         _OS_DAEMON_TASK_PRIORITY
 
/*
 * OSAL DATA TYPE AND ENUMERATION FORWARD MACROS
 *****************************************************************************************
 */
 
/*
 * OS task priority values
 */
#define OS_TASK_PRIORITY_LOWEST         _OS_TASK_PRIORITY_LOWEST        
#define OS_TASK_PRIORITY_NORMAL         _OS_TASK_PRIORITY_NORMAL        
#define OS_TASK_PRIORITY_HIGHEST        _OS_TASK_PRIORITY_HIGHEST       
 
/*
 * Data types and enumerations for OS tasks and functions that operate on them
 */
#define OS_TASK                         _OS_TASK                        
#define OS_TASK_STATUS                  _OS_TASK_STATUS                 
#define OS_TASK_CREATE_SUCCESS          _OS_TASK_CREATE_SUCCESS         
#define OS_TASK_NOTIFY_SUCCESS          _OS_TASK_NOTIFY_SUCCESS         
#define OS_TASK_NOTIFY_FAIL             _OS_TASK_NOTIFY_FAIL            
#define OS_TASK_NOTIFY_NO_WAIT          _OS_TASK_NOTIFY_NO_WAIT         
#define OS_TASK_NOTIFY_FOREVER          _OS_TASK_NOTIFY_FOREVER         
#define OS_TASK_NOTIFY_NONE             _OS_TASK_NOTIFY_NONE            
#define OS_TASK_NOTIFY_ALL_BITS         _OS_TASK_NOTIFY_ALL_BITS        
 
/*
 * Data types and enumerations for OS mutexes and functions that operate on them
 */
#define OS_MUTEX                        _OS_MUTEX                       
#define OS_MUTEX_CREATE_SUCCESS         _OS_MUTEX_CREATE_SUCCESS        
#define OS_MUTEX_CREATE_FAIL            _OS_MUTEX_CREATE_FAIL           
#define OS_MUTEX_TAKEN                  _OS_MUTEX_TAKEN                 
#define OS_MUTEX_NOT_TAKEN              _OS_MUTEX_NOT_TAKEN             
#define OS_MUTEX_NO_WAIT                _OS_MUTEX_NO_WAIT               
#define OS_MUTEX_FOREVER                _OS_MUTEX_FOREVER               
 
/*
 * Data types and enumerations for OS events and functions that operate on them
 */
#define OS_EVENT                        _OS_EVENT                       
#define OS_EVENT_CREATE_SUCCESS         _OS_EVENT_CREATE_SUCCESS        
#define OS_EVENT_CREATE_FAIL            _OS_EVENT_CREATE_FAIL           
#define OS_EVENT_SIGNALED               _OS_EVENT_SIGNALED              
#define OS_EVENT_NOT_SIGNALED           _OS_EVENT_NOT_SIGNALED          
#define OS_EVENT_NO_WAIT                _OS_EVENT_NO_WAIT               
#define OS_EVENT_FOREVER                _OS_EVENT_FOREVER               
 
/*
 * Data types and enumerations for OS event groups and functions that operate on them
 */
#define OS_EVENT_GROUP                  _OS_EVENT_GROUP                 
#define OS_EVENT_GROUP_OK               _OS_EVENT_GROUP_OK              
#define OS_EVENT_GROUP_FAIL             _OS_EVENT_GROUP_FAIL            
#define OS_EVENT_GROUP_NO_WAIT          _OS_EVENT_GROUP_NO_WAIT         
#define OS_EVENT_GROUP_FOREVER          _OS_EVENT_GROUP_FOREVER         
 
/*
 * Data types and enumerations for OS queues and functions that operate on them
 */
#define OS_QUEUE                        _OS_QUEUE                       
#define OS_QUEUE_OK                     _OS_QUEUE_OK                    
#define OS_QUEUE_FULL                   _OS_QUEUE_FULL                  
#define OS_QUEUE_EMPTY                  _OS_QUEUE_EMPTY                 
#define OS_QUEUE_NO_WAIT                _OS_QUEUE_NO_WAIT               
#define OS_QUEUE_FOREVER                _OS_QUEUE_FOREVER               
 
/*
 * Data types and enumerations for OS timers and functions that operate on them
 */
#define OS_TIMER                        _OS_TIMER                       
#define OS_TIMER_SUCCESS                _OS_TIMER_SUCCESS               
#define OS_TIMER_FAIL                   _OS_TIMER_FAIL                  
#define OS_TIMER_RELOAD                 _OS_TIMER_RELOAD                
#define OS_TIMER_ONCE                   _OS_TIMER_ONCE                  
#define OS_TIMER_NO_WAIT                _OS_TIMER_NO_WAIT               
#define OS_TIMER_FOREVER                _OS_TIMER_FOREVER               
 
/*
 * Base data types matching underlying architecture
 */
#define OS_BASE_TYPE                    _OS_BASE_TYPE                   
#define OS_UBASE_TYPE                   _OS_UBASE_TYPE                  
 
/*
 * Enumeration values indicating successful or not OS operation
 */
#define OS_OK                           _OS_OK                          
#define OS_FAIL                         _OS_FAIL                        
 
/*
 * Boolean enumeration values
 */
#define OS_TRUE                         _OS_TRUE                        
#define OS_FALSE                        _OS_FALSE                       
 
 
#define OS_MAX_DELAY                    _OS_MAX_DELAY
 
#define OS_TICK_TIME                    _OS_TICK_TIME
 
#define OS_TICK_PERIOD                  _OS_TICK_PERIOD
 
#define OS_TICK_PERIOD_MS               _OS_TICK_PERIOD_MS
 
#define OS_TICK_CLOCK_HZ                _OS_TICK_CLOCK_HZ
 
#define OS_TASK_ARG_TYPE                _OS_TASK_ARG_TYPE
 
/*
 * Enumeration values indicating successful or not OS Atomic compare and swap operation
 */
#define OS_ATOMIC_COMPARE_AND_SWAP_SUCCESS     _OS_ATOMIC_COMPARE_AND_SWAP_SUCCESS
#define OS_ATOMIC_COMPARE_AND_SWAP_FAILURE     _OS_ATOMIC_COMPARE_AND_SWAP_FAILURE
 
/* Data type containing heap memory statistics */
#define OS_HEAP_STATISTICS_TYPE         _OS_HEAP_STATISTICS_TYPE
 
/*
 * OSAL ENUMERATIONS
 *****************************************************************************************
 */
 
typedef enum {
        OS_NOTIFY_NO_ACTION             = _OS_NOTIFY_NO_ACTION,                 
        OS_NOTIFY_SET_BITS              = _OS_NOTIFY_SET_BITS,                  
        OS_NOTIFY_INCREMENT             = _OS_NOTIFY_INCREMENT,                 
        OS_NOTIFY_VAL_WITH_OVERWRITE    = _OS_NOTIFY_VAL_WITH_OVERWRITE,        
        OS_NOTIFY_VAL_WITHOUT_OVERWRITE = _OS_NOTIFY_VAL_WITHOUT_OVERWRITE,     
} OS_NOTIFY_ACTION;
 
typedef enum {
        OS_TASK_RUNNING                 = _OS_TASK_RUNNING,                     
        OS_TASK_READY                   = _OS_TASK_READY,                       
        OS_TASK_BLOCKED                 = _OS_TASK_BLOCKED,                     
        OS_TASK_SUSPENDED               = _OS_TASK_SUSPENDED,                   
        OS_TASK_DELETED                 = _OS_TASK_DELETED,                     
} OS_TASK_STATE;
 
typedef enum {
        OS_SCHEDULER_RUNNING            = _OS_SCHEDULER_RUNNING,                
        OS_SCHEDULER_NOT_STARTED        = _OS_SCHEDULER_NOT_STARTED,            
        OS_SCHEDULER_SUSPENDED          = _OS_SCHEDULER_SUSPENDED,              
} OS_SCHEDULER_STATE;
 
/*
 * OSAL MACRO FUNCTION DEFINITIONS
 *****************************************************************************************
 */
 
#ifdef _OS_TASK_BEGIN
#define OS_TASK_BEGIN() _OS_TASK_BEGIN()
#else
#define OS_TASK_BEGIN() do { } while (0)
#endif /* _OS_TASK_BEGIN */
 
#ifdef _OS_TASK_END
#define OS_TASK_END() _OS_TASK_END()
#else
#define OS_TASK_END() do { } while (0)
#endif /* _OS_TASK_END */
 
#define OS_TASK_FUNCTION(func, arg) _OS_TASK_FUNCTION(func, arg)
 
#define OS_TASK_SCHEDULER_RUN() _OS_TASK_SCHEDULER_RUN()
 
#define OS_TIME_TO_TICKS(time_in_ms) _OS_TIME_TO_TICKS(time_in_ms)
 
#define OS_GET_CURRENT_TASK() _OS_GET_CURRENT_TASK()
 
#define OS_TASK_CREATE(name, task_func, arg, stack_size, priority, task) \
        _OS_TASK_CREATE((name), (task_func), (OS_TASK_ARG_TYPE)(arg), \
                         MAX(stack_size + dg_configSYSTEMVIEW_STACK_OVERHEAD, OS_MINIMAL_TASK_STACK_SIZE ) , \
                        (priority), (task))
 
#define OS_TASK_DELETE(task) _OS_TASK_DELETE(task)
 
#define OS_TASK_PRIORITY_GET(task) _OS_TASK_PRIORITY_GET(task)
 
#define OS_TASK_PRIORITY_GET_FROM_ISR(task) _OS_TASK_PRIORITY_GET_FROM_ISR(task)
 
#define OS_TASK_PRIORITY_SET(task, prio) _OS_TASK_PRIORITY_SET((task), (prio))
 
#define OS_TASK_YIELD() _OS_TASK_YIELD()
 
#define OS_TASK_YIELD_FROM_ISR() _OS_TASK_YIELD_FROM_ISR()
 
#define OS_TASK_NOTIFY(task, value, action) _OS_TASK_NOTIFY((task), (value), (action))
 
#define OS_TASK_NOTIFY_INDEXED(task, index, value, action) \
        _OS_TASK_NOTIFY_INDEXED((task), (index), (value), (action))
 
#define OS_TASK_NOTIFY_AND_QUERY(task, value, action, prev_value) \
        _OS_TASK_NOTIFY_AND_QUERY((task), (value), (action), (prev_value))
 
#define OS_TASK_NOTIFY_AND_QUERY_INDEXED(task, index, value, action, prev_value) \
        _OS_TASK_NOTIFY_AND_QUERY_INDEXED((task), (index), (value), (action), (prev_value))
 
#define OS_TASK_NOTIFY_FROM_ISR(task, value, action) \
        _OS_TASK_NOTIFY_FROM_ISR((task), (value), (action))
 
#define OS_TASK_NOTIFY_INDEXED_FROM_ISR(task, index, value, action) \
        _OS_TASK_NOTIFY_INDEXED_FROM_ISR((task), (index), (value), (action))
 
#define OS_TASK_NOTIFY_AND_QUERY_FROM_ISR(task, value, action, prev_value) \
        _OS_TASK_NOTIFY_AND_QUERY_FROM_ISR((task), (value), (action), (prev_value))
 
#define OS_TASK_NOTIFY_AND_QUERY_INDEXED_FROM_ISR(task, index, value, action, prev_value) \
        _OS_TASK_NOTIFY_AND_QUERY_INDEXED_FROM_ISR((task), (index), (value), (action), (prev_value))
 
#define OS_TASK_NOTIFY_GIVE(task) _OS_TASK_NOTIFY_GIVE(task)
 
#define OS_TASK_NOTIFY_GIVE_INDEXED(task, index) _OS_TASK_NOTIFY_GIVE_INDEXED((task), (index))
 
#define OS_TASK_NOTIFY_GIVE_FROM_ISR(task) _OS_TASK_NOTIFY_GIVE_FROM_ISR(task)
 
#define OS_TASK_NOTIFY_GIVE_INDEXED_FROM_ISR(task, index) \
        _OS_TASK_NOTIFY_GIVE_INDEXED_FROM_ISR((task), (index))
 
#define OS_TASK_NOTIFY_TAKE(clear_on_exit, time_to_wait) \
        _OS_TASK_NOTIFY_TAKE((clear_on_exit), (time_to_wait))
 
#define OS_TASK_NOTIFY_TAKE_INDEXED(index, clear_on_exit, time_to_wait) \
        _OS_TASK_NOTIFY_TAKE_INDEXED((index), (clear_on_exit), (time_to_wait))
 
#define OS_TASK_NOTIFY_STATE_CLEAR(task) _OS_TASK_NOTIFY_STATE_CLEAR(task)
 
#define OS_TASK_NOTIFY_STATE_CLEAR_INDEXED(task, index) \
        _OS_TASK_NOTIFY_STATE_CLEAR_INDEXED((task), (index))
 
#define OS_TASK_NOTIFY_VALUE_CLEAR(task, bits_to_clear) \
        _OS_TASK_NOTIFY_VALUE_CLEAR((task), (bits_to_clear))
 
#define OS_TASK_NOTIFY_VALUE_CLEAR_INDEXED(task, index,bits_to_clear) \
        _OS_TASK_NOTIFY_VALUE_CLEAR_INDEXED((task), (index), (bits_to_clear))
 
#define OS_TASK_NOTIFY_WAIT(entry_bits, exit_bits, value, ticks_to_wait) \
        _OS_TASK_NOTIFY_WAIT((entry_bits), (exit_bits), (value), (ticks_to_wait))
 
#define OS_TASK_NOTIFY_WAIT_INDEXED(index, entry_bits, exit_bits, value, ticks_to_wait) \
        _OS_TASK_NOTIFY_WAIT_INDEXED((index), (entry_bits), (exit_bits), (value), (ticks_to_wait))
 
#define OS_TASK_RESUME(task) _OS_TASK_RESUME(task)
 
#define OS_TASK_RESUME_FROM_ISR(task) _OS_TASK_RESUME_FROM_ISR(task)
 
#define OS_TASK_SUSPEND(task) _OS_TASK_SUSPEND(task)
 
 
#define OS_TASK_RESUME_ALL() _OS_TASK_RESUME_ALL()
 
#define OS_TASK_SUSPEND_ALL() _OS_TASK_SUSPEND_ALL()
 
#define OS_MUTEX_CREATE(mutex) _OS_MUTEX_CREATE(mutex)
 
#define OS_MUTEX_DELETE(mutex) _OS_MUTEX_DELETE(mutex)
 
#define OS_MUTEX_PUT(mutex) _OS_MUTEX_PUT(mutex)
 
#define OS_MUTEX_GET(mutex, timeout) _OS_MUTEX_GET((mutex), (timeout))
 
#define OS_MUTEX_GET_OWNER(mutex) _OS_MUTEX_GET_OWNER(mutex)
 
#define OS_MUTEX_GET_OWNER_FROM_ISR(mutex) _OS_MUTEX_GET_OWNER_FROM_ISR(mutex)
 
#define OS_MUTEX_GET_COUNT(mutex) _OS_MUTEX_GET_COUNT(mutex)
 
#define OS_MUTEX_GET_COUNT_FROM_ISR(mutex) _OS_MUTEX_GET_COUNT_FROM_ISR(mutex)
 
#define OS_EVENT_CREATE(event) _OS_EVENT_CREATE(event)
 
#define OS_EVENT_DELETE(event) _OS_EVENT_DELETE(event)
 
#define OS_EVENT_SIGNAL(event) _OS_EVENT_SIGNAL(event)
 
#define OS_EVENT_SIGNAL_FROM_ISR(event) _OS_EVENT_SIGNAL_FROM_ISR(event)
 
#define OS_EVENT_SIGNAL_FROM_ISR_NO_YIELD(event, need_yield) \
        _OS_EVENT_SIGNAL_FROM_ISR_NO_YIELD((event), (need_yield))
 
#define OS_EVENT_WAIT(event, timeout) _OS_EVENT_WAIT((event), (timeout))
 
#define OS_EVENT_CHECK(event) _OS_EVENT_CHECK(event)
 
#define OS_EVENT_CHECK_FROM_ISR(event) _OS_EVENT_CHECK_FROM_ISR(event)
 
#define OS_EVENT_CHECK_FROM_ISR_NO_YIELD(event, need_yield) \
        _OS_EVENT_CHECK_FROM_ISR_NO_YIELD((event), (need_yield))
 
#define OS_EVENT_GET_STATUS(event) _OS_EVENT_GET_STATUS(event)
 
#define OS_EVENT_GET_STATUS_FROM_ISR(event) _OS_EVENT_GET_STATUS_FROM_ISR(event)
 
#define OS_EVENT_GROUP_CREATE() _OS_EVENT_GROUP_CREATE()
 
#define OS_EVENT_GROUP_WAIT_BITS(event_group, bits_to_wait, clear_on_exit, wait_for_all, timeout) \
        _OS_EVENT_GROUP_WAIT_BITS((event_group), (bits_to_wait), (clear_on_exit), (wait_for_all), \
                                  (timeout))
 
#define OS_EVENT_GROUP_SET_BITS(event_group, bits_to_set) \
        _OS_EVENT_GROUP_SET_BITS((event_group), (bits_to_set))
 
#define OS_EVENT_GROUP_SET_BITS_FROM_ISR(event_group, bits_to_set) \
        _OS_EVENT_GROUP_SET_BITS_FROM_ISR((event_group), (bits_to_set))
 
#define OS_EVENT_GROUP_SET_BITS_FROM_ISR_NO_YIELD(event_group, bits_to_set, need_yield) \
        _OS_EVENT_GROUP_SET_BITS_FROM_ISR_NO_YIELD((event_group), (bits_to_set), (need_yield))
 
#define OS_EVENT_GROUP_CLEAR_BITS(event_group, bits_to_clear) \
        _OS_EVENT_GROUP_CLEAR_BITS((event_group), (bits_to_clear))
 
#define OS_EVENT_GROUP_CLEAR_BITS_FROM_ISR(event_group, bits_to_clear) \
        _OS_EVENT_GROUP_CLEAR_BITS_FROM_ISR((event_group), (bits_to_clear))
 
#define OS_EVENT_GROUP_GET_BITS(event_group) _OS_EVENT_GROUP_GET_BITS(event_group)
 
#define OS_EVENT_GROUP_GET_BITS_FROM_ISR(event_group) _OS_EVENT_GROUP_GET_BITS_FROM_ISR(event_group)
 
#define OS_EVENT_GROUP_SYNC(event_group, bits_to_set, bits_to_wait, timeout) \
        _OS_EVENT_GROUP_SYNC((event_group), (bits_to_set), (bits_to_wait), (timeout))
 
#define OS_EVENT_GROUP_DELETE(event_group) _OS_EVENT_GROUP_DELETE(event_group)
 
#define OS_QUEUE_CREATE(queue, item_size, max_items) \
        _OS_QUEUE_CREATE((queue), (item_size), (max_items))
 
#define OS_QUEUE_DELETE(queue) _OS_QUEUE_DELETE(queue)
 
#define OS_QUEUE_PUT(queue, item, timeout) _OS_QUEUE_PUT((queue), (item), (timeout))
 
#define OS_QUEUE_PUT_FROM_ISR(queue, item) _OS_QUEUE_PUT_FROM_ISR((queue), (item))
 
#define OS_QUEUE_REPLACE(queue, item) _OS_QUEUE_REPLACE((queue), (item))
 
#define OS_QUEUE_REPLACE_FROM_ISR(queue, item) _OS_QUEUE_REPLACE_FROM_ISR((queue), (item))
 
#define OS_QUEUE_REPLACE_FROM_ISR_NO_YIELD(queue, item, need_yield) \
        _OS_QUEUE_REPLACE_FROM_ISR_NO_YIELD((queue), (item), (need_yield))
 
#define OS_QUEUE_GET(queue, item, timeout) _OS_QUEUE_GET((queue), (item), (timeout))
 
#define OS_QUEUE_GET_FROM_ISR(queue, item) _OS_QUEUE_GET_FROM_ISR((queue), (item))
 
#define OS_QUEUE_GET_FROM_ISR_NO_YIELD(queue, item, need_yield) \
        _OS_QUEUE_GET_FROM_ISR_NO_YIELD((queue), (item), (need_yield))
 
#define OS_QUEUE_PEEK(queue, item, timeout) _OS_QUEUE_PEEK((queue), (item), (timeout))
 
#define OS_QUEUE_PEEK_FROM_ISR(queue, item) _OS_QUEUE_PEEK_FROM_ISR((queue), (item))
 
#define OS_QUEUE_MESSAGES_WAITING(queue) _OS_QUEUE_MESSAGES_WAITING(queue)
 
#define OS_QUEUE_MESSAGES_WAITING_FROM_ISR(queue) _OS_QUEUE_MESSAGES_WAITING_FROM_ISR(queue)
 
#define OS_QUEUE_SPACES_AVAILABLE(queue) _OS_QUEUE_SPACES_AVAILABLE(queue)
 
#define OS_TIMER_CREATE(name, period, reload, timer_id, callback) \
        _OS_TIMER_CREATE((name), (period), (reload), (timer_id), (callback))
 
#define OS_TIMER_GET_TIMER_ID(timer) _OS_TIMER_GET_TIMER_ID(timer)
 
#define OS_TIMER_IS_ACTIVE(timer) _OS_TIMER_IS_ACTIVE(timer)
 
#define OS_TIMER_START(timer, timeout) _OS_TIMER_START((timer), (timeout))
 
#define OS_TIMER_STOP(timer, timeout) _OS_TIMER_STOP((timer), (timeout))
 
#define OS_TIMER_CHANGE_PERIOD(timer, period, timeout) \
        _OS_TIMER_CHANGE_PERIOD((timer), (period), (timeout))
 
#define OS_TIMER_DELETE(timer, timeout) _OS_TIMER_DELETE((timer), (timeout))
 
#define OS_TIMER_RESET(timer, timeout) _OS_TIMER_RESET((timer), (timeout))
 
#define OS_TIMER_START_FROM_ISR(timer) _OS_TIMER_START_FROM_ISR(timer)
 
#define OS_TIMER_STOP_FROM_ISR(timer) _OS_TIMER_STOP_FROM_ISR(timer)
 
#define OS_TIMER_CHANGE_PERIOD_FROM_ISR(timer, period) \
        _OS_TIMER_CHANGE_PERIOD_FROM_ISR((timer), (period))
 
#define OS_TIMER_RESET_FROM_ISR(timer) _OS_TIMER_RESET_FROM_ISR(timer)
 
#define OS_TIMER_SET_RELOAD_MODE(timer, auto_reload) _OS_TIMER_SET_RELOAD_MODE(timer, auto_reload)
 
#define OS_TIMER_GET_RELOAD_MODE(timer) _OS_TIMER_GET_RELOAD_MODE(timer)
 
#define OS_DELAY(ticks) _OS_DELAY(ticks)
 
#define OS_DELAY_UNTIL(ticks) _OS_DELAY_UNTIL(ticks)
 
#define OS_GET_TICK_COUNT() _OS_GET_TICK_COUNT()
 
#define OS_GET_TICK_COUNT_FROM_ISR() _OS_GET_TICK_COUNT_FROM_ISR()
 
#define OS_TICKS_2_MS(ticks) _OS_TICKS_2_MS(ticks)
 
#define OS_MS_2_TICKS(ms) _OS_MS_2_TICKS(ms)
 
#define OS_DELAY_MS(ms) _OS_DELAY_MS(ms)
 
#define OS_ENTER_CRITICAL_SECTION() _OS_ENTER_CRITICAL_SECTION()
 
#define OS_ENTER_CRITICAL_SECTION_FROM_ISR(critical_section_status) \
        _OS_ENTER_CRITICAL_SECTION_FROM_ISR(critical_section_status)
 
#define OS_LEAVE_CRITICAL_SECTION() _OS_LEAVE_CRITICAL_SECTION()
 
#define OS_LEAVE_CRITICAL_SECTION_FROM_ISR(critical_section_status) \
        _OS_LEAVE_CRITICAL_SECTION_FROM_ISR(critical_section_status)
 
 
#define OS_MALLOC_FUNC _OS_MALLOC_FUNC
 
#define OS_MALLOC_NORET_FUNC _OS_MALLOC_NORET_FUNC
 
#define OS_MALLOC(size) _OS_MALLOC(size)
 
#define OS_MALLOC_NORET(size) _OS_MALLOC_NORET(size)
 
#define OS_FREE_FUNC _OS_FREE_FUNC
 
#define OS_FREE_NORET_FUNC _OS_FREE_NORET_FUNC
 
#define OS_FREE(addr) _OS_FREE(addr)
 
#define OS_FREE_NORET(addr) _OS_FREE_NORET(addr)
 
#ifdef _OS_ASSERT
 
#define OS_ASSERT(cond) _OS_ASSERT(cond)
#else
#define OS_ASSERT(cond)
#endif /* _OS_ASSERT */
 
#ifdef _OS_PRECONDITION
 
#define OS_PRECONDITION(cond) _OS_PRECONDITION(cond)
#else
#define OS_PRECONDITION(cond)
#endif /* OS_PRECONDITION */
 
#ifdef _OS_MEMORY_BARRIER
 
#define OS_MEMORY_BARRIER() _OS_MEMORY_BARRIER()
#else
#define OS_MEMORY_BARRIER()
#endif /* OS_MEMORY_BARRIER */
 
#ifdef _OS_SOFTWARE_BARRIER
 
#define OS_SOFTWARE_BARRIER() _OS_SOFTWARE_BARRIER()
#else
#define OS_SOFTWARE_BARRIER()
#endif /* OS_SOFTWARE_BARRIER */
 
#ifdef _OS_GET_TASKS_STATUS
 
#define OS_GET_TASKS_STATUS(task_status, status_size) \
        _OS_GET_TASKS_STATUS((task_status), (status_size))
#endif /* _OS_GET_TASKS_STATUS */
 
#ifdef _OS_GET_TASK_STACK_WATERMARK
 
#define OS_GET_TASK_STACK_WATERMARK(task) _OS_GET_TASK_STACK_WATERMARK(task)
#endif /* _OS_GET_TASK_STACK_WATERMARK */
 
#define OS_GET_HEAP_WATERMARK() _OS_GET_HEAP_WATERMARK()
 
#define OS_GET_FREE_HEAP_SIZE() _OS_GET_FREE_HEAP_SIZE()
 
#define OS_GET_TASKS_NUMBER() _OS_GET_TASKS_NUMBER()
 
#ifdef _OS_GET_TASK_NAME
 
#define OS_GET_TASK_NAME(task) _OS_GET_TASK_NAME(task)
#endif /* _OS_GET_TASK_NAME */
 
#ifdef _OS_GET_TASK_STATE
 
#define OS_GET_TASK_STATE(task) _OS_GET_TASK_STATE(task)
#endif /* _OS_GET_TASK_STATE */
 
#ifdef _OS_GET_TASK_PRIORITY
 
#define OS_GET_TASK_PRIORITY(task) _OS_GET_TASK_PRIORITY(task)
#endif /* _OS_GET_TASK_PRIORITY */
 
#ifdef _OS_GET_TASK_SCHEDULER_STATE
 
#define OS_GET_TASK_SCHEDULER_STATE() _OS_GET_TASK_SCHEDULER_STATE()
#endif /* _OS_GET_TASK_SCHEDULER_STATE */
 
#ifdef _OS_GET_IDLE_TASK_HANDLE
 
#define OS_GET_IDLE_TASK_HANDLE() _OS_GET_IDLE_TASK_HANDLE()
#endif /* _OS_GET_IDLE_TASK_HANDLE */
 
#ifdef _OS_GET_TASK_HANDLE
 
#define OS_GET_TASK_HANDLE(task_name) _OS_GET_TASK_HANDLE(task_name)
#endif /* _OS_GET_TASK_HANDLE */
 
#ifdef _OS_ATOMIC_COMPARE_AND_SWAP_U32
 
#define OS_ATOMIC_COMPARE_AND_SWAP_U32(value_location, exchange_value, swap_condition) \
        _OS_ATOMIC_COMPARE_AND_SWAP_U32(value_location, exchange_value, swap_condition)
#endif /* _OS_ATOMIC_COMPARE_AND_SWAP_U32 */
 
#ifdef _OS_ATOMIC_SWAP_POINTERS_P32
 
#define OS_ATOMIC_SWAP_POINTERS_P32(destination_pointer, exchange_pointer) \
        _OS_ATOMIC_SWAP_POINTERS_P32(destination_pointer, exchange_pointer)
#endif /* _OS_ATOMIC_SWAP_POINTERS_P32 */
 
#ifdef _OS_ATOMIC_COMPARE_AND_SWAP_POINTERS_P32
 
#define OS_ATOMIC_COMPARE_AND_SWAP_POINTERS_P32(destination_pointer, exchange_pointer, swap_condition) \
        _OS_ATOMIC_COMPARE_AND_SWAP_POINTERS_P32(destination_pointer, exchange_pointer, swap_condition)
#endif /* _OS_ATOMIC_COMPARE_AND_SWAP_POINTERS_P32 */
 
#ifdef _OS_ATOMIC_ADD_U32
 
#define OS_ATOMIC_ADD_U32(value_location, add_value) \
        _OS_ATOMIC_ADD_U32(value_location, add_value)
#endif /* _OS_ATOMIC_ADD_U32 */
 
#ifdef _OS_ATOMIC_SUBTRACT_U32
 
#define OS_ATOMIC_SUBTRACT_U32(value_location, subtract_value) \
        _OS_ATOMIC_SUBTRACT_U32(value_location, subtract_value)
#endif /* _OS_ATOMIC_SUBTRACT_U32 */
 
#ifdef _OS_ATOMIC_INCREMENT_U32
 
#define OS_ATOMIC_INCREMENT_U32(value_location) _OS_ATOMIC_INCREMENT_U32(value_location)
#endif /* _OS_ATOMIC_INCREMENT_U32 */
 
#ifdef _OS_ATOMIC_DECREMENT_U32
 
#define OS_ATOMIC_DECREMENT_U32(value_location) _OS_ATOMIC_DECREMENT_U32(value_location)
#endif /* _OS_ATOMIC_DECREMENT_U32 */
 
#ifdef _OS_ATOMIC_OR_U32
 
#define OS_ATOMIC_OR_U32(value_location, or_mask) _OS_ATOMIC_OR_U32(value_location, or_mask)
#endif /* _OS_ATOMIC_OR_U32 */
 
#ifdef _OS_ATOMIC_AND_U32
 
#define OS_ATOMIC_AND_U32(value_location, and_mask) _OS_ATOMIC_AND_U32(value_location, and_mask)
#endif /* _OS_ATOMIC_AND_U32 */
 
#ifdef _OS_ATOMIC_NAND_U32
 
#define OS_ATOMIC_NAND_U32(value_location, nand_mask) _OS_ATOMIC_NAND_U32(value_location, nand_mask)
#endif /* _OS_ATOMIC_NAND_U32 */
 
#ifdef _OS_ATOMIC_XOR_U32
 
#define OS_ATOMIC_XOR_U32(value_location, xor_mask) _OS_ATOMIC_XOR_U32(value_location, xor_mask)
#endif /* _OS_ATOMIC_XOR_U32 */
 
#ifdef _OS_GET_HEAP_STATISTICS
 
#define OS_GET_HEAP_STATISTICS(results_pointer) _OS_GET_HEAP_STATISTICS(results_pointer)
#endif /* _OS_GET_HEAP_STATISTICS */
 
/* ****************************************************** */
/* The following macro functions are called by the system */
/* ****************************************************** */
 
#if !defined(OS_SYS_PRE_STOP_PROCESSING) && defined(_OS_SYS_PRE_STOP_PROCESSING)
 
#define OS_SYS_PRE_STOP_PROCESSING() _OS_SYS_PRE_STOP_PROCESSING()
#endif /* OS_SYS_PRE_STOP_PROCESSING && _OS_SYS_PRE_STOP_PROCESSING */
 
#if !defined(OS_SYS_PRE_SLEEP_PROCESSING) && defined(_OS_SYS_PRE_SLEEP_PROCESSING)
 
#define OS_SYS_PRE_SLEEP_PROCESSING(sleep_period) _OS_SYS_PRE_SLEEP_PROCESSING(sleep_period)
#endif /* OS_SYS_PRE_SLEEP_PROCESSING && _OS_SYS_PRE_SLEEP_PROCESSING */
 
#if !defined(OS_SYS_POST_SLEEP_PROCESSING) && defined(_OS_SYS_POST_SLEEP_PROCESSING)
 
#define OS_SYS_POST_SLEEP_PROCESSING() _OS_SYS_POST_SLEEP_PROCESSING()
#endif /* OS_SYS_POST_SLEEP_PROCESSING && _OS_SYS_POST_SLEEP_PROCESSING */
 
#if !defined(OS_SYS_PRE_IDLE_PROCESSING) && defined(_OS_SYS_PRE_IDLE_PROCESSING)
 
#define OS_SYS_PRE_IDLE_PROCESSING(sleep_period) _OS_SYS_PRE_IDLE_PROCESSING(sleep_period)
#endif /* OS_SYS_PRE_IDLE_PROCESSING && _OS_SYS_PRE_IDLE_PROCESSING */
 
#if !defined(OS_SYS_POST_IDLE_PROCESSING) && defined(_OS_SYS_POST_IDLE_PROCESSING)
 
#define OS_SYS_POST_IDLE_PROCESSING(sleep_period) _OS_SYS_POST_IDLE_PROCESSING(sleep_period)
#endif /* OS_SYS_POST_IDLE_PROCESSING && _OS_SYS_POST_IDLE_PROCESSING */
 
#ifdef _OS_APP_MALLOC_FAILED
#define OS_APP_MALLOC_FAILED(...) _OS_APP_MALLOC_FAILED(__VA_ARGS__)
#else
#define OS_APP_MALLOC_FAILED(...) void dummyMallocFailedHook(__VA_ARGS__) __UNUSED; \
                                  void dummyMallocFailedHook(__VA_ARGS__)
#endif /* _OS_APP_MALLOC_FAILED */
 
#ifdef _OS_APP_IDLE
#define OS_APP_IDLE(...) _OS_APP_IDLE(__VA_ARGS__)
#else
#define OS_APP_IDLE(...) void dummyIdleHook(__VA_ARGS__) __UNUSED; \
                         void dummyIdleHook(__VA_ARGS__)
#endif /* _OS_APP_IDLE */
 
#ifdef _OS_APP_STACK_OVERFLOW
#define OS_APP_STACK_OVERFLOW(...) _OS_APP_STACK_OVERFLOW(__VA_ARGS__)
#else
#define OS_APP_STACK_OVERFLOW(...) void dummyStackOverflowHook(__VA_ARGS__) __UNUSED; \
                                   void dummyStackOverflowHook(__VA_ARGS__)
#endif /* _OS_APP_STACK_OVERFLOW */
 
#ifdef _OS_APP_TICK
#define OS_APP_TICK(...) _OS_APP_TICK(__VA_ARGS__)
#else
#define OS_APP_TICK(...) void dummyTickHook(__VA_ARGS__) __UNUSED; \
                         void dummyTickHook(__VA_ARGS__)
#endif /* _OS_APP_TICK */
 
#ifdef _OS_APP_DAEMON_TASK
#define OS_APP_DAEMON_TASK(...) _OS_APP_DAEMON_TASK(__VA_ARGS__)
#else
#define OS_APP_DAEMON_TASK(...) void dummyDaemonTaskHook(__VA_ARGS__) __UNUSED; \
                                void dummyDaemonTaskHook(__VA_ARGS__)
#endif /* _OS_APP_DAEMON_TASK */
 
/* *************************************************************** */
/* The following macro functions are used internally by the system */
/* *************************************************************** */
 
#define OS_TICK_ADVANCE() _OS_TICK_ADVANCE()
 
#define OS_TICK_INCREMENT(ticks) _OS_TICK_INCREMENT(ticks)
 
/*
 * CHECKS DEFINITIONS OF MANDATORY OSAL MACRO FUNCTIONS
 *****************************************************************************************
 */
 
 
/* *************** Mandatory OSAL configuration forward macros *************** */
 
/* Enable use of low power tickless mode */
#ifndef _OS_USE_TICKLESS_IDLE
#error "OS_USE_TICKLESS_IDLE not defined"
#endif
 
/* Total size of heap memory available for the OS */
#ifndef _OS_TOTAL_HEAP_SIZE
#error "OS_TOTAL_HEAP_SIZE not defined"
#endif
 
/* Word size used for the items stored to the stack */
#ifndef _OS_STACK_WORD_SIZE
#error "OS_STACK_WORD_SIZE not defined"
#endif
 
/* Minimal stack size (in bytes) defined for an OS task */
#ifndef _OS_MINIMAL_TASK_STACK_SIZE
#error "OS_MINIMAL_TASK_STACK_SIZE not defined"
#endif
 
/* Priority of timer daemon OS task */
#ifndef _OS_DAEMON_TASK_PRIORITY
#error "OS_DAEMON_TASK_PRIORITY not defined"
#endif
 
/* ********* Mandatory OSAL data type and enumeration forward macros ********* */
 
/* OS task priority values */
 
#ifndef _OS_TASK_PRIORITY_LOWEST
#error "OS_TASK_PRIORITY_LOWEST not defined"
#endif
 
#ifndef _OS_TASK_PRIORITY_NORMAL
#error "OS_TASK_PRIORITY_NORMAL not defined"
#endif
 
#ifndef _OS_TASK_PRIORITY_HIGHEST
#error "OS_TASK_PRIORITY_HIGHEST not defined"
#endif
 
/* Data types and enumerations for OS tasks and functions that operate on them */
 
#ifndef _OS_TASK
#error "OS_TASK not defined"
#endif
 
#ifndef _OS_TASK_CREATE_SUCCESS
#error "OS_TASK_CREATE_SUCCESS not defined"
#endif
 
#ifndef _OS_TASK_NOTIFY_SUCCESS
#error "OS_TASK_NOTIFY_SUCCESS not defined"
#endif
 
#ifndef _OS_TASK_NOTIFY_FAIL
#error "OS_TASK_NOTIFY_FAIL not defined"
#endif
 
#ifndef _OS_TASK_NOTIFY_NO_WAIT
#error "OS_TASK_NOTIFY_NO_WAIT not defined"
#endif
 
#ifndef _OS_TASK_NOTIFY_FOREVER
#error "OS_TASK_NOTIFY_FOREVER not defined"
#endif
 
#ifndef _OS_TASK_NOTIFY_NONE
#error "OS_TASK_NOTIFY_NONE not defined"
#endif
 
#ifndef _OS_TASK_NOTIFY_ALL_BITS
#error "OS_TASK_NOTIFY_ALL_BITS not defined"
#endif
 
/* Data types and enumerations for OS mutexes and functions that operate on them */
 
#ifndef _OS_MUTEX
#error "OS_MUTEX not defined"
#endif
 
#ifndef _OS_MUTEX_CREATE_SUCCESS
#error "OS_MUTEX_CREATE_SUCCESS not defined"
#endif
 
#ifndef _OS_MUTEX_CREATE_FAIL
#error "OS_MUTEX_CREATE_FAIL not defined"
#endif
 
#ifndef _OS_MUTEX_TAKEN
#error "OS_MUTEX_TAKEN not defined"
#endif
 
#ifndef _OS_MUTEX_NOT_TAKEN
#error "OS_MUTEX_NOT_TAKEN not defined"
#endif
 
#ifndef _OS_MUTEX_NO_WAIT
#error "OS_MUTEX_NO_WAIT not defined"
#endif
 
#ifndef _OS_MUTEX_FOREVER
#error "OS_MUTEX_FOREVER not defined"
#endif
 
/* Data types and enumerations for OS events and functions that operate on them */
 
#ifndef _OS_EVENT
#error "OS_EVENT not defined"
#endif
 
#ifndef _OS_EVENT_CREATE_SUCCESS
#error "OS_EVENT_CREATE_SUCCESS not defined"
#endif
 
#ifndef _OS_EVENT_CREATE_FAIL
#error "OS_EVENT_CREATE_FAIL not defined"
#endif
 
#ifndef _OS_EVENT_SIGNALED
#error "OS_EVENT_SIGNALED not defined"
#endif
 
#ifndef _OS_EVENT_NOT_SIGNALED
#error "OS_EVENT_NOT_SIGNALED not defined"
#endif
 
#ifndef _OS_EVENT_NO_WAIT
#error "OS_EVENT_NO_WAIT not defined"
#endif
 
#ifndef _OS_EVENT_FOREVER
#error "OS_EVENT_FOREVER not defined"
#endif
 
/* Data types and enumerations for OS event groups and functions that operate on them */
 
#ifndef _OS_EVENT_GROUP
#error "OS_EVENT_GROUP not defined"
#endif
 
#ifndef _OS_EVENT_GROUP_OK
#error "OS_EVENT_GROUP_OK not defined"
#endif
 
#ifndef _OS_EVENT_GROUP_FAIL
#error "OS_EVENT_GROUP_FAIL not defined"
#endif
 
#ifndef _OS_EVENT_GROUP_NO_WAIT
#error "OS_EVENT_GROUP_NO_WAIT not defined"
#endif
 
#ifndef _OS_EVENT_GROUP_FOREVER
#error "OS_EVENT_GROUP_FOREVER not defined"
#endif
 
/* Data types and enumerations for OS queues and functions that operate on them */
 
#ifndef _OS_QUEUE
#error "OS_QUEUE not defined"
#endif
 
#ifndef _OS_QUEUE_OK
#error "OS_QUEUE_OK not defined"
#endif
 
#ifndef _OS_QUEUE_FULL
#error "OS_QUEUE_FULL not defined"
#endif
 
#ifndef _OS_QUEUE_EMPTY
#error "OS_QUEUE_EMPTY not defined"
#endif
 
#ifndef _OS_QUEUE_NO_WAIT
#error "OS_QUEUE_NO_WAIT not defined"
#endif
 
#ifndef _OS_QUEUE_FOREVER
#error "OS_QUEUE_FOREVER not defined"
#endif
 
/* Data types and enumerations for OS timers and functions that operate on them */
 
#ifndef _OS_TIMER
#error "OS_TIMER not defined"
#endif
 
#ifndef _OS_TIMER_SUCCESS
#error "OS_TIMER_SUCCESS not defined"
#endif
 
#ifndef _OS_TIMER_FAIL
#error "OS_TIMER_FAIL not defined"
#endif
 
#ifndef _OS_TIMER_RELOAD
#error "OS_TIMER_RELOAD not defined"
#endif
 
#ifndef _OS_TIMER_ONCE
#error "OS_TIMER_ONCE not defined"
#endif
 
#ifndef _OS_TIMER_NO_WAIT
#error "OS_TIMER_NO_WAIT not defined"
#endif
 
#ifndef _OS_TIMER_FOREVER
#error "OS_TIMER_FOREVER not defined"
#endif
 
/* Base data types matching underlying architecture */
 
#ifndef _OS_BASE_TYPE
#error "OS_BASE_TYPE not defined"
#endif
 
#ifndef _OS_UBASE_TYPE
#error "OS_UBASE_TYPE not defined"
#endif
 
/* Enumeration values indicating successful or not OS operation */
 
#ifndef _OS_OK
#error "OS_OK not defined"
#endif
 
#ifndef _OS_FAIL
#error "OS_FAIL not defined"
#endif
 
/* Boolean enumeration values */
 
#ifndef _OS_TRUE
#error "OS_TRUE not defined"
#endif
 
#ifndef _OS_FALSE
#error "OS_FALSE not defined"
#endif
 
/* Maximum OS delay (in OS ticks) */
#ifndef _OS_MAX_DELAY
#error "OS_MAX_DELAY not defined"
#endif
 
/* OS tick time (i.e. time expressed in OS ticks) data type */
#ifndef _OS_TICK_TIME
#error "OS_TICK_TIME not defined"
#endif
 
/* OS tick period (in cycles of source clock used for the OS timer) */
#ifndef _OS_TICK_PERIOD
#error "OS_TICK_PERIOD not defined"
#endif
 
/* OS tick period (in msec) */
#ifndef _OS_TICK_PERIOD_MS
#error "OS_TICK_PERIOD_MS not defined"
#endif
 
/* Frequency (in Hz) of the source clock used for the OS timer */
#ifndef _OS_TICK_CLOCK_HZ
#error "OS_TICK_CLOCK_HZ not defined"
#endif
 
/* Data type of OS task function (i.e. OS_TASK_FUNCTION) argument */
#ifndef _OS_TASK_ARG_TYPE
#error "OS_TASK_ARG_TYPE not defined"
#endif
 
/* *********************** Mandatory OSAL enumerations *********************** */
 
/* OS task notification action */
 
#ifndef _OS_NOTIFY_NO_ACTION
#error "OS_NOTIFY_NO_ACTION not defined"
#endif
 
#ifndef _OS_NOTIFY_SET_BITS
#error "OS_NOTIFY_SET_BITS not defined"
#endif
 
#ifndef _OS_NOTIFY_INCREMENT
#error "OS_NOTIFY_INCREMENT not defined"
#endif
 
#ifndef _OS_NOTIFY_VAL_WITH_OVERWRITE
#error "OS_NOTIFY_VAL_WITH_OVERWRITE not defined"
#endif
 
#ifndef _OS_NOTIFY_VAL_WITHOUT_OVERWRITE
#error "OS_NOTIFY_VAL_WITHOUT_OVERWRITE not defined"
#endif
 
/* OS task state */
 
#ifndef _OS_TASK_RUNNING
#error "OS_TASK_RUNNING not defined"
#endif
 
#ifndef _OS_TASK_READY
#error "OS_TASK_READY not defined"
#endif
 
#ifndef _OS_TASK_BLOCKED
#error "OS_TASK_BLOCKED not defined"
#endif
 
#ifndef _OS_TASK_SUSPENDED
#error "OS_TASK_SUSPENDED not defined"
#endif
 
#ifndef _OS_TASK_DELETED
#error "OS_TASK_DELETED not defined"
#endif
 
/* OS scheduler state */
 
#ifndef _OS_SCHEDULER_RUNNING
#error "OS_SCHEDULER_RUNNING not defined"
#endif
 
#ifndef _OS_SCHEDULER_NOT_STARTED
#error "OS_SCHEDULER_NOT_STARTED not defined"
#endif
 
#ifndef _OS_SCHEDULER_SUSPENDED
#error "OS_SCHEDULER_SUSPENDED not defined"
#endif
 
/* **************** Mandatory OSAL macro function definitions **************** */
 
/* Declare an OS task function */
#ifndef _OS_TASK_FUNCTION
#error "OS_TASK_FUNCTION not defined"
#endif
 
/* Run the OS task scheduler */
#ifndef _OS_TASK_SCHEDULER_RUN
#error "OS_TASK_SCHEDULER_RUN not defined"
#endif
 
/* Convert a time in milliseconds to a time in OS ticks */
#ifndef _OS_TIME_TO_TICKS
#error "OS_TIME_TO_TICKS not defined"
#endif
 
/* Return current OS task handle */
#ifndef _OS_GET_CURRENT_TASK
#error "OS_GET_CURRENT_TASK not defined"
#endif
 
/* Create OS task */
#ifndef _OS_TASK_CREATE
#error "OS_TASK_CREATE not defined"
#endif
 
/* Delete OS task */
#ifndef _OS_TASK_DELETE
#error "OS_TASK_DELETE not defined"
#endif
 
/* Get the priority of an OS task */
#ifndef _OS_TASK_PRIORITY_GET
#error "OS_TASK_PRIORITY_GET not defined"
#endif
 
/* Get the priority of an OS task from ISR */
#ifndef _OS_TASK_PRIORITY_GET_FROM_ISR
#error "OS_TASK_PRIORITY_GET_FROM_ISR not defined"
#endif
 
/* Set the priority of an OS task */
#ifndef _OS_TASK_PRIORITY_SET
#error "OS_TASK_PRIORITY_SET not defined"
#endif
 
/* The running OS task yields control to the scheduler */
#ifndef _OS_TASK_YIELD
#error "OS_TASK_YIELD not defined"
#endif
 
/* The running OS task yields control to the scheduler from ISR */
#ifndef _OS_TASK_YIELD_FROM_ISR
#error "OS_TASK_YIELD_FROM_ISR not defined"
#endif
 
/* Send notification to OS task, updating its notification value */
#ifndef _OS_TASK_NOTIFY
#error "OS_TASK_NOTIFY not defined"
#endif
 
/* Send notification to OS task, updating its notification value and returning previous value */
#ifndef _OS_TASK_NOTIFY_AND_QUERY
#error "OS_TASK_NOTIFY_AND_QUERY not defined"
#endif
 
/* Send notification to OS task from ISR, updating its notification value */
#ifndef _OS_TASK_NOTIFY_FROM_ISR
#error "OS_TASK_NOTIFY_FROM_ISR not defined"
#endif
 
/* Send notification to OS task from ISR, updating its notification value and returning
 * previous value */
#ifndef _OS_TASK_NOTIFY_AND_QUERY_FROM_ISR
#error "OS_TASK_NOTIFY_AND_QUERY_FROM_ISR not defined"
#endif
 
/* Send a notification event to OS task, incrementing its notification value */
#ifndef _OS_TASK_NOTIFY_GIVE
#error "OS_TASK_NOTIFY_GIVE not defined"
#endif
 
/* Send a notification event to OS task from ISR, incrementing its notification value */
#ifndef _OS_TASK_NOTIFY_GIVE_FROM_ISR
#error "OS_TASK_NOTIFY_GIVE_FROM_ISR not defined"
#endif
 
/* Wait for the calling OS task to receive a notification event, clearing to zero or
 * decrementing task notification value on exit */
#ifndef _OS_TASK_NOTIFY_TAKE
#error "OS_TASK_NOTIFY_TAKE not defined"
#endif
 
/* Wait for the calling OS task to receive a notification, updating task notification value
 * on exit */
#ifndef _OS_TASK_NOTIFY_WAIT
#error "OS_TASK_NOTIFY_WAIT not defined"
#endif
 
/* Resume OS task */
#ifndef _OS_TASK_RESUME
#error "OS_TASK_RESUME not defined"
#endif
 
/* Resume OS task from ISR */
#ifndef _OS_TASK_RESUME_FROM_ISR
#error "OS_TASK_RESUME_FROM_ISR not defined"
#endif
 
/* Suspend OS task */
#ifndef _OS_TASK_SUSPEND
#error "OS_TASK_SUSPEND not defined"
#endif
 
/* Enable scheduler to resume all tasks */
#ifndef _OS_TASK_RESUME_ALL
#error "OS_TASK_RESUME_ALL not defined"
#endif
 
/* Disable scheduler to suspend all tasks */
#ifndef _OS_TASK_SUSPEND_ALL
#error "OS_TASK_SUSPEND_ALL not defined"
#endif
 
/* Create OS mutex */
#ifndef _OS_MUTEX_CREATE
#error "OS_MUTEX_CREATE not defined"
#endif
 
/* Delete OS mutex */
#ifndef _OS_MUTEX_DELETE
#error "OS_MUTEX_DELETE not defined"
#endif
 
/* Release OS mutex */
#ifndef _OS_MUTEX_PUT
#error "OS_MUTEX_PUT not defined"
#endif
 
/* Acquire OS mutex */
#ifndef _OS_MUTEX_GET
#error "OS_MUTEX_GET not defined"
#endif
 
/* Get OS task owner of OS mutex */
#ifndef _OS_MUTEX_GET_OWNER
#error "OS_MUTEX_GET_OWNER not defined"
#endif
 
/* Get OS task owner of OS mutex from ISR */
#ifndef _OS_MUTEX_GET_OWNER_FROM_ISR
#error "OS_MUTEX_GET_OWNER_FROM_ISR not defined"
#endif
 
/* Get OS mutex current count value */
#ifndef _OS_MUTEX_GET_COUNT
#error "OS_MUTEX_GET_COUNT not defined"
#endif
 
/* Get OS mutex current count value from ISR */
#ifndef _OS_MUTEX_GET_COUNT_FROM_ISR
#error "OS_MUTEX_GET_COUNT_FROM_ISR not defined"
#endif
 
/* Create OS event */
#ifndef _OS_EVENT_CREATE
#error "OS_EVENT_CREATE not defined"
#endif
 
/* Delete OS event */
#ifndef _OS_EVENT_DELETE
#error "OS_EVENT_DELETE not defined"
#endif
 
/* Set OS event in signaled state */
#ifndef _OS_EVENT_SIGNAL
#error "OS_EVENT_SIGNAL not defined"
#endif
 
/* Set OS event in signaled state from ISR */
#ifndef _OS_EVENT_SIGNAL_FROM_ISR
#error "OS_EVENT_SIGNAL_FROM_ISR not defined"
#endif
 
/* Set OS event in signaled state from ISR without requesting running OS task to yield */
#ifndef _OS_EVENT_SIGNAL_FROM_ISR_NO_YIELD
#error "OS_EVENT_SIGNAL_FROM_ISR_NO_YIELD not defined"
#endif
 
/* Wait for OS event to be signaled */
#ifndef _OS_EVENT_WAIT
#error "OS_EVENT_WAIT not defined"
#endif
 
/* Check if OS event is signaled and clear it */
#ifndef _OS_EVENT_CHECK
#error "OS_EVENT_CHECK not defined"
#endif
 
/* Check from ISR if OS event is signaled and clear it */
#ifndef _OS_EVENT_CHECK_FROM_ISR
#error "OS_EVENT_CHECK_FROM_ISR not defined"
#endif
 
/* Check from ISR if OS event is signaled and clear it, without requesting
 * running OS task to yield */
#ifndef _OS_EVENT_CHECK_FROM_ISR_NO_YIELD
#error "OS_EVENT_CHECK_FROM_ISR_NO_YIELD not defined"
#endif
 
/* Get OS event status */
#ifndef _OS_EVENT_GET_STATUS
#error "OS_EVENT_GET_STATUS not defined"
#endif
 
/* Get OS event status from ISR */
#ifndef _OS_EVENT_GET_STATUS_FROM_ISR
#error "OS_EVENT_GET_STATUS_FROM_ISR not defined"
#endif
 
/* Create OS event group */
#ifndef _OS_EVENT_GROUP_CREATE
#error "OS_EVENT_GROUP_CREATE not defined"
#endif
 
/* Wait for OS event group bits to become set */
#ifndef _OS_EVENT_GROUP_WAIT_BITS
#error "OS_EVENT_GROUP_WAIT_BITS not defined"
#endif
 
/* Set OS event group bits */
#ifndef _OS_EVENT_GROUP_SET_BITS
#error "OS_EVENT_GROUP_SET_BITS not defined"
#endif
 
/* Set OS event group bits from ISR */
#ifndef _OS_EVENT_GROUP_SET_BITS_FROM_ISR
#error "OS_EVENT_GROUP_SET_BITS_FROM_ISR not defined"
#endif
 
/* Set OS event group bits from ISR without requesting running OS task to yield */
#ifndef _OS_EVENT_GROUP_SET_BITS_FROM_ISR_NO_YIELD
#error "OS_EVENT_GROUP_SET_BITS_FROM_ISR_NO_YIELD not defined"
#endif
 
/* Clear OS event group bits */
#ifndef _OS_EVENT_GROUP_CLEAR_BITS
#error "OS_EVENT_GROUP_CLEAR_BITS not defined"
#endif
 
/* Clear OS event group bits from an interrupt */
#ifndef _OS_EVENT_GROUP_CLEAR_BITS_FROM_ISR
#error "OS_EVENT_GROUP_CLEAR_BITS_FROM_ISR not defined"
#endif
 
/* Get OS event group bits */
#ifndef _OS_EVENT_GROUP_GET_BITS
#error "OS_EVENT_GROUP_GET_BITS not defined"
#endif
 
/* Get OS event group bits from an interrupt */
#ifndef _OS_EVENT_GROUP_GET_BITS_FROM_ISR
#error "OS_EVENT_GROUP_GET_BITS_FROM_ISR not defined"
#endif
 
/* Synchronize OS event group bits */
#ifndef _OS_EVENT_GROUP_SYNC
#error "OS_EVENT_GROUP_SYNC not defined"
#endif
 
/* Delete OS event group */
#ifndef _OS_EVENT_GROUP_DELETE
#error "OS_EVENT_GROUP_DELETE not defined"
#endif
 
/* Create OS queue */
#ifndef _OS_QUEUE_CREATE
#error "OS_QUEUE_CREATE not defined"
#endif
 
/* Deletes OS queue */
#ifndef _OS_QUEUE_DELETE
#error "OS_QUEUE_DELETE not defined"
#endif
 
/* Put element in OS queue */
#ifndef _OS_QUEUE_PUT
#error "OS_QUEUE_PUT not defined"
#endif
 
/* Put element in OS queue */
#ifndef _OS_QUEUE_PUT_FROM_ISR
#error "OS_QUEUE_PUT_FROM_ISR not defined"
#endif
 
/* Replace element in OS queue of one element */
#ifndef _OS_QUEUE_REPLACE
#error "OS_QUEUE_REPLACE not defined"
#endif
 
/* Replace element in OS queue of one element from ISR */
#ifndef _OS_QUEUE_REPLACE_FROM_ISR
#error "OS_QUEUE_REPLACE_FROM_ISR not defined"
#endif
 
/* Replace element in OS queue of one element from ISR without requesting running OS task to yield */
#ifndef _OS_QUEUE_REPLACE_FROM_ISR_NO_YIELD
#error "OS_QUEUE_REPLACE_FROM_ISR_NO_YIELD not defined"
#endif
 
/* Get element from OS queue */
#ifndef _OS_QUEUE_GET
#error "OS_QUEUE_GET not defined"
#endif
 
/* Get element from OS queue from ISR */
#ifndef _OS_QUEUE_GET_FROM_ISR
#error "OS_QUEUE_GET_FROM_ISR not defined"
#endif
 
/* Get element from OS queue from ISR without requesting running OS task to yield */
#ifndef _OS_QUEUE_GET_FROM_ISR_NO_YIELD
#error "OS_QUEUE_GET_FROM_ISR_NO_YIELD not defined"
#endif
 
/* Peek element from OS queue */
#ifndef _OS_QUEUE_PEEK
#error "OS_QUEUE_PEEK not defined"
#endif
 
/* Peek element from OS queue from ISR */
#ifndef _OS_QUEUE_PEEK_FROM_ISR
#error "OS_QUEUE_PEEK_FROM_ISR not defined"
#endif
 
/* Get the number of messages stored in OS queue */
#ifndef _OS_QUEUE_MESSAGES_WAITING
#error "OS_QUEUE_MESSAGES_WAITING not defined"
#endif
 
/* Get the number of messages stored in OS queue from ISR */
#ifndef _OS_QUEUE_MESSAGES_WAITING_FROM_ISR
#error "OS_QUEUE_MESSAGES_WAITING_FROM_ISR not defined"
#endif
 
/* Get the number of free spaces in OS queue */
#ifndef _OS_QUEUE_SPACES_AVAILABLE
#error "OS_QUEUE_SPACES_AVAILABLE not defined"
#endif
 
/* Create OS timer */
#ifndef _OS_TIMER_CREATE
#error "OS_TIMER_CREATE not defined"
#endif
 
/* Get OS timer ID */
#ifndef _OS_TIMER_GET_TIMER_ID
#error "OS_TIMER_GET_TIMER_ID not defined"
#endif
 
/* Check if OS timer is active */
#ifndef _OS_TIMER_IS_ACTIVE
#error "OS_TIMER_IS_ACTIVE not defined"
#endif
 
/* Start OS timer */
#ifndef _OS_TIMER_START
#error "OS_TIMER_START not defined"
#endif
 
/* Stop OS timer */
#ifndef _OS_TIMER_STOP
#error "OS_TIMER_STOP not defined"
#endif
 
/* Change OS timer's period */
#ifndef _OS_TIMER_CHANGE_PERIOD
#error "OS_TIMER_CHANGE_PERIOD not defined"
#endif
 
/* Delete OS timer */
#ifndef _OS_TIMER_DELETE
#error "OS_TIMER_DELETE not defined"
#endif
 
/* Reset OS timer */
#ifndef _OS_TIMER_RESET
#error "OS_TIMER_RESET not defined"
#endif
 
/* Start OS timer from ISR */
#ifndef _OS_TIMER_START_FROM_ISR
#error "OS_TIMER_START_FROM_ISR not defined"
#endif
 
/* Stop OS timer from ISR */
#ifndef _OS_TIMER_STOP_FROM_ISR
#error "OS_TIMER_STOP_FROM_ISR not defined"
#endif
 
/* Change OS timer period from ISR */
#ifndef _OS_TIMER_CHANGE_PERIOD_FROM_ISR
#error "OS_TIMER_CHANGE_PERIOD_FROM_ISR not defined"
#endif
 
/* Reset OS timer from ISR */
#ifndef _OS_TIMER_RESET_FROM_ISR
#error "OS_TIMER_RESET_FROM_ISR not defined"
#endif
 
/* Delay execution of OS task for specified time */
#ifndef _OS_DELAY
#error "OS_DELAY not defined"
#endif
 
/* Delay execution of OS task until specified time */
#ifndef _OS_DELAY_UNTIL
#error "OS_DELAY_UNTIL not defined"
#endif
 
/* Get current OS tick count */
#ifndef _OS_GET_TICK_COUNT
#error "OS_GET_TICK_COUNT not defined"
#endif
 
/* Get current OS tick count from ISR */
#ifndef _OS_GET_TICK_COUNT_FROM_ISR
#error "OS_GET_TICK_COUNT_FROM_ISR not defined"
#endif
 
/* Convert from OS ticks to ms */
#ifndef _OS_TICKS_2_MS
#error "OS_TICKS_2_MS not defined"
#endif
 
/* Convert from ms to OS ticks */
#ifndef _OS_MS_2_TICKS
#error "OS_MS_2_TICKS not defined"
#endif
 
/* Delay execution of OS task for specified time */
#ifndef _OS_DELAY_MS
#error "OS_DELAY_MS not defined"
#endif
 
/* Enter critical section from non-ISR context */
#ifndef _OS_ENTER_CRITICAL_SECTION
#error "OS_ENTER_CRITICAL_SECTION not defined"
#endif
 
/* Enter critical section from ISR context */
#ifndef _OS_ENTER_CRITICAL_SECTION_FROM_ISR
#error "OS_ENTER_CRITICAL_SECTION_FROM_ISR not defined"
#endif
 
/* Leave critical section from non-ISR context */
#ifndef _OS_LEAVE_CRITICAL_SECTION
#error "OS_LEAVE_CRITICAL_SECTION not defined"
#endif
 
/* Leave critical section from ISR context */
#ifndef _OS_LEAVE_CRITICAL_SECTION_FROM_ISR
#error "OS_LEAVE_CRITICAL_SECTION_FROM_ISR not defined"
#endif
 
/* Name for OS memory allocation function */
#ifndef _OS_MALLOC_FUNC
#error "OS_MALLOC_FUNC not defined"
#endif
 
/* Name for non-retain memory allocation function */
#ifndef _OS_MALLOC_NORET_FUNC
#error "OS_MALLOC_NORET_FUNC not defined"
#endif
 
/* Allocate memory from OS provided heap */
#ifndef _OS_MALLOC
#error "OS_MALLOC not defined"
#endif
 
/* Allocate memory from non-retain heap */
#ifndef _OS_MALLOC_NORET
#error "OS_MALLOC_NORET not defined"
#endif
 
/* Name for OS free memory function */
#ifndef _OS_FREE_FUNC
#error "OS_FREE_FUNC not defined"
#endif
 
/* Name for non-retain memory free function */
#ifndef _OS_FREE_NORET_FUNC
#error "OS_FREE_NORET_FUNC not defined"
#endif
 
/* Free memory allocated by OS_MALLOC() */
#ifndef _OS_FREE
#error "OS_FREE not defined"
#endif
 
/* Free memory allocated by OS_MALLOC_NORET() */
#ifndef _OS_FREE_NORET
#error "OS_FREE_NORET not defined"
#endif
 
/* Get the high water mark of heap */
#ifndef _OS_GET_HEAP_WATERMARK
#error "OS_GET_HEAP_WATERMARK not defined"
#endif
 
/* Get current free heap size */
#ifndef _OS_GET_FREE_HEAP_SIZE
#error "OS_GET_FREE_HEAP_SIZE not defined"
#endif
 
/* Get current number of OS tasks */
#ifndef _OS_GET_TASKS_NUMBER
#error "OS_GET_TASKS_NUMBER not defined"
#endif
 
/* Advance OS tick count */
#ifndef _OS_TICK_ADVANCE
#error "OS_TICK_ADVANCE not defined"
#endif
 
/* Update OS tick count by adding a given number of OS ticks */
#ifndef _OS_TICK_INCREMENT
#error "OS_TICK_INCREMENT not defined"
#endif
 
#else
 
#include <stdlib.h>
/*
 * Basic set of macros that can be used in non OS environment.
 */
#define PRIVILEGED_DATA
#define OS_MALLOC               malloc
#define OS_FREE                 free
#ifndef RELEASE_BUILD
#define OS_ASSERT(a)            do { if (!(a)) {__BKPT(0);} } while (0)
#else
#define OS_ASSERT(a)            ((void) (a))
#endif
 
#endif /* OS_PRESENT */
 
#define OS_PTR_TO_UINT(p) ((unsigned) (void *) (p))
 
#define OS_PTR_TO_INT(p) ((int) (void *) (p))
 
#define OS_UINT_TO_PTR(u) ((void *) (unsigned) (u))
 
#define OS_INT_TO_PTR(i) ((void *) (int) (i))
 
#endif /* OSAL_H_ */