OsUtility.h

Go to the documentation of this file.

 
#ifndef OS_UTILITY_H_
#define OS_UTILITY_H_
 
#include "OsAbstraction.h"
 
enum time_unit_t {
    TIME_UNIT_US = 0,  
    TIME_UNIT_MS,      
    TIME_UNIT_S        
};
 
#define UTIL_SYSTEM_CLOCK (240000000.0) //240MHz
 
#if defined(HF_RTOS_FREERTOS) || defined(HF_RTOS_THREADX) || defined(HF_RTOS_CMSIS)
 
#if defined(HF_RTOS_CMSIS) && !defined(HF_RTOS_CMSIS_TICK_RATE_HZ)
#  define HF_RTOS_CMSIS_TICK_RATE_HZ 1000U
#endif
 
#if defined(HF_RTOS_FREERTOS)
static constexpr uint32_t osTickRateHz = static_cast<uint32_t>(configTICK_RATE_HZ);
#elif defined(HF_RTOS_CMSIS)
static constexpr uint32_t osTickRateHz = HF_RTOS_CMSIS_TICK_RATE_HZ;
#else
static constexpr uint32_t osTickRateHz = 1000;
#endif
 
// ── Portable constexpr conversion utilities (work regardless of RTOS) ────
constexpr uint32_t os_convert_msec_to_delay_ticks( uint32_t milliseconds )
{
    const uint64_t ticks = static_cast<uint64_t>(milliseconds) * osTickRateHz / 1000U;
    if (ticks >= 0xFFFFFFFFULL) return 0xFFFFFFFEU;
    if (ticks == 0U && milliseconds != 0U) return 1U;
    return static_cast<uint32_t>(ticks);
}
 
constexpr uint32_t os_convert_delay_ticks_to_msec(uint32_t delayTicks)
{
    return (delayTicks * 1000U) / osTickRateHz;
}
 
constexpr uint32_t os_convert_hz_to_delay_ticks( uint32_t frequency )
{
    if (frequency == 0U) return 0U;
    const uint32_t ticks = osTickRateHz / frequency;
    return (ticks == 0U) ? 1U : ticks;
}
 
// ── RTOS declarations (implemented in OsUtility.cpp) ─────────────────────
 
#ifdef __cplusplus
extern "C" {
#endif
 
void os_delay_msec(uint16_t msec);
 
void os_delay_time(uint32_t timeBetweenSamples, time_unit_t timeUnit);
 
uint32_t os_get_elapsed_time_msec();
 
uint32_t os_get_elapsed_processor_cycle_count(uint32_t startCycleCount, time_unit_t unit);
 
uint32_t os_get_processor_cycle_count();
 
void os_stack_fault_handler(OS_Thread* thread);
 
//=============//
// MUTEX
//=============//
 
bool os_mutex_create_ex(OS_Mutex& mutex, const char* mutexName,
                   OS_Uint priority = OS_INHERIT,
                   bool suppressVerbose=true ) noexcept;
 
bool os_mutex_get_ex(OS_Mutex& mutex_ptr, OS_Ulong wait_option, bool suppressVerbose=true) noexcept;
 
bool os_mutex_put_ex(OS_Mutex& mutex_ptr, bool suppressVerbose=true) noexcept;
 
bool os_mutex_delete_ex(OS_Mutex& mutex, bool suppressVerbose=true) noexcept;
 
 
bool os_mutex_create_p(OS_Mutex* mutex, const char* mutexName,
                    OS_Uint priority = OS_INHERIT,
                    bool suppressVerbose=true ) noexcept;
 
bool os_mutex_get_p(OS_Mutex* mutex_ptr, OS_Ulong wait_option, bool suppressVerbose=true) noexcept;
 
bool os_mutex_put_p(OS_Mutex* mutex_ptr, bool suppressVerbose=true) noexcept;
 
bool os_mutex_delete_p(OS_Mutex* mutex, bool suppressVerbose=true) noexcept;
 
//=============//
// THREAD
//=============//
 
bool os_thread_create_ex(OS_Thread* txThread, const char* name,
                    void (*entry_function)(OS_Ulong id), OS_Ulong entry_input,
                    uint8_t* stack, OS_Ulong stackSizeBytes, OS_Uint priority,
                    OS_Uint preempt_threshold, OS_Ulong timeSliceAllowed,
                    OS_Uint auto_start, bool suppressVerbose=true) noexcept;
 
bool os_thread_create_ex_pinned(OS_Thread* txThread, const char* name,
                    void (*entry_function)(OS_Ulong id), OS_Ulong entry_input,
                    uint8_t* stack, OS_Ulong stackSizeBytes, OS_Uint priority,
                    OS_Uint preempt_threshold, OS_Ulong timeSliceAllowed,
                    OS_Uint auto_start, int core_id,
                    bool suppressVerbose=true) noexcept;
 
bool os_thread_resume_ex(OS_Thread* thread, bool suppressVerbose=true);
 
bool os_thread_resume_if_suspended(OS_Thread *txThread, bool suppressVerbose=true) noexcept;
 
bool os_thread_suspend_ex( OS_Thread* thread, bool suppressVerbose=true);
 
bool os_thread_delete_ex(OS_Thread *txThread, bool suppressVerbose=true) noexcept;
 
//=============//
// QUEUE
//=============//
 
bool os_queue_create_ex(OS_Queue& queue, const char* queueName, OS_Uint messageSizeInWords,
                   void* queueStorage, OS_Ulong queueSize, bool suppressVerbose=true) noexcept;
 
bool os_queue_delete_ex(OS_Queue& queue, bool suppressVerbose=true) noexcept;
 
bool os_queue_send_ex(OS_Queue& queue, void* message, OS_Ulong wait_option = OS_WAIT_FOREVER,
                   bool suppressVerbose=true) noexcept;
 
bool os_queue_receive_ex(OS_Queue& queue, void* message, OS_Ulong wait_option = OS_WAIT_FOREVER,
                        bool suppressVerbose=true) noexcept;
 
//=============//
// TIMER
//=============//
bool os_timer_create_ex ( OS_Timer& timer, const char* name, void (*callback)(uint32_t),
                     uint32_t callbackExpirationInput, uint32_t initialTimeoutTicks,
                     uint32_t rescheduleTimeoutTicks, OS_Uint autoActivate,
                     bool suppressVerbose=true ) noexcept;
 
bool os_timer_deactivate_and_delete_ex( OS_Timer& timer, bool suppressVerbose=true) noexcept;
 
bool os_timer_activate_ex( OS_Timer& timer, bool suppressVerbose=true) noexcept;
 
bool os_timer_deactivate_ex( OS_Timer& timer, bool suppressVerbose=true) noexcept;
 
//=============//
// SEMAPHORES
//=============//
 
bool os_semaphore_create_ex(OS_Semaphore* txSemaphore, const char* name, OS_Uint initial_count,
                       bool suppressVerbose=true) noexcept;
 
bool os_semaphore_delete_ex(OS_Semaphore *txSemaphore, bool suppressVerbose=true) noexcept;
 
bool os_semaphore_put_ex(OS_Semaphore* txSemaphore, bool suppressVerbose=true) noexcept;
 
bool os_semaphore_get_ex(OS_Semaphore* txSemaphore, OS_Ulong wait_option,
                    bool suppressVerbose=true) noexcept;
 
OS_Ulong os_semaphore_get_count_ex(OS_Semaphore *txSemaphore, bool suppressVerbose=true) noexcept;
 
//=============//
// EVENTS
//=============//
 
bool os_event_flags_create_ex(OS_EventGroup& eventFlags, const char* name, bool suppressVerbose=true) noexcept;
 
bool os_event_flags_delete_ex(OS_EventGroup& eventFlags, bool suppressVerbose=true) noexcept;
 
bool os_event_flags_set_ex(OS_EventGroup& eventFlags, OS_Ulong flagsToSet,
                     bool suppressVerbose=true) noexcept;
 
bool os_event_flags_clear_ex(OS_EventGroup& eventFlags, OS_Ulong flagsToClear,
                       bool suppressVerbose=true) noexcept;
 
bool os_event_flags_get_ex(OS_EventGroup& eventFlags, OS_Ulong flagsToGet,
                     OS_Uint getOption, OS_Ulong& actualFlags,
                     OS_Ulong wait_option, bool suppressVerbose=true) noexcept;
 
//=============//
//=============//
 
#ifdef __cplusplus
}
#endif
 
#endif /* HF_RTOS_FREERTOS || HF_RTOS_THREADX || HF_RTOS_CMSIS */
 
/* ═══════════════════════════════════════════════════════════════════════════
 * RTOS_NONE  — inline no-op stubs for _ex functions (OsUtility.cpp not compiled)
 * ═══════════════════════════════════════════════════════════════════════════ */
#if defined(HF_RTOS_NONE) || defined(HF_MCU_FAMILY_NONE)
 
#ifdef __cplusplus
/* Host SIL / HF_RTOS_NONE: identity conversion so headers that call
 * os_convert_msec_to_delay_ticks (RtosMutex and other headers) compile
 * without pulling an RTOS. 1 ms == 1 tick. */
static constexpr uint32_t osTickRateHz = 1000;
 
constexpr uint32_t os_convert_msec_to_delay_ticks(uint32_t milliseconds)
{
  return milliseconds * osTickRateHz / 1000U;
}
 
constexpr uint32_t os_convert_delay_ticks_to_msec(uint32_t delayTicks)
{
  return (delayTicks * 1000U) / osTickRateHz;
}
 
constexpr uint32_t os_convert_hz_to_delay_ticks(uint32_t frequency)
{
  if (frequency == 0U) return 0U;
  const uint32_t ticks = osTickRateHz / frequency;
  return (ticks == 0U) ? 1U : ticks;
}
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined(HF_RTOS_NONE_EXTERNAL_CLOCK)
/* Time comes from the integrator's clock (see os/os_none.h). */
static inline void os_delay_msec(uint16_t msec) { hf_os_none_delay_us((uint64_t)msec * 1000U); }
static inline void os_delay_time(uint32_t t, time_unit_t u)
{
  if (u == TIME_UNIT_US) {
    hf_os_none_delay_us((uint64_t)t);
  } else if (u == TIME_UNIT_MS) {
    hf_os_none_delay_us((uint64_t)t * 1000U);
  } else if (u == TIME_UNIT_S) {
    hf_os_none_delay_us((uint64_t)t * 1000000U);
  }
}
static inline uint32_t os_get_elapsed_time_msec() { return (uint32_t)(hf_os_none_clock_us() / 1000U); }
#else
static inline void os_delay_msec(uint16_t msec) { (void)msec; }
static inline void os_delay_time(uint32_t t, time_unit_t u) { (void)t; (void)u; }
static inline uint32_t os_get_elapsed_time_msec() { return 0; }
#endif
static inline uint32_t os_get_elapsed_processor_cycle_count(uint32_t s, time_unit_t u) { (void)s; (void)u; return 0; }
static inline uint32_t os_get_processor_cycle_count() { return 0; }
static inline void os_stack_fault_handler(OS_Thread* t) { (void)t; }
 
#ifdef __cplusplus
}
#endif
 
// Mutex _ex stubs
static inline bool os_mutex_create_ex(OS_Mutex&, const char*, OS_Uint = 0, bool = true) noexcept { return true; }
static inline bool os_mutex_get_ex(OS_Mutex&, OS_Ulong, bool = true) noexcept { return true; }
static inline bool os_mutex_put_ex(OS_Mutex&, bool = true) noexcept { return true; }
static inline bool os_mutex_delete_ex(OS_Mutex&, bool = true) noexcept { return true; }
static inline bool os_mutex_create_p(OS_Mutex*, const char*, OS_Uint = 0, bool = true) noexcept { return true; }
static inline bool os_mutex_get_p(OS_Mutex*, OS_Ulong, bool = true) noexcept { return true; }
static inline bool os_mutex_put_p(OS_Mutex*, bool = true) noexcept { return true; }
static inline bool os_mutex_delete_p(OS_Mutex*, bool = true) noexcept { return true; }
 
// Thread _ex stubs
static inline bool os_thread_create_ex(OS_Thread*, const char*, void (*)(OS_Ulong), OS_Ulong,
                                       uint8_t*, OS_Ulong, OS_Uint, OS_Uint, OS_Ulong,
                                       OS_Uint, bool = true) noexcept { return true; }
static inline bool os_thread_create_ex_pinned(OS_Thread*, const char*, void (*)(OS_Ulong), OS_Ulong,
                                              uint8_t*, OS_Ulong, OS_Uint, OS_Uint, OS_Ulong,
                                              OS_Uint, int /*core_id*/, bool = true) noexcept { return true; }
static inline bool os_thread_resume_ex(OS_Thread*, bool = true) { return true; }
static inline bool os_thread_resume_if_suspended(OS_Thread*, bool = true) noexcept { return true; }
static inline bool os_thread_suspend_ex(OS_Thread*, bool = true) { return true; }
static inline bool os_thread_delete_ex(OS_Thread*, bool = true) noexcept { return true; }
 
// Queue _ex stubs
static inline bool os_queue_create_ex(OS_Queue&, const char*, OS_Uint, void*, OS_Ulong, bool = true) noexcept { return true; }
static inline bool os_queue_delete_ex(OS_Queue&, bool = true) noexcept { return true; }
static inline bool os_queue_send_ex(OS_Queue&, void*, OS_Ulong = 0xFFFFFFFFUL, bool = true) noexcept { return true; }
static inline bool os_queue_receive_ex(OS_Queue&, void*, OS_Ulong = 0xFFFFFFFFUL, bool = true) noexcept { return false; }
 
// Timer _ex stubs
static inline bool os_timer_create_ex(OS_Timer&, const char*, void (*)(uint32_t), uint32_t, uint32_t, uint32_t, OS_Uint, bool = true) noexcept { return true; }
static inline bool os_timer_deactivate_and_delete_ex(OS_Timer&, bool = true) noexcept { return true; }
static inline bool os_timer_activate_ex(OS_Timer&, bool = true) noexcept { return true; }
static inline bool os_timer_deactivate_ex(OS_Timer&, bool = true) noexcept { return true; }
 
// Semaphore _ex stubs
static inline bool os_semaphore_create_ex(OS_Semaphore*, const char*, OS_Uint, bool = true) noexcept { return true; }
static inline bool os_semaphore_delete_ex(OS_Semaphore*, bool = true) noexcept { return true; }
static inline bool os_semaphore_put_ex(OS_Semaphore*, bool = true) noexcept { return true; }
static inline bool os_semaphore_get_ex(OS_Semaphore*, OS_Ulong, bool = true) noexcept { return true; }
static inline OS_Ulong os_semaphore_get_count_ex(OS_Semaphore*, bool = true) noexcept { return 0; }
 
// Event flags _ex stubs
static inline bool os_event_flags_create_ex(OS_EventGroup&, const char*, bool = true) noexcept { return true; }
static inline bool os_event_flags_delete_ex(OS_EventGroup&, bool = true) noexcept { return true; }
static inline bool os_event_flags_set_ex(OS_EventGroup&, OS_Ulong, bool = true) noexcept { return true; }
static inline bool os_event_flags_clear_ex(OS_EventGroup&, OS_Ulong, bool = true) noexcept { return true; }
static inline bool os_event_flags_get_ex(OS_EventGroup&, OS_Ulong, OS_Uint, OS_Ulong&, OS_Ulong, bool = true) noexcept { return true; }
 
#endif /* HF_RTOS_NONE / HF_MCU_FAMILY_NONE */
 
#endif // OS_UTILITY_H_