os-c-api.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2016-2025 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 */
 
/*
 * The code was originally inspired by ARM CMSIS cmsis_os.h file, v1.02,
 * and tries to remain functionally close to the CMSIS specifications.
 */
 
#ifndef CMSIS_PLUS_RTOS_OS_C_API_H_
#define CMSIS_PLUS_RTOS_OS_C_API_H_
 
// ----------------------------------------------------------------------------
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
// Include the µOS++ C API structures declarations.
#include <cmsis-plus/rtos/os-c-decls.h>
 
#include <cmsis-plus/rtos/os-hooks.h>
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
 
// ----------------------------------------------------------------------------
 
#ifdef __cplusplus
extern "C"
{
#endif
 
  // --------------------------------------------------------------------------
  enum
  {
    os_ok = 0
  };
 
  // --------------------------------------------------------------------------
  int
  os_main (int argc, char* argv[]);
 
  // --------------------------------------------------------------------------
  os_result_t
  os_sched_initialize (void);
 
  void __attribute__ ((noreturn))
  os_sched_start (void);
 
  bool
  os_sched_is_started (void);
 
  os_sched_state_t
  os_sched_lock (void);
 
  os_sched_state_t
  os_sched_unlock (void);
 
  os_sched_state_t
  os_sched_set_locked (os_sched_state_t state);
 
  bool
  os_sched_is_locked (void);
 
  bool
  os_sched_is_preemptive (void);
 
  bool
  os_sched_set_preemptive (bool state);
 
  // --------------------------------------------------------------------------
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES)
 
  os_statistics_counter_t
  os_sched_stat_get_context_switches (void);
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) */
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES)
 
  os_statistics_duration_t
  os_sched_stat_get_cpu_cycles (void);
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES) */
 
  // --------------------------------------------------------------------------
  bool
  os_irq_in_handler_mode (void);
 
  os_irq_state_t
  os_irq_critical_enter (void);
 
  void
  os_irq_critical_exit (os_irq_state_t state);
 
  // --------------------------------------------------------------------------
 
  os_irq_state_t
  os_irq_uncritical_enter (void);
 
  void
  os_irq_uncritical_exit (os_irq_state_t state);
 
#if defined(OS_HAS_INTERRUPTS_STACK) || defined(__DOXYGEN__)
 
  os_thread_stack_t*
  os_irq_get_stack (void);
 
#endif
 
  // --------------------------------------------------------------------------
  os_thread_t*
  os_this_thread (void);
 
  void
  os_this_thread_suspend (void);
 
  void __attribute__ ((noreturn))
  os_this_thread_exit (void* exit_ptr);
 
  os_result_t
  os_this_thread_flags_wait (os_flags_mask_t mask, os_flags_mask_t* oflags,
                             os_flags_mode_t mode);
 
  os_result_t
  os_this_thread_flags_try_wait (os_flags_mask_t mask, os_flags_mask_t* oflags,
                                 os_flags_mode_t mode);
 
  os_result_t
  os_this_thread_flags_timed_wait (os_flags_mask_t mask,
                                   os_clock_duration_t timeout,
                                   os_flags_mask_t* oflags,
                                   os_flags_mode_t mode);
 
  os_result_t
  os_this_thread_flags_clear (os_flags_mask_t mask, os_flags_mask_t* oflags);
 
  os_flags_mask_t
  os_this_thread_flags_get (os_flags_mask_t mask, os_flags_mode_t mode);
 
  // --------------------------------------------------------------------------
  void
  os_thread_attr_init (os_thread_attr_t* attr);
 
  void
  os_thread_construct (os_thread_t* thread, const char* name,
                       os_thread_func_t func, const os_thread_func_args_t args,
                       const os_thread_attr_t* attr);
 
  void
  os_thread_destruct (os_thread_t* thread);
 
  os_thread_t*
  os_thread_new (const char* name, os_thread_func_t func,
                 const os_thread_func_args_t args,
                 const os_thread_attr_t* attr);
 
  void
  os_thread_delete (os_thread_t* thread);
 
  bool
  os_thread_is_constructed (os_thread_t* thread);
 
  const char*
  os_thread_get_name (os_thread_t* thread);
 
  os_thread_prio_t
  os_thread_get_priority (os_thread_t* thread);
 
  os_result_t
  os_thread_set_priority (os_thread_t* thread, os_thread_prio_t prio);
 
  os_result_t
  os_thread_kill (os_thread_t* thread);
 
  os_result_t
  os_thread_join (os_thread_t* thread, void** exit_ptr);
 
  void
  os_thread_resume (os_thread_t* thread);
 
  os_result_t
  os_thread_flags_raise (os_thread_t* thread, os_flags_mask_t mask,
                         os_flags_mask_t* oflags);
 
  os_thread_state_t
  os_thread_get_state (os_thread_t* thread);
 
#if defined(OS_INCLUDE_RTOS_CUSTOM_THREAD_USER_STORAGE) || defined(__DOXYGEN__)
 
  os_thread_user_storage_t*
  os_thread_get_user_storage (os_thread_t* thread);
 
#endif /* defined(OS_INCLUDE_RTOS_CUSTOM_THREAD_USER_STORAGE) */
 
  os_thread_stack_t*
  os_thread_get_stack (os_thread_t* thread);
 
  // --------------------------------------------------------------------------
#define os_thread_create os_thread_construct
#define os_thread_destroy os_thread_destruct
 
  // --------------------------------------------------------------------------
  size_t
  os_thread_stack_get_default_size (void);
 
  size_t
  os_thread_stack_set_default_size (size_t size_bytes);
 
  size_t
  os_thread_stack_get_min_size (void);
 
  size_t
  os_thread_stack_set_min_size (size_t size_bytes);
 
  os_thread_stack_element_t*
  os_thread_stack_get_bottom (os_thread_stack_t* stack);
 
  os_thread_stack_element_t*
  os_thread_stack_get_top (os_thread_stack_t* stack);
 
  size_t
  os_thread_stack_get_size (os_thread_stack_t* stack);
 
  size_t
  os_thread_stack_get_available (os_thread_stack_t* stack);
 
  bool
  os_thread_stack_check_bottom_magic (os_thread_stack_t* stack);
 
  bool
  os_thread_stack_check_top_magic (os_thread_stack_t* stack);
 
  // --------------------------------------------------------------------------
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES)
 
  os_statistics_counter_t
  os_thread_stat_get_context_switches (os_thread_t* thread);
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) */
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES)
 
  os_statistics_duration_t
  os_thread_stat_get_cpu_cycles (os_thread_t* thread);
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES) */
 
  // --------------------------------------------------------------------------
  os_iterator_t
  os_children_threads_iter_begin (os_thread_t* thread);
 
  os_iterator_t
  os_children_threads_iter_end (os_thread_t* thread);
 
  os_thread_t*
  os_children_threads_iter_get (os_iterator_t iterator);
 
  os_iterator_t
  os_children_threads_iter_next (os_iterator_t iterator);
 
  // --------------------------------------------------------------------------
  const char*
  os_clock_get_name (os_clock_t* clock);
 
  os_clock_timestamp_t
  os_clock_now (os_clock_t* clock);
 
  os_clock_timestamp_t
  os_clock_steady_now (os_clock_t* clock);
 
  os_result_t
  os_clock_sleep_for (os_clock_t* clock, os_clock_duration_t duration);
 
  os_result_t
  os_clock_sleep_until (os_clock_t* clock, os_clock_timestamp_t timestamp);
 
  os_result_t
  os_clock_wait_for (os_clock_t* clock, os_clock_duration_t timeout);
 
  os_clock_offset_t
  os_clock_get_offset (os_clock_t* clock);
 
  os_clock_offset_t
  os_clock_set_offset (os_clock_t* clock, os_clock_offset_t offset);
 
  os_clock_t*
  os_clock_get_sysclock (void);
 
  os_clock_t*
  os_clock_get_rtclock (void);
 
  os_clock_t*
  os_clock_get_hrclock (void);
 
  // --------------------------------------------------------------------------
 
  os_clock_timestamp_t
  os_sysclock_now (void);
 
  os_result_t
  os_sysclock_sleep_for (os_clock_duration_t duration);
 
  os_result_t
  os_sysclock_sleep_until (os_clock_timestamp_t timestamp);
 
  os_result_t
  os_sysclock_wait_for (os_clock_duration_t timeout);
 
#pragma GCC diagnostic push
#if defined(__cplusplus)
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
 
  inline os_clock_duration_t __attribute__ ((always_inline))
  os_sysclock_ticks_cast (uint32_t microsec)
  {
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#if defined(__cplusplus)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
#endif
    return (
        os_clock_duration_t)((((microsec)
                               * ((uint32_t)OS_INTEGER_SYSTICK_FREQUENCY_HZ))
                              + (uint32_t)1000000ul - 1)
                             / (uint32_t)1000000ul);
#pragma GCC diagnostic pop
  }
 
  inline os_clock_duration_t __attribute__ ((always_inline))
  os_sysclock_ticks_cast_long (uint64_t microsec)
  {
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#if defined(__cplusplus)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
#endif
    return (
        os_clock_duration_t)((((microsec)
                               * ((uint64_t)OS_INTEGER_SYSTICK_FREQUENCY_HZ))
                              + (uint64_t)1000000ul - 1)
                             / (uint64_t)1000000ul);
#pragma GCC diagnostic pop
  }
 
#pragma GCC diagnostic pop
 
  // --------------------------------------------------------------------------
  void
  os_timer_attr_init (os_timer_attr_t* attr);
 
  void
  os_timer_attr_periodic_init (os_timer_attr_t* attr);
 
  const os_timer_attr_t*
  os_timer_attr_get_periodic (void);
 
  void
  os_timer_construct (os_timer_t* timer, const char* name,
                      os_timer_func_t function, os_timer_func_args_t args,
                      const os_timer_attr_t* attr);
 
  void
  os_timer_destruct (os_timer_t* timer);
 
  os_timer_t*
  os_timer_new (const char* name, os_timer_func_t function,
                os_timer_func_args_t args, const os_timer_attr_t* attr);
 
  void
  os_timer_delete (os_timer_t* timer);
 
  const char*
  os_timer_get_name (os_timer_t* timer);
 
  os_result_t
  os_timer_start (os_timer_t* timer, os_clock_duration_t period);
 
  os_result_t
  os_timer_stop (os_timer_t* timer);
 
  // --------------------------------------------------------------------------
#define os_timer_create os_timer_construct
#define os_timer_destroy os_timer_destruct
 
  // --------------------------------------------------------------------------
  void
  os_mutex_attr_init (os_mutex_attr_t* attr);
 
  void
  os_mutex_attr_recursive_init (os_mutex_attr_t* attr);
 
  const os_mutex_attr_t*
  os_mutex_attr_get_recursive (void);
 
  void
  os_mutex_construct (os_mutex_t* mutex, const char* name,
                      const os_mutex_attr_t* attr);
 
  void
  os_mutex_recursive_construct (os_mutex_t* mutex, const char* name,
                                const os_mutex_attr_t* attr);
 
  void
  os_mutex_destruct (os_mutex_t* mutex);
 
  os_mutex_t*
  os_mutex_new (const char* name, const os_mutex_attr_t* attr);
 
  os_mutex_t*
  os_mutex_recursive_new (const char* name, const os_mutex_attr_t* attr);
 
  void
  os_mutex_delete (os_mutex_t* mutex);
 
  const char*
  os_mutex_get_name (os_mutex_t* mutex);
 
  os_result_t
  os_mutex_lock (os_mutex_t* mutex);
 
  os_result_t
  os_mutex_try_lock (os_mutex_t* mutex);
 
  os_result_t
  os_mutex_timed_lock (os_mutex_t* mutex, os_clock_duration_t timeout);
 
  os_result_t
  os_mutex_unlock (os_mutex_t* mutex);
 
  os_thread_prio_t
  os_mutex_get_prio_ceiling (os_mutex_t* mutex);
 
  os_result_t
  os_mutex_set_prio_ceiling (os_mutex_t* mutex, os_thread_prio_t prio_ceiling,
                             os_thread_prio_t* old_prio_ceiling);
 
  os_result_t
  os_mutex_mark_consistent (os_mutex_t* mutex);
 
  os_thread_t*
  os_mutex_get_owner (os_mutex_t* mutex);
 
  os_mutex_type_t
  os_mutex_get_type (os_mutex_t* mutex);
 
  os_mutex_protocol_t
  os_mutex_get_protocol (os_mutex_t* mutex);
 
  os_mutex_robustness_t
  os_mutex_get_robustness (os_mutex_t* mutex);
 
  os_result_t
  os_mutex_reset (os_mutex_t* mutex);
 
  // --------------------------------------------------------------------------
#define os_mutex_create os_mutex_construct
#define os_mutex_recursive_create os_mutex_recursive_construct
#define os_mutex_destroy os_mutex_destruct
 
  // --------------------------------------------------------------------------
  void
  os_condvar_attr_init (os_condvar_attr_t* attr);
 
  void
  os_condvar_construct (os_condvar_t* condvar, const char* name,
                        const os_condvar_attr_t* attr);
 
  void
  os_condvar_destruct (os_condvar_t* condvar);
 
  os_condvar_t*
  os_condvar_new (const char* name, const os_condvar_attr_t* attr);
 
  void
  os_condvar_delete (os_condvar_t* condvar);
 
  const char*
  os_condvar_get_name (os_condvar_t* condvar);
 
  os_result_t
  os_condvar_signal (os_condvar_t* condvar);
 
  os_result_t
  os_condvar_broadcast (os_condvar_t* condvar);
 
  os_result_t
  os_condvar_wait (os_condvar_t* condvar, os_mutex_t* mutex);
 
  os_result_t
  os_condvar_timed_wait (os_condvar_t* condvar, os_mutex_t* mutex,
                         os_clock_duration_t timeout);
 
  // --------------------------------------------------------------------------
#define os_condvar_create os_condvar_construct
#define os_condvar_destroy os_condvar_destruct
 
  // --------------------------------------------------------------------------
  void
  os_semaphore_attr_init (os_semaphore_attr_t* attr);
 
  void
  os_semaphore_attr_binary_init (os_semaphore_attr_t* attr,
                                 const os_semaphore_count_t initial_value);
 
  void
  os_semaphore_attr_counting_init (os_semaphore_attr_t* attr,
                                   const os_semaphore_count_t max_value,
                                   const os_semaphore_count_t initial_value);
 
  const os_semaphore_attr_t*
  os_semaphore_attr_get_binary (void);
 
  void
  os_semaphore_construct (os_semaphore_t* semaphore, const char* name,
                          const os_semaphore_attr_t* attr);
 
  void
  os_semaphore_binary_construct (os_semaphore_t* semaphore, const char* name,
                                 const os_semaphore_count_t initial_value);
 
  void
  os_semaphore_counting_construct (os_semaphore_t* semaphore, const char* name,
                                   const os_semaphore_count_t max_value,
                                   const os_semaphore_count_t initial_value);
 
  void
  os_semaphore_destruct (os_semaphore_t* semaphore);
 
  os_semaphore_t*
  os_semaphore_new (const char* name, const os_semaphore_attr_t* attr);
 
  os_semaphore_t*
  os_semaphore_binary_new (const char* name,
                           const os_semaphore_count_t initial_value);
 
  os_semaphore_t*
  os_semaphore_counting_new (const char* name,
                             const os_semaphore_count_t max_value,
                             const os_semaphore_count_t initial_value);
 
  void
  os_semaphore_delete (os_semaphore_t* semaphore);
 
  const char*
  os_semaphore_get_name (os_semaphore_t* semaphore);
 
  os_result_t
  os_semaphore_post (os_semaphore_t* semaphore);
 
  os_result_t
  os_semaphore_wait (os_semaphore_t* semaphore);
 
  os_result_t
  os_semaphore_try_wait (os_semaphore_t* semaphore);
 
  os_result_t
  os_semaphore_timed_wait (os_semaphore_t* semaphore,
                           os_clock_duration_t timeout);
 
  os_semaphore_count_t
  os_semaphore_get_value (os_semaphore_t* semaphore);
 
  os_result_t
  os_semaphore_reset (os_semaphore_t* semaphore);
 
  os_semaphore_count_t
  os_semaphore_get_initial_value (os_semaphore_t* semaphore);
 
  os_semaphore_count_t
  os_semaphore_get_max_value (os_semaphore_t* semaphore);
 
#define os_semaphore_create os_semaphore_construct
#define os_semaphore_binary_create os_semaphore_binary_construct
#define os_semaphore_counting_create os_semaphore_counting_construct
#define os_semaphore_destroy os_semaphore_destruct
 
  // --------------------------------------------------------------------------
  void
  os_mempool_attr_init (os_mempool_attr_t* attr);
 
  void
  os_mempool_construct (os_mempool_t* mempool, const char* name, size_t blocks,
                        size_t block_size_bytes,
                        const os_mempool_attr_t* attr);
 
  void
  os_mempool_destruct (os_mempool_t* mempool);
 
  os_mempool_t*
  os_mempool_new (const char* name, size_t blocks, size_t block_size_bytes,
                  const os_mempool_attr_t* attr);
 
  void
  os_mempool_delete (os_mempool_t* mempool);
 
  const char*
  os_mempool_get_name (os_mempool_t* mempool);
 
  void*
  os_mempool_alloc (os_mempool_t* mempool);
 
  void*
  os_mempool_try_alloc (os_mempool_t* mempool);
 
  void*
  os_mempool_timed_alloc (os_mempool_t* mempool, os_clock_duration_t timeout);
 
  os_result_t
  os_mempool_free (os_mempool_t* mempool, void* block);
 
  size_t
  os_mempool_get_capacity (os_mempool_t* mempool);
 
  size_t
  os_mempool_get_count (os_mempool_t* mempool);
 
  size_t
  os_mempool_get_block_size (os_mempool_t* mempool);
 
  bool
  os_mempool_is_empty (os_mempool_t* mempool);
 
  bool
  os_mempool_is_full (os_mempool_t* mempool);
 
  os_result_t
  os_mempool_reset (os_mempool_t* mempool);
 
  void*
  os_mempool_get_pool (os_mempool_t* mempool);
 
#define os_mempool_create os_mempool_construct
#define os_mempool_destroy os_mempool_destruct
 
  // --------------------------------------------------------------------------
  void
  os_mqueue_attr_init (os_mqueue_attr_t* attr);
 
  void
  os_mqueue_construct (os_mqueue_t* mqueue, const char* name, size_t msgs,
                       size_t msg_size_bytes, const os_mqueue_attr_t* attr);
 
  void
  os_mqueue_destruct (os_mqueue_t* mqueue);
 
  os_mqueue_t*
  os_mqueue_new (const char* name, size_t msgs, size_t msg_size_bytes,
                 const os_mqueue_attr_t* attr);
 
  void
  os_mqueue_delete (os_mqueue_t* mqueue);
 
  const char*
  os_mqueue_get_name (os_mqueue_t* mqueue);
 
  os_result_t
  os_mqueue_send (os_mqueue_t* mqueue, const void* msg, size_t nbytes,
                  os_mqueue_prio_t mprio);
 
  os_result_t
  os_mqueue_try_send (os_mqueue_t* mqueue, const void* msg, size_t nbytes,
                      os_mqueue_prio_t mprio);
 
  os_result_t
  os_mqueue_timed_send (os_mqueue_t* mqueue, const void* msg, size_t nbytes,
                        os_clock_duration_t timeout, os_mqueue_prio_t mprio);
 
  os_result_t
  os_mqueue_receive (os_mqueue_t* mqueue, void* msg, size_t nbytes,
                     os_mqueue_prio_t* mprio);
 
  os_result_t
  os_mqueue_try_receive (os_mqueue_t* mqueue, void* msg, size_t nbytes,
                         os_mqueue_prio_t* mprio);
 
  os_result_t
  os_mqueue_timed_receive (os_mqueue_t* mqueue, void* msg, size_t nbytes,
                           os_clock_duration_t timeout,
                           os_mqueue_prio_t* mprio);
 
  size_t
  os_mqueue_get_capacity (os_mqueue_t* mqueue);
 
  size_t
  os_mqueue_get_length (os_mqueue_t* mqueue);
 
  size_t
  os_mqueue_get_msg_size (os_mqueue_t* mqueue);
 
  bool
  os_mqueue_is_empty (os_mqueue_t* mqueue);
 
  bool
  os_mqueue_is_full (os_mqueue_t* mqueue);
 
  os_result_t
  os_mqueue_reset (os_mqueue_t* mqueue);
 
#define os_mqueue_create os_mqueue_construct
#define os_mqueue_destroy os_mqueue_destruct
 
  // --------------------------------------------------------------------------
  void
  os_evflags_attr_init (os_evflags_attr_t* attr);
 
  void
  os_evflags_construct (os_evflags_t* evflags, const char* name,
                        const os_evflags_attr_t* attr);
 
  void
  os_evflags_destruct (os_evflags_t* evflags);
 
  os_evflags_t*
  os_evflags_new (const char* name, const os_evflags_attr_t* attr);
 
  void
  os_evflags_delete (os_evflags_t* evflags);
 
  const char*
  os_evflags_get_name (os_evflags_t* evflags);
 
  os_result_t
  os_evflags_wait (os_evflags_t* evflags, os_flags_mask_t mask,
                   os_flags_mask_t* oflags, os_flags_mode_t mode);
 
  os_result_t
  os_evflags_try_wait (os_evflags_t* evflags, os_flags_mask_t mask,
                       os_flags_mask_t* oflags, os_flags_mode_t mode);
 
  os_result_t
  os_evflags_timed_wait (os_evflags_t* evflags, os_flags_mask_t mask,
                         os_clock_duration_t timeout, os_flags_mask_t* oflags,
                         os_flags_mode_t mode);
 
  os_result_t
  os_evflags_raise (os_evflags_t* evflags, os_flags_mask_t mask,
                    os_flags_mask_t* oflags);
 
  os_result_t
  os_evflags_clear (os_evflags_t* evflags, os_flags_mask_t mask,
                    os_flags_mask_t* oflags);
 
  os_flags_mask_t
  os_evflags_get (os_evflags_t* evflags, os_flags_mask_t mask,
                  os_flags_mode_t mode);
 
  bool
  os_evflags_are_waiting (os_evflags_t* evflags);
 
#define os_evflags_create os_evflags_construct
#define os_evflags_destroy os_evflags_destruct
 
  // --------------------------------------------------------------------------
  os_memory_t*
  os_memory_get_default (void);
 
  void*
  os_memory_allocate (os_memory_t* memory, size_t bytes, size_t alignment);
 
  void
  os_memory_deallocate (os_memory_t* memory, void* addr, size_t bytes,
                        size_t alignment);
 
  void
  os_memory_reset (os_memory_t* memory);
 
  bool
  os_memory_coalesce (os_memory_t* memory);
 
  size_t
  os_memory_get_total_bytes (os_memory_t* memory);
 
  size_t
  os_memory_get_allocated_bytes (os_memory_t* memory);
 
  size_t
  os_memory_get_free_bytes (os_memory_t* memory);
 
  size_t
  os_memory_get_allocated_chunks (os_memory_t* memory);
 
  size_t
  os_memory_get_free_chunks (os_memory_t* memory);
 
// --------------------------------------------------------------------------
#ifdef __cplusplus
}
#endif
 
// ----------------------------------------------------------------------------
 
#endif /* CMSIS_PLUS_RTOS_OS_C_API_H_ */