RTOS API for bare metal

Provide partial RTOS API for bare metal builds - things that
can be done in a single threaded environment.

Allows more code to work in both RTOS and bare metal builds without
change, and in particular gives easy access to the ability to
efficiently wait for something occurring in interrupt.

Available in bare-metal:
* ThisThread
* osThreadFlagsSet to set flags on main thread (can be set from IRQ)
* EventFlags (can be set from IRQ)
* Semaphores (can be released from IRQ)
* Mutex (dummy implementation)

Not useful:
* ConditionVariable (could only be signalled from 2nd thread)
* RtosTimer (calls in a second thread context)
* Thread

Unimplemented:
* Mail, Queue, MemoryPool

Possible future work:
* ConditionVariableCS to act as IRQ signalled ConditionVariable

Author: kjbracey

mbed.h

@@ -18,7 +18,7 @@
 
 #include "platform/mbed_version.h"
 
-#if MBED_CONF_RTOS_PRESENT
+#if MBED_CONF_RTOS_API_PRESENT
 #include "rtos/rtos.h"
 #endif
 

rtos/ConditionVariable.cpp

@@ -26,6 +26,8 @@
 #include "mbed_error.h"
 #include "mbed_assert.h"
 
+#if MBED_CONF_RTOS_PRESENT
+
 namespace rtos {
 
 ConditionVariable::Waiter::Waiter(): sem(0), prev(NULL), next(NULL), in_list(false)
@@ -151,3 +153,5 @@ ConditionVariable::~ConditionVariable()
 }
 
 }
+
+#endif

rtos/ConditionVariable.h

@@ -23,12 +23,14 @@
 #define CONDITIONVARIABLE_H
 
 #include <stdint.h>
-#include "cmsis_os.h"
+#include "mbed_rtos_types.h"
 #include "rtos/Mutex.h"
 #include "rtos/Semaphore.h"
 
 #include "platform/NonCopyable.h"
 
+#if MBED_CONF_RTOS_PRESENT || defined(DOXYGEN_ONLY)
+
 namespace rtos {
 /** \addtogroup rtos */
 /** @{*/
@@ -328,4 +330,6 @@ class ConditionVariable : private mbed::NonCopyable<ConditionVariable> {
 }
 #endif
 
+#endif
+
 /** @}*/

rtos/EventFlags.cpp

@@ -20,6 +20,8 @@
  * SOFTWARE.
  */
 #include "rtos/EventFlags.h"
+#include "rtos/ThisThread.h"
+#include "mbed_os_timer.h"
 #include <string.h>
 #include "mbed_error.h"
 #include "mbed_assert.h"
@@ -38,27 +40,43 @@ EventFlags::EventFlags(const char *name)
 
 void EventFlags::constructor(const char *name)
 {
+#if MBED_CONF_RTOS_PRESENT
     osEventFlagsAttr_t attr = { 0 };
     attr.name = name ? name : "application_unnamed_event_flags";
     attr.cb_mem = &_obj_mem;
     attr.cb_size = sizeof(_obj_mem);
     _id = osEventFlagsNew(&attr);
     MBED_ASSERT(_id);
+#else
+    _flags = 0;
+#endif
 }
 
 uint32_t EventFlags::set(uint32_t flags)
 {
+#if MBED_CONF_RTOS_PRESENT
     return osEventFlagsSet(_id, flags);
+#else
+    return core_util_atomic_fetch_or_u32(&_flags, flags) | flags;
+#endif
 }
 
 uint32_t EventFlags::clear(uint32_t flags)
 {
+#if MBED_CONF_RTOS_PRESENT
     return osEventFlagsClear(_id, flags);
+#else
+    return core_util_atomic_fetch_and_u32(&_flags, ~flags);
+#endif
 }
 
 uint32_t EventFlags::get() const
 {
+#if MBED_CONF_RTOS_PRESENT
     return osEventFlagsGet(_id);
+#else
+    return core_util_atomic_load_u32(&_flags);
+#endif
 }
 
 uint32_t EventFlags::wait_all(uint32_t flags, uint32_t millisec, bool clear)
@@ -73,7 +91,9 @@ uint32_t EventFlags::wait_any(uint32_t flags, uint32_t millisec, bool clear)
 
 EventFlags::~EventFlags()
 {
+#if MBED_CONF_RTOS_PRESENT
     osEventFlagsDelete(_id);
+#endif
 }
 
 uint32_t EventFlags::wait(uint32_t flags, uint32_t opt, uint32_t millisec, bool clear)
@@ -82,7 +102,24 @@ uint32_t EventFlags::wait(uint32_t flags, uint32_t opt, uint32_t millisec, bool
         opt |= osFlagsNoClear;
     }
 
+#if MBED_CONF_RTOS_PRESENT
     return osEventFlagsWait(_id, flags, opt, millisec);
+#else
+    rtos::internal::flags_check_capture check;
+    check.flags = &_flags;
+    check.options = opt;
+    check.flags_wanted = flags;
+    check.result = 0;
+    check.match = false;
+    mbed::internal::do_timed_sleep_relative_or_forever(millisec, rtos::internal::non_rtos_check_flags, &check);
+    if (check.match) {
+        return check.result;
+    } else if (millisec == 0) {
+        return osErrorResource;
+    } else {
+        return osErrorTimeout;
+    }
+#endif
 }
 
 }

rtos/EventFlags.h

@@ -23,7 +23,7 @@
 #define EVENT_FLAG_H
 
 #include <stdint.h>
-#include "cmsis_os2.h"
+#include "mbed_rtos_types.h"
 #include "mbed_rtos1_types.h"
 #include "mbed_rtos_storage.h"
 
@@ -114,8 +114,12 @@ class EventFlags : private mbed::NonCopyable<EventFlags> {
 private:
     void constructor(const char *name = NULL);
     uint32_t wait(uint32_t flags, uint32_t opt, uint32_t millisec, bool clear);
+#if MBED_CONF_RTOS_PRESENT
     osEventFlagsId_t                _id;
     mbed_rtos_storage_event_flags_t _obj_mem;
+#else
+    uint32_t _flags;
+#endif
 };
 
 /** @}*/

rtos/Kernel.cpp

@@ -20,16 +20,17 @@
  * SOFTWARE.
  */
 
-#include "cmsis_os2.h"
 #include "rtos/Kernel.h"
 #include "rtos/rtos_idle.h"
 #include "rtos/rtos_handlers.h"
 #include "platform/mbed_critical.h"
+#include "platform/mbed_os_timer.h"
 
 namespace rtos {
 
 uint64_t Kernel::get_ms_count()
 {
+#if MBED_CONF_RTOS_PRESENT
     // CMSIS-RTOS 2.1.0 and 2.1.1 differ in the time type. We assume
     // our header at least matches the implementation, so we don't try looking
     // at the run-time version report. (There's no compile-time version report)
@@ -61,8 +62,12 @@ uint64_t Kernel::get_ms_count()
         core_util_critical_section_exit();
         return ret;
     }
+#else
+    return mbed::internal::init_os_timer()->update_and_get_tick();
+#endif
 }
 
+#if MBED_CONF_RTOS_PRESENT
 void Kernel::attach_idle_hook(void (*fptr)(void))
 {
     rtos_attach_idle_hook(fptr);
@@ -72,5 +77,6 @@ void Kernel::attach_thread_terminate_hook(void (*fptr)(osThreadId_t id))
 {
     rtos_attach_thread_terminate_hook(fptr);
 }
+#endif
 
 }

rtos/Kernel.h

@@ -23,7 +23,7 @@
 #define KERNEL_H
 
 #include <stdint.h>
-#include "cmsis_os2.h"
+#include "mbed_rtos_types.h"
 
 namespace rtos {
 /** \addtogroup rtos */

rtos/LICENSE.md

@@ -3,7 +3,6 @@ as can be found: LICENSE-apache-2.0.txt.
 
 Files licensed under MIT:
 
-- TARGET_CORTEX/mbed_rtos1_types.h
 - TARGET_CORTEX/mbed_rtos_storage.h
 - TARGET_CORTEX/mbed_rtx_conf.h
 - TARGET_CORTEX/mbed_rtx_idle.cpp

rtos/Mail.h

@@ -27,7 +27,7 @@
 
 #include "Queue.h"
 #include "MemoryPool.h"
-#include "cmsis_os2.h"
+#include "mbed_rtos_types.h"
 #include "mbed_rtos_storage.h"
 #include "mbed_rtos1_types.h"
 
@@ -38,6 +38,8 @@
 using namespace rtos;
 #endif
 
+#if MBED_CONF_RTOS_PRESENT || defined(DOXYGEN_ONLY)
+
 namespace rtos {
 /** \addtogroup rtos */
 /** @{*/
@@ -238,5 +240,5 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {
 
 #endif
 
-
+#endif
 

rtos/MemoryPool.h

@@ -25,11 +25,12 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "cmsis_os2.h"
+#include "mbed_rtos_types.h"
 #include "mbed_rtos1_types.h"
 #include "mbed_rtos_storage.h"
 #include "platform/NonCopyable.h"
 
+#if MBED_CONF_RTOS_PRESENT || defined(DOXYGEN_ONLY)
 namespace rtos {
 /** \addtogroup rtos */
 /** @{*/
@@ -193,4 +194,6 @@ class MemoryPool : private mbed::NonCopyable<MemoryPool<T, pool_sz> > {
 }
 #endif
 
+#endif
+
 

rtos/Mutex.cpp

@@ -26,9 +26,11 @@
 #include "mbed_error.h"
 #include "mbed_assert.h"
 
+#if MBED_CONF_RTOS_PRESENT
+
 namespace rtos {
 
-Mutex::Mutex(): _count(0)
+Mutex::Mutex()
 {
     constructor();
 }
@@ -40,6 +42,7 @@ Mutex::Mutex(const char *name)
 
 void Mutex::constructor(const char *name)
 {
+    _count = 0;
     osMutexAttr_t attr =
     { 0 };
     attr.name = name ? name : "application_unnamed_mutex";
@@ -147,3 +150,5 @@ Mutex::~Mutex()
 }
 
 }
+
+#endif

rtos/Mutex.h

@@ -23,7 +23,7 @@
 #define MUTEX_H
 
 #include <stdint.h>
-#include "cmsis_os2.h"
+#include "mbed_rtos_types.h"
 #include "mbed_rtos1_types.h"
 #include "mbed_rtos_storage.h"
 
@@ -56,6 +56,8 @@ typedef mbed::ScopedLock<Mutex> ScopedMutexLock;
 /** The Mutex class is used to synchronize the execution of threads.
  This is, for example, used to protect access to a shared resource.
 
+ In bare-metal builds, the Mutex class is a dummy, so lock() and unlock() are no-ops.
+
  @note You cannot use member functions of this class in ISR context. If you require Mutex functionality within
  ISR handler, consider using @a Semaphore.
 
@@ -88,7 +90,11 @@ class Mutex : private mbed::NonCopyable<Mutex> {
       @note This function treats RTOS errors as fatal system errors, so it can only return osOK.
             Use of the return value is deprecated, as the return is expected to become void in the future.
      */
-    osStatus lock(void);
+#if MBED_CONF_RTOS_PRESENT
+    osStatus lock();
+#else
+    void lock(); // Value return backwards compatibility not required for non-RTOS
+#endif
 
     /**
       Wait until a Mutex becomes available.
@@ -150,14 +156,18 @@ class Mutex : private mbed::NonCopyable<Mutex> {
       @note This function treats RTOS errors as fatal system errors, so it can only return osOK.
             Use of the return value is deprecated, as the return is expected to become void in the future.
      */
+#if MBED_CONF_RTOS_PRESENT
     osStatus unlock();
+#else
+    void unlock(); // Value return backwards compatibility not required for non-RTOS
+#endif
 
     /** Get the owner the this mutex
       @return  the current owner of this mutex.
 
       @note You cannot call this function from ISR context.
      */
-    osThreadId get_owner();
+    osThreadId_t get_owner();
 
     /** Mutex destructor
      *
@@ -166,13 +176,53 @@ class Mutex : private mbed::NonCopyable<Mutex> {
     ~Mutex();
 
 private:
+#if MBED_CONF_RTOS_PRESENT
     void constructor(const char *name = NULL);
     friend class ConditionVariable;
 
     osMutexId_t               _id;
     mbed_rtos_storage_mutex_t _obj_mem;
     uint32_t                  _count;
+#endif
 };
+
+#if !MBED_CONF_RTOS_PRESENT
+inline Mutex::Mutex()
+{
+}
+
+inline Mutex::Mutex(const char *)
+{
+}
+
+inline Mutex::~Mutex()
+{
+}
+
+inline void Mutex::lock()
+{
+}
+
+inline bool Mutex::trylock()
+{
+    return true;
+}
+
+inline bool Mutex::trylock_for(uint32_t)
+{
+    return true;
+}
+
+inline bool Mutex::trylock_until(uint64_t)
+{
+    return true;
+}
+
+inline void Mutex::unlock()
+{
+}
+#endif
+
 /** @}*/
 /** @}*/
 }