initHEADmaster

32 files changed, 7207 insertions, 0 deletions

diff --git a/lib/chibios/os/various/cpp_wrappers/ch.cpp b/lib/chibios/os/various/cpp_wrappers/ch.cpp
new file mode 100644
index 000000000..155e56ebc
--- /dev/null
+++ b/lib/chibios/os/various/cpp_wrappers/ch.cpp
@@ -0,0 +1,45 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+/**
+ * @file    ch.cpp
+ * @brief   C++ wrapper code.
+ *
+ * @addtogroup cpp_library
+ * @{
+ */
+
+#include "ch.hpp"
+
+namespace chibios_rt {
+
+#if (CH_CFG_NO_IDLE_THREAD == FALSE) || defined(__DOXYGEN__)
+  ThreadReference System::getIdleThreadX(void) {
+
+    return ThreadReference(chSysGetIdleThreadX());
+  }
+#endif /* CH_CFG_NO_IDLE_THREAD == FALSE */
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::BaseStaticThread                                           *
+   *------------------------------------------------------------------------*/
+
+  void _thd_start(void *arg) {
+
+    ((BaseThread *)arg)->main();
+  }
+}
+
+/** @} */
diff --git a/lib/chibios/os/various/cpp_wrappers/ch.hpp b/lib/chibios/os/various/cpp_wrappers/ch.hpp
new file mode 100644
index 000000000..5c2e022e1
--- /dev/null
+++ b/lib/chibios/os/various/cpp_wrappers/ch.hpp
@@ -0,0 +1,3133 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+/**
+ * @file    ch.hpp
+ * @brief   C++ wrapper classes and definitions.
+ *
+ * @addtogroup cpp_library
+ * @{
+ */
+
+#include <ch.h>
+
+#ifndef _CH_HPP_
+#define _CH_HPP_
+
+/**
+ * @brief   ChibiOS-RT kernel-related classes and interfaces.
+ */
+namespace chibios_rt {
+
+  /* Forward declaration of some classes.*/
+  class ThreadReference;
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::System                                                     *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief Class encapsulating the base system functionalities.
+   */
+  class System {
+  public:
+    /**
+     * @brief   ChibiOS/RT initialization.
+     * @details After executing this function the current instructions stream
+     *          becomes the main thread.
+     * @pre     Interrupts must be still disabled when @p chSysInit() is invoked
+     *          and are internally enabled.
+     * @post    The main thread is created with priority @p NORMALPRIO.
+     * @note    This function has special, architecture-dependent, requirements,
+     *          see the notes into the various port reference manuals.
+     *
+     * @special
+     */
+    static void init(void) {
+
+      chSysInit();
+    }
+
+    /**
+     * @brief   Halts the system.
+     * @details This function is invoked by the operating system when an
+     *          unrecoverable error is detected, for example because a programming
+     *          error in the application code that triggers an assertion while
+     *          in debug mode.
+     * @note    Can be invoked from any system state.
+     *
+     * @param[in] reason        pointer to an error string
+     *
+     * @special
+     */
+    static void halt(const char *reason) {
+
+      chSysHalt(reason);
+    }
+
+    /**
+     * @brief   System integrity check.
+     * @details Performs an integrity check of the important ChibiOS/RT data
+     *          structures.
+     * @note    The appropriate action in case of failure is to halt the system
+     *          before releasing the critical zone.
+     * @note    If the system is corrupted then one possible outcome of this
+     *          function is an exception caused by @p nullptr or corrupted
+     *          pointers in list elements. Exception vectors must be monitored
+     *          as well.
+     * @note    This function is not used internally, it is up to the
+     *          application to define if and where to perform system
+     *          checking.
+     * @note    Performing all tests at once can be a slow operation and can
+     *          degrade the system response time. It is suggested to execute
+     *          one test at time and release the critical zone in between tests.
+     *
+     * @param[in] testmask  Each bit in this mask is associated to a test to be
+     *                      performed.
+     * @return              The test result.
+     * @retval false        The test succeeded.
+     * @retval true         Test failed.
+     *
+     * @iclass
+     */
+    static bool integrityCheckI(unsigned int testmask) {
+
+      return chSysIntegrityCheckI(testmask);
+    }
+
+    /**
+     * @brief   Raises the system interrupt priority mask to the maximum level.
+     * @details All the maskable interrupt sources are disabled regardless their
+     *          hardware priority.
+     * @note    Do not invoke this API from within a kernel lock.
+     *
+     * @special
+     */
+    static void disable(void) {
+
+      chSysDisable();
+    }
+
+    /**
+     * @brief   Raises the system interrupt priority mask to system level.
+     * @details The interrupt sources that should not be able to preempt the kernel
+     *          are disabled, interrupt sources with higher priority are still
+     *          enabled.
+     * @note    Do not invoke this API from within a kernel lock.
+     * @note    This API is no replacement for @p chSysLock(), the @p chSysLock()
+     *          could do more than just disable the interrupts.
+     *
+     * @special
+     */
+    static void suspend(void) {
+
+      chSysSuspend();
+    }
+
+    /**
+     * @brief   Lowers the system interrupt priority mask to user level.
+     * @details All the interrupt sources are enabled.
+     * @note    Do not invoke this API from within a kernel lock.
+     * @note    This API is no replacement for @p chSysUnlock(), the
+     *          @p chSysUnlock() could do more than just enable the interrupts.
+     *
+     * @special
+     */
+    static void enable(void) {
+
+      chSysEnable();
+    }
+
+    /**
+     * @brief   Enters the kernel lock mode.
+     *
+     * @special
+     */
+    static void lock(void) {
+
+      chSysLock();
+    }
+
+    /**
+     * @brief   Leaves the kernel lock mode.
+     *
+     * @special
+     */
+    static void unlock(void) {
+
+      chSysUnlock();
+    }
+
+    /**
+     * @brief   Enters the kernel lock mode from within an interrupt handler.
+     * @note    This API may do nothing on some architectures, it is required
+     *          because on ports that support preemptable interrupt handlers
+     *          it is required to raise the interrupt mask to the same level of
+     *          the system mutual exclusion zone.<br>
+     *          It is good practice to invoke this API before invoking any I-class
+     *          syscall from an interrupt handler.
+     * @note    This API must be invoked exclusively from interrupt handlers.
+     *
+     * @special
+     */
+    static void lockFromIsr(void) {
+
+      chSysLockFromISR();
+    }
+
+    /**
+     * @brief   Leaves the kernel lock mode from within an interrupt handler.
+     *
+     * @note    This API may do nothing on some architectures, it is required
+     *          because on ports that support preemptable interrupt handlers
+     *          it is required to raise the interrupt mask to the same level of
+     *          the system mutual exclusion zone.<br>
+     *          It is good practice to invoke this API after invoking any I-class
+     *          syscall from an interrupt handler.
+     * @note    This API must be invoked exclusively from interrupt handlers.
+     *
+     * @special
+     */
+    static void unlockFromIsr(void) {
+
+      chSysUnlockFromISR();
+    }
+
+    /**
+     * @brief   Unconditionally enters the kernel lock state.
+     * @note    Can be called without previous knowledge of the current lock state.
+     *          The final state is "s-locked".
+     *
+     * @special
+     */
+    static void unconditionalLock(void) {
+
+      chSysUnconditionalLock();
+    }
+
+    /**
+     * @brief   Unconditionally leaves the kernel lock state.
+     * @note    Can be called without previous knowledge of the current lock state.
+     *          The final state is "normal".
+     *
+     * @special
+     */
+    static void unconditionalUnlock(void) {
+
+      chSysUnconditionalUnlock();
+    }
+
+    /**
+     * @brief   Returns the execution status and enters a critical zone.
+     * @details This functions enters into a critical zone and can be called
+     *          from any context. Because its flexibility it is less efficient
+     *          than @p chSysLock() which is preferable when the calling context
+     *          is known.
+     * @post    The system is in a critical zone.
+     *
+     * @return              The previous system status, the encoding of this
+     *                      status word is architecture-dependent and opaque.
+     *
+     * @xclass
+     */
+    static syssts_t getStatusAndLockX(void) {
+
+      return chSysGetStatusAndLockX();
+    }
+
+    /**
+     * @brief   Restores the specified execution status and leaves a critical zone.
+     * @note    A call to @p chSchRescheduleS() is automatically performed
+     *          if exiting the critical zone and if not in ISR context.
+     *
+     * @param[in] sts       the system status to be restored.
+     *
+     * @xclass
+     */
+    static void restoreStatusX(syssts_t sts) {
+
+      chSysRestoreStatusX(sts);
+    }
+
+#if (PORT_SUPPORTS_RT == TRUE) || defined(__DOXYGEN__)
+    /**
+     * @brief   Returns the current value of the system real time counter.
+     * @note    This function is only available if the port layer supports the
+     *          option @p PORT_SUPPORTS_RT.
+     *
+     * @return              The value of the system realtime counter of
+     *                      type rtcnt_t.
+     *
+     * @xclass
+     */
+    static rtcnt_t getRealtimeCounterX(void) {
+
+      return chSysGetRealtimeCounterX();
+    }
+
+    /**
+     * @brief   Realtime window test.
+     * @details This function verifies if the current realtime counter value
+     *          lies within the specified range or not. The test takes care
+     *          of the realtime counter wrapping to zero on overflow.
+     * @note    When start==end then the function returns always true because the
+     *          whole time range is specified.
+     * @note    This function is only available if the port layer supports the
+     *          option @p PORT_SUPPORTS_RT.
+     *
+     * @param[in] cnt       the counter value to be tested
+     * @param[in] start     the start of the time window (inclusive)
+     * @param[in] end       the end of the time window (non inclusive)
+     * @retval true         current time within the specified time window.
+     * @retval false        current time not within the specified time window.
+     *
+     * @xclass
+     */
+    static bool isCounterWithinX(rtcnt_t cnt,
+                                       rtcnt_t start,
+                                       rtcnt_t end) {
+
+      return chSysIsCounterWithinX(cnt, start, end);
+    }
+
+   /**
+    * @brief   Polled delay.
+    * @note    The real delay is always few cycles in excess of the specified
+    *          value.
+    * @note    This function is only available if the port layer supports the
+    *          option @p PORT_SUPPORTS_RT.
+    *
+    * @param[in] cycles    number of cycles
+    *
+    * @xclass
+    */
+    static void polledDelayX(rtcnt_t cycles) {
+
+      chSysPolledDelayX(cycles);
+    }
+#endif /* PORT_SUPPORTS_RT == TRUE */
+
+    /**
+     * @brief   Returns the system time as system ticks.
+     * @note    The system tick time interval is implementation dependent.
+     *
+     * @return          The system time.
+     *
+     * @api
+     */
+    static systime_t getTime(void) {
+
+      return chVTGetSystemTime();
+    }
+
+    /**
+     * @brief   Returns the system time as system ticks.
+     * @note    The system tick time interval is implementation dependent.
+     *
+     * @return          The system time.
+     *
+     * @xclass
+     */
+    static systime_t getTimeX(void) {
+
+      return chVTGetSystemTimeX();
+    }
+
+    /**
+     * @brief   Checks if the current system time is within the specified time
+     *          window.
+     * @note    When start==end then the function returns always true because the
+     *          whole time range is specified.
+     *
+     * @param[in] start     the start of the time window (inclusive)
+     * @param[in] end       the end of the time window (non inclusive)
+     * @retval true         current time within the specified time window.
+     * @retval false        current time not within the specified time window.
+     *
+     * @api
+     */
+    static bool isSystemTimeWithin(systime_t start, systime_t end) {
+
+      return chVTIsSystemTimeWithin(start, end);
+    }
+
+#if (CH_CFG_NO_IDLE_THREAD == FALSE) || defined(__DOXYGEN__)
+    /**
+     * @brief   Returns a reference to the idle thread.
+     * @pre     In order to use this function the option @p CH_CFG_NO_IDLE_THREAD
+     *          must be disabled.
+     * @note    The reference counter of the idle thread is not incremented but
+     *          it is not strictly required being the idle thread a static
+     *          object.
+     *
+     * @return              Reference to the idle thread.
+     *
+     * @xclass
+     */
+    static ThreadReference getIdleThreadX(void);
+#endif /* CH_CFG_NO_IDLE_THREAD == FALSE */
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::CriticalSectionLocker                                      *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   RAII helper for reentrant critical sections.
+   */
+  class CriticalSectionLocker {
+    volatile const syssts_t syssts = chSysGetStatusAndLockX();
+
+  public:
+    ~CriticalSectionLocker() {
+
+      chSysRestoreStatusX(syssts);
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Scheduler                                                  *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief Class encapsulating the low level scheduler functionalities.
+   */
+  class Scheduler {
+  public:
+    /**
+     * @brief   Performs a reschedule if a higher priority thread is runnable.
+     * @details If a thread with a higher priority than the current thread is in
+     *          the ready list then make the higher priority thread running.
+     *
+     * @sclass
+     */
+    static void rescheduleS(void) {
+
+      void chSchRescheduleS();
+    }
+  };
+
+#if (CH_CFG_USE_MEMCORE == TRUE) || defined(__DOXYGEN__)
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Core                                                       *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief Class encapsulating the base system functionalities.
+   */
+  class Core {
+  public:
+    /**
+     * @brief   Allocates a memory block.
+     * @details The size of the returned block is aligned to the alignment
+     *          type so it is not possible to allocate less
+     *          than <code>MEM_ALIGN_SIZE</code>.
+     *
+     * @param[in] size      the size of the block to be allocated
+     * @return              A pointer to the allocated memory block.
+     * @retval nullptr      allocation failed, core memory exhausted.
+     *
+     * @api
+     */
+    static void *alloc(size_t size) {
+
+      return chCoreAlloc(size);
+    }
+
+    /**
+     * @brief   Allocates a memory block.
+     * @details The size of the returned block is aligned to the alignment
+     *          type so it is not possible to allocate less than
+     *          <code>MEM_ALIGN_SIZE</code>.
+     *
+     * @param[in] size      the size of the block to be allocated.
+     * @return              A pointer to the allocated memory block.
+     * @retval nullptr      allocation failed, core memory exhausted.
+     *
+     * @iclass
+     */
+    static void *allocI(size_t size) {
+
+      return chCoreAllocI(size);
+    }
+
+    /**
+     * @brief   Core memory status.
+     *
+     * @return              The size, in bytes, of the free core memory.
+     *
+     * @xclass
+     */
+    static size_t getStatusX(void) {
+
+      return chCoreGetStatusX();
+    }
+  };
+#endif /* CH_CFG_USE_MEMCORE == TRUE */
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Timer                                                      *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Timer class.
+   */
+  class Timer {
+    /**
+     * @brief   Embedded @p virtual_timer_t structure.
+     */
+    virtual_timer_t vt;
+
+  public:
+    /**
+     * @brief  Construct a virtual timer.
+     */
+    Timer() : vt() {
+
+      chVTObjectInit(&vt);
+    }
+
+    /* Prohibit copy construction and assignment.*/
+    Timer(const Timer &) = delete;
+    Timer &operator=(const Timer &) = delete;
+
+    /**
+     * @brief   Enables a virtual timer.
+     * @note    The associated function is invoked from interrupt context.
+     *
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the special values are handled as follow:
+     *                      - @a TIME_INFINITE is allowed but interpreted as a
+     *                        normal time specification.
+     *                      - @a TIME_IMMEDIATE this value is not allowed.
+     *                      .
+     * @param[in] vtfunc    the timer callback function. After invoking the
+     *                      callback the timer is disabled and the structure
+     *                      can be disposed or reused.
+     * @param[in] par       a parameter that will be passed to the callback
+     *                      function
+     *
+     * @api
+     */
+    void set(sysinterval_t timeout, vtfunc_t vtfunc, void *par) {
+
+      chVTSet(&vt, timeout, vtfunc, par);
+    }
+
+    /**
+     * @brief   Enables a virtual timer.
+     * @note    The associated function is invoked from interrupt context.
+     *
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the special values are handled as follow:
+     *                      - @a TIME_INFINITE is allowed but interpreted as a
+     *                        normal time specification.
+     *                      - @a TIME_IMMEDIATE this value is not allowed.
+     *                      .
+     * @param[in] vtfunc    the timer callback function. After invoking the
+     *                      callback the timer is disabled and the structure
+     *                      can be disposed or reused.
+     * @param[in] par       a parameter that will be passed to the callback
+     *                      function
+     *
+     * @iclass
+     */
+    void setI(sysinterval_t timeout, vtfunc_t vtfunc, void *par) {
+
+      chVTSetI(&vt, timeout, vtfunc, par);
+    }
+
+    /**
+     * @brief   Resets the timer, if armed.
+     *
+     * @api
+     */
+    void reset() {
+
+      chVTReset(&vt);
+    }
+
+    /**
+     * @brief   Resets the timer, if armed.
+     *
+     * @iclass
+     */
+    void resetI() {
+
+      chVTResetI(&vt);
+    }
+
+    /**
+     * @brief   Returns the timer status.
+     *
+     * @return              The timer status.
+     * @retval true         If the timer is armed.
+     * @retval false        If the timer already fired its callback.
+     *
+     * @iclass
+     */
+    bool isArmedI(void) const {
+
+      return chVTIsArmedI(&vt);
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::ThreadReference                                            *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief     Thread reference class.
+   * @details   This class encapsulates a reference to a system thread. All
+   *            operations involving another thread are performed through
+   *            an object of this type.
+   */
+  class ThreadReference final {
+    /**
+     * @brief   Pointer to the system thread.
+     */
+    thread_t *thread_ref;
+
+  public:
+    /**
+     * @brief   Thread reference constructor.
+     * @note    Do not call this version directly, this constructor is empty
+     *          and is here only to do nothing when an object of this kind
+     *          is declared then assigned.
+     * @note    Automatic instances of this object are not initialized
+     *          because this constructor, this is intentional.
+     *
+     * @param[in] tp            the target thread
+     *
+     * @init
+     */
+    ThreadReference(void) {
+
+    }
+
+    /**
+     * @brief   Thread reference constructor.
+     *
+     * @param[in] tp            the target thread
+     *
+     * @init
+     */
+    ThreadReference(thread_t *tp) : thread_ref(tp) {
+
+    }
+
+    /**
+     * @brief   Returns the reference state.
+     *
+     * @return          The reference state.
+     * @retval false    if the reference is still valid.
+     * @retval true     if the reference is set to @p nullptr.
+     */
+    bool isNull(void) const {
+
+      return (bool)(thread_ref == nullptr);
+    }
+
+    /**
+     * @brief   Returns the low level pointer to the referenced thread.
+     */
+    thread_t *getInner(void) {
+
+      return thread_ref;
+    }
+
+    /**
+     * @brief   Requests a thread termination.
+     * @pre     The target thread must be written to invoke periodically
+     *          @p chThdShouldTerminate() and terminate cleanly if it returns
+     *          @p TRUE.
+     * @post    The specified thread will terminate after detecting the
+     *          termination condition.
+     *
+     * @api
+     */
+    void requestTerminate(void) const {
+
+      chThdTerminate(thread_ref);
+    }
+
+#if (CH_CFG_USE_REGISTRY == TRUE) || defined(__DOXYGEN__)
+    /**
+     * @brief   Adds a reference to a thread object.
+     * @pre     The configuration option @p CH_CFG_USE_REGISTRY must be enabled
+     *          in order to use this function.
+     *
+     * @return              A new thread reference.
+     *
+     * @api
+     */
+    ThreadReference addRef(void) const {
+
+      return ThreadReference(chThdAddRef(thread_ref));
+    }
+
+    /**
+     * @brief   Releases a reference to a thread object.
+     * @details If the references counter reaches zero <b>and</b> the thread
+     *          is in the @p CH_STATE_FINAL state then the thread's memory is
+     *          returned to the proper allocator and the thread is removed
+     *          from the registry.<br>
+     *          Threads whose counter reaches zero and are still active become
+     *          "detached" and will be removed from registry on termination.
+     * @pre     The configuration option @p CH_CFG_USE_REGISTRY must be enabled in
+     *          order to use this function.
+     * @post    The reference is set to @p nullptr.
+     * @note    Static threads are not affected.
+     *
+     * @api
+     */
+    void release(void) {
+      thread_t *tp = thread_ref;
+      thread_ref = nullptr;
+
+      chThdRelease(tp);
+    }
+#endif /* CH_CFG_USE_REGISTRY == TRUE */
+
+#if (CH_CFG_USE_WAITEXIT == TRUE) || defined(__DOXYGEN__)
+    /**
+     * @brief   Blocks the execution of the invoking thread until the specified
+     *          thread terminates then the exit code is returned.
+     * @details This function waits for the specified thread to terminate then
+     *          decrements its reference counter, if the counter reaches zero
+     *          then the thread working area is returned to the proper
+     *          allocator.<br>
+     *          The memory used by the exited thread is handled in different
+     *          ways depending on the API that spawned the thread:
+     *          - If the thread was spawned by @p chThdCreateStatic() or by
+     *            @p chThdCreateI() then nothing happens and the thread working
+     *            area is not released or modified in any way. This is the
+     *            default, totally static, behavior.
+     *          - If the thread was spawned by @p chThdCreateFromHeap() then
+     *            the working area is returned to the system heap.
+     *          - If the thread was spawned by @p chThdCreateFromMemoryPool()
+     *            then the working area is returned to the owning memory pool.
+     *          .
+     * @pre     The configuration option @p CH_USE_WAITEXIT must be enabled in
+     *          order to use this function.
+     * @post    Enabling @p chThdWait() requires 2-4 (depending on the
+     *          architecture) extra bytes in the @p Thread structure.
+     * @post    The reference is set to @p nullptr.
+     * @note    If @p CH_USE_DYNAMIC is not specified this function just waits
+     *          for the thread termination, no memory allocators are involved.
+     *
+     * @return              The exit code from the terminated thread.
+     *
+     * @api
+     */
+    msg_t wait(void) {
+      thread_t *tp = thread_ref;
+      thread_ref = nullptr;
+
+      msg_t msg = chThdWait(tp);
+      return msg;
+    }
+#endif /* CH_CFG_USE_WAITEXIT == TRUE */
+
+#if (CH_CFG_USE_MESSAGES == TRUE) || defined(__DOXYGEN__)
+    /**
+     * @brief   Sends a message to the thread and returns the answer.
+     *
+     * @param[in] msg           the sent message
+     * @return                  The returned message.
+     *
+     * @api
+     */
+    msg_t sendMessage(msg_t msg) const {
+
+      return chMsgSend(thread_ref, msg);
+    }
+
+    /**
+     * @brief   Returns true if there is at least one message in queue.
+     *
+     * @retval true             A message is waiting in queue.
+     * @retval false            A message is not waiting in queue.
+     *
+     * @api
+     */
+    bool isPendingMessage(void) const {
+
+      return chMsgIsPendingI(thread_ref);
+    }
+
+    /**
+     * @brief   Returns an enqueued message or @p nullptr.
+     *
+     * @return                  The incoming message.
+     *
+     * @api
+     */
+    msg_t getMessage(void) const {
+
+      return chMsgGet(thread_ref);
+    }
+
+    /**
+     * @brief   Releases the next message in queue with a reply.
+     * @post    The reference is set to @p nullptr.
+     *
+     * @param[in] msg           the answer message
+     *
+     * @api
+     */
+    void releaseMessage(msg_t msg) {
+      thread_t *tp = thread_ref;
+      thread_ref = nullptr;
+
+      chMsgRelease(tp, msg);
+    }
+#endif /* CH_CFG_USE_MESSAGES == TRUE */
+
+#if (CH_CFG_USE_EVENTS == TRUE) || defined(__DOXYGEN__)
+    /**
+     * @brief   Adds a set of event flags directly to specified @p Thread.
+     *
+     * @param[in] mask      the event flags set to be ORed
+     *
+     * @api
+     */
+    void signalEvents(eventmask_t mask) const {
+
+      chEvtSignal(thread_ref, mask);
+    }
+
+    /**
+     * @brief   Adds a set of event flags directly to specified @p Thread.
+     *
+     * @param[in] mask      the event flags set to be ORed
+     *
+     * @iclass
+     */
+    void signalEventsI(eventmask_t mask) const {
+
+      chEvtSignalI(thread_ref, mask);
+    }
+#endif /* CH_CFG_USE_EVENTS == TRUE */
+
+#if (CH_DBG_THREADS_PROFILING == TRUE) || defined(__DOXYGEN__)
+    /**
+     * @brief   Returns the number of ticks consumed by the specified thread.
+     * @note    This function is only available when the
+     *          @p CH_DBG_THREADS_PROFILING configuration option is enabled.
+     *
+     * @param[in] tp        pointer to the thread
+     * @return              The number of consumed system ticks.
+     *
+     * @xclass
+     */
+    systime_t getTicksX(void) const {
+
+      return chThdGetTicksX(thread_ref);
+    }
+#endif /* CH_DBG_THREADS_PROFILING == TRUE */
+  };
+
+#if (CH_CFG_USE_REGISTRY == TRUE) || defined(__DOXYGEN__)
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Registry                                                   *
+   *------------------------------------------------------------------------*/
+  class Registry {
+  public:
+    /**
+     * @brief   Returns the first thread in the system.
+     * @details Returns the most ancient thread in the system, usually this is
+     *          the main thread unless it terminated. A reference is added to the
+     *          returned thread in order to make sure its status is not lost.
+     * @note    This function cannot return @p nullptr because there is always at
+     *          least one thread in the system.
+     *
+     * @return              A reference to the most ancient thread.
+     *
+     * @api
+     */
+    static ThreadReference firstThread(void) {
+
+      return ThreadReference(chRegFirstThread());
+    }
+
+    /**
+     * @brief   Returns the thread next to the specified one.
+     * @details The reference counter of the specified thread is decremented and
+     *          the reference counter of the returned thread is incremented.
+     *
+     * @param[in] tref      reference to the thread
+     * @return              A reference to the next thread. The reference is
+     *                      set to @p nullptr if there is no next thread.
+     *
+     * @api
+     */
+    static ThreadReference nextThread(ThreadReference tref) {
+
+      return ThreadReference(chRegNextThread(tref.getInner()));
+    }
+
+    /**
+     * @brief   Retrieves a thread reference by name.
+     * @note    The reference counter of the found thread is increased by one so
+     *          it cannot be disposed incidentally after the pointer has been
+     *          returned.
+     *
+     * @param[in] name      the thread name
+     * @return              A pointer to the found thread.
+     * @return              A reference to the found thread. The reference is
+     *                      set to @p nullptr if no next thread is found.
+     *
+     * @api
+     */
+    static ThreadReference findThreadByName(const char *name) {
+
+      return ThreadReference(chRegFindThreadByName(name));
+    }
+  };
+#endif /* CH_CFG_USE_REGISTRY == TRUE */
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::BaseThread                                                 *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Abstract base class for a ChibiOS/RT thread.
+   * @details The thread body is the virtual function @p Main().
+   */
+  class BaseThread {
+  public:
+    /**
+     * @brief   BaseThread constructor.
+     *
+     * @init
+     */
+    BaseThread(void) {
+
+    }
+
+    /**
+     * @brief   Thread body function.
+     *
+     * @return                  The exit message.
+     *
+     * @api
+     */
+    virtual void main(void) = 0;
+
+    /**
+     * @brief   Creates and starts a system thread.
+     *
+     * @param[in] prio          thread priority
+     * @return                  A reference to the created thread with
+     *                          reference counter set to one.
+     *
+     * @api
+     */
+    virtual ThreadReference start(tprio_t prio) = 0;
+
+    /**
+     * @brief   Returns a reference to the current thread.
+     *
+     * @return             A reference to the current thread.
+     *
+     * @xclass
+     */
+    static ThreadReference getSelfX(void) {
+
+      return ThreadReference(chThdGetSelfX());
+    }
+
+    /**
+     * @brief   Sets the current thread name.
+     * @pre     This function only stores the pointer to the name if the option
+     *          @p CH_USE_REGISTRY is enabled else no action is performed.
+     *
+     * @param[in] tname         thread name as a zero terminated string
+     *
+     * @api
+     */
+    static void setName(const char *tname) {
+
+      chRegSetThreadName(tname);
+    }
+
+    /**
+     * @brief   Changes the running thread priority level then reschedules if
+     *          necessary.
+     * @note    The function returns the real thread priority regardless of the
+     *          current priority that could be higher than the real priority
+     *          because the priority inheritance mechanism.
+     *
+     * @param[in] newprio   the new priority level of the running thread
+     * @return              The old priority level.
+     *
+     * @api
+     */
+    static tprio_t setPriority(tprio_t newprio) {
+
+      return chThdSetPriority(newprio);
+    }
+
+    /**
+     * @brief   Returns the current thread priority.
+     * @note    Can be invoked in any context.
+     *
+     * @return              The current thread priority.
+     *
+     * @xclass
+     */
+    static tprio_t getPriorityX(void) {
+
+      return chThdGetPriorityX();
+    }
+
+    /**
+     * @brief   Terminates the current thread.
+     * @details The thread goes in the @p THD_STATE_FINAL state holding the
+     *          specified exit status code, other threads can retrieve the
+     *          exit status code by invoking the function @p chThdWait().
+     * @post    Eventual code after this function will never be executed,
+     *          this function never returns. The compiler has no way to
+     *          know this so do not assume that the compiler would remove
+     *          the dead code.
+     *
+     * @param[in] msg       thread exit code
+     *
+     * @api
+     */
+    static void exit(msg_t msg) {
+
+      chThdExit(msg);
+    }
+
+    /**
+     * @brief   Terminates the current thread.
+     * @details The thread goes in the @p THD_STATE_FINAL state holding the
+     *          specified exit status code, other threads can retrieve the
+     *          exit status code by invoking the function @p chThdWait().
+     * @post    Eventual code after this function will never be executed,
+     *          this function never returns. The compiler has no way to
+     *          know this so do not assume that the compiler would remove
+     *          the dead code.
+     *
+     * @param[in] msg       thread exit code
+     *
+     * @sclass
+     */
+    static void exitS(msg_t msg) {
+
+      chThdExitS(msg);
+    }
+
+    /**
+     * @brief   Verifies if the current thread has a termination request
+     *          pending.
+     * @note    Can be invoked in any context.
+     *
+     * @retval TRUE         termination request pending.
+     * @retval FALSE        termination request not pending.
+     *
+     * @special
+     */
+    static bool shouldTerminate(void) {
+
+      return chThdShouldTerminateX();
+    }
+
+    /**
+     * @brief   Suspends the invoking thread for the specified time.
+     *
+     * @param[in] interval  the delay in system ticks, the special values are
+     *                      handled as follow:
+     *                      - @a TIME_INFINITE the thread enters an infinite
+     *                        sleep state.
+     *                      - @a TIME_IMMEDIATE this value is not allowed.
+     *                      .
+     *
+     * @api
+     */
+    static void sleep(sysinterval_t interval) {
+
+      chThdSleep(interval);
+    }
+
+    /**
+     * @brief   Suspends the invoking thread until the system time arrives to
+     *          the specified value.
+     *
+     * @param[in] time      absolute system time
+     *
+     * @api
+     */
+    static void sleepUntil(systime_t time) {
+
+      chThdSleepUntil(time);
+    }
+
+    /**
+     * @brief   Suspends the invoking thread until the system time arrives to the
+     *          specified value.
+     * @note    The system time is assumed to be between @p prev and @p time
+     *          else the call is assumed to have been called outside the
+     *          allowed time interval, in this case no sleep is performed.
+     * @see     chThdSleepUntil()
+     *
+     * @param[in] prev      absolute system time of the previous deadline
+     * @param[in] next      absolute system time of the next deadline
+     * @return              the @p next parameter
+     *
+     * @api
+     */
+    static systime_t sleepUntilWindowed(systime_t prev, systime_t next) {
+
+      return chThdSleepUntilWindowed(prev, next);
+    }
+
+    /**
+     * @brief   Yields the time slot.
+     * @details Yields the CPU control to the next thread in the ready list
+     *          with equal priority, if any.
+     *
+     * @api
+     */
+    static void yield(void) {
+
+      chThdYield();
+    }
+
+#if CH_CFG_USE_MESSAGES || defined(__DOXYGEN__)
+    /**
+     * @brief   Waits for a message.
+     * @post    On the returned reference it is mandatory to call
+     *          @p releaseMessage() or the sender thread would be waiting
+     *          undefinitely.
+     *
+     * @return                  The sender thread reference.
+     *
+     * @api
+     */
+    static ThreadReference waitMessage(void) {
+
+      return ThreadReference(chMsgWait());
+    }
+#endif /* CH_CFG_USE_MESSAGES == TRUE */
+
+#if CH_CFG_USE_EVENTS || defined(__DOXYGEN__)
+    /**
+     * @brief   Clears the pending events specified in the mask.
+     *
+     * @param[in] mask      the events to be cleared
+     * @return              The pending events that were cleared.
+     *
+     * @api
+     */
+    static eventmask_t getAndClearEvents(eventmask_t mask) {
+
+      return chEvtGetAndClearEvents(mask);
+    }
+
+    /**
+     * @brief   Adds (OR) a set of event flags on the current thread, this is
+     *          @b much faster than using @p chEvtBroadcast() or
+     *          @p chEvtSignal().
+     *
+     * @param[in] mask      the event flags to be added
+     * @return              The current pending events mask.
+     *
+     * @api
+     */
+    static eventmask_t addEvents(eventmask_t mask) {
+
+      return chEvtAddEvents(mask);
+    }
+
+    /**
+     * @brief   Waits for a single event.
+     * @details A pending event among those specified in @p ewmask is selected,
+     *          cleared and its mask returned.
+     * @note    One and only one event is served in the function, the one with
+     *          the lowest event id. The function is meant to be invoked into
+     *          a loop in order to serve all the pending events.<br>
+     *          This means that Event Listeners with a lower event identifier
+     *          have an higher priority.
+     *
+     * @param[in] ewmask        mask of the events that the function should
+     *                          wait for, @p ALL_EVENTS enables all the events
+     * @return                  The mask of the lowest id served and cleared
+     *                          event.
+     *
+     * @api
+     */
+    static eventmask_t waitOneEvent(eventmask_t ewmask) {
+
+      return chEvtWaitOne(ewmask);
+    }
+
+    /**
+     * @brief   Waits for any of the specified events.
+     * @details The function waits for any event among those specified in
+     *          @p ewmask to become pending then the events are cleared and
+     *          returned.
+     *
+     * @param[in] ewmask        mask of the events that the function should
+     *                          wait for, @p ALL_EVENTS enables all the events
+     * @return                  The mask of the served and cleared events.
+     *
+     * @api
+     */
+    static eventmask_t waitAnyEvent(eventmask_t ewmask) {
+
+      return chEvtWaitAny(ewmask);
+    }
+
+    /**
+     * @brief   Waits for all the specified event flags then clears them.
+     * @details The function waits for all the events specified in @p ewmask
+     *          to become pending then the events are cleared and returned.
+     *
+     * @param[in] ewmask        mask of the event ids that the function should
+     *                          wait for
+     * @return                  The mask of the served and cleared events.
+     *
+     * @api
+     */
+    static eventmask_t waitAllEvents(eventmask_t ewmask) {
+
+      return chEvtWaitAll(ewmask);
+    }
+
+#if CH_CFG_USE_EVENTS_TIMEOUT || defined(__DOXYGEN__)
+    /**
+     * @brief   Waits for a single event.
+     * @details A pending event among those specified in @p ewmask is selected,
+     *          cleared and its mask returned.
+     * @note    One and only one event is served in the function, the one with
+     *          the lowest event id. The function is meant to be invoked into
+     *          a loop in order to serve all the pending events.<br>
+     *          This means that Event Listeners with a lower event identifier
+     *          have an higher priority.
+     *
+     * @param[in] ewmask        mask of the events that the function should
+     *                          wait for, @p ALL_EVENTS enables all the events
+     *
+     * @param[in] timeout       the number of ticks before the operation
+     *                          timouts
+     * @return                  The mask of the lowest id served and cleared
+     *                          event.
+     * @retval 0                if the specified timeout expired.
+     *
+     * @api
+     */
+    static eventmask_t waitOneEventTimeout(eventmask_t ewmask,
+                                           sysinterval_t timeout) {
+
+      return chEvtWaitOneTimeout(ewmask, timeout);
+    }
+
+    /**
+     * @brief   Waits for any of the specified events.
+     * @details The function waits for any event among those specified in
+     *          @p ewmask to become pending then the events are cleared and
+     *          returned.
+     *
+     * @param[in] ewmask        mask of the events that the function should
+     *                          wait for, @p ALL_EVENTS enables all the events
+     * @param[in] timeout       the number of ticks before the operation
+     *                          timouts
+     * @return                  The mask of the served and cleared events.
+     * @retval 0                if the specified timeout expired.
+     *
+     * @api
+     */
+    static eventmask_t waitAnyEventTimeout(eventmask_t ewmask,
+                                           sysinterval_t timeout) {
+
+      return chEvtWaitAnyTimeout(ewmask, timeout);
+    }
+
+    /**
+     * @brief   Waits for all the specified event flags then clears them.
+     * @details The function waits for all the events specified in @p ewmask
+     *          to become pending then the events are cleared and returned.
+     *
+     * @param[in] ewmask        mask of the event ids that the function should
+     *                          wait for
+     * @param[in] timeout       the number of ticks before the operation
+     *                          timouts
+     * @return                  The mask of the served and cleared events.
+     * @retval 0                if the specified timeout expired.
+     *
+     * @api
+     */
+    static eventmask_t waitAllEventsTimeout(eventmask_t ewmask,
+                                            sysinterval_t timeout) {
+
+      return chEvtWaitAllTimeout(ewmask, timeout);
+    }
+#endif /* CH_CFG_USE_EVENTS_TIMEOUT == TRUE */
+
+    /**
+     * @brief   Invokes the event handlers associated to an event flags mask.
+     *
+     * @param[in] mask      mask of the event flags to be dispatched
+     * @param[in] handlers  an array of @p evhandler_t. The array must have
+     *                      size equal to the number of bits in eventmask_t.
+     *
+     * @api
+     */
+    static void dispatchEvents(const evhandler_t handlers[],
+                               eventmask_t mask) {
+
+      chEvtDispatch(handlers, mask);
+    }
+#endif /* CH_CFG_USE_EVENTS == TRUE */
+
+#if CH_CFG_USE_MUTEXES || defined(__DOXYGEN__)
+    /**
+     * @brief   Unlocks all the mutexes owned by the invoking thread.
+     * @post    The stack of owned mutexes is emptied and all the found
+     *          mutexes are unlocked.
+     * @note    This function is <b>MUCH MORE</b> efficient than releasing the
+     *          mutexes one by one and not just because the call overhead,
+     *          this function does not have any overhead related to the
+     *          priority inheritance mechanism.
+     *
+     * @api
+     */
+    static void unlockAllMutexes(void) {
+
+      chMtxUnlockAll();
+    }
+#endif /* CH_CFG_USE_MUTEXES == TRUE */
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::BaseStaticThread                                           *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Static threads template base class.
+   * @details This class introduces static working area instantiation.
+   *
+   * @param N               the working area size for the thread class
+   */
+  template <int N>
+  class BaseStaticThread : public BaseThread {
+  protected:
+    THD_WORKING_AREA(wa, N);
+
+  public:
+    /**
+     * @brief   Starts a static thread.
+     *
+     * @param[in] prio          thread priority
+     * @return                  A reference to the created thread with
+     *                          reference counter set to one.
+     *
+     * @api
+     */
+    ThreadReference start(tprio_t prio) override {
+      void _thd_start(void *arg);
+
+      return ThreadReference(chThdCreateStatic(wa, sizeof(wa), prio,
+                                               _thd_start, this));
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::BaseDynamicThread                                          *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Dynamic threads base class.
+   */
+  class BaseDynamicThread : public BaseThread {
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::ThreadStayPoint                                            *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief     Thread suspension point class.
+   * @details   This class encapsulates a reference to a suspended thread.
+   */
+  class ThreadStayPoint {
+    /**
+     * @brief   Pointer to the suspended thread.
+     */
+    thread_reference_t thread_ref = nullptr;
+
+  public:
+    /**
+     * @brief   Thread stay point constructor.
+     *
+     * @init
+     */
+    ThreadStayPoint() {
+
+    }
+
+    /* Prohibit copy construction and assignment.*/
+    ThreadStayPoint(const ThreadStayPoint &) = delete;
+    ThreadStayPoint &operator=(const ThreadStayPoint &) = delete;
+
+    /**
+     * @brief   Suspends the current thread on the stay point.
+     * @details The suspended thread becomes the referenced thread. It is
+     *          possible to use this method only if the thread reference
+     *          was set to @p nullptr.
+     *
+     * @return                  The incoming message.
+     *
+     * @sclass
+     */
+    msg_t suspendS(void) {
+
+      return chThdSuspendS(&thread_ref);
+    }
+
+    /**
+     * @brief   Suspends the current thread on the stay point with timeout.
+     * @details The suspended thread becomes the referenced thread. It is
+     *          possible to use this method only if the thread reference
+     *          was set to @p nullptr.
+     *
+     *
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the semaphore.
+     * @retval MSG_OK       if the binary semaphore has been successfully
+     *                      taken.
+     * @retval MSG_RESET    if the binary semaphore has been reset using
+     *                      @p bsemReset().
+     * @retval MSG_TIMEOUT  if the binary semaphore has not been signaled
+     *                      or reset within the specified timeout.
+     *
+     * @sclass
+     */
+    msg_t suspendS(sysinterval_t timeout) {
+
+      return chThdSuspendTimeoutS(&thread_ref, timeout);
+    }
+
+    /**
+     * @brief   Resumes the currently referenced thread, if any.
+     *
+     * @param[in] msg       the wakeup message
+     *
+     * @iclass
+     */
+    void resumeI(msg_t msg) {
+
+      chThdResumeI(&thread_ref, msg);
+    }
+
+    /**
+     * @brief   Resumes the currently referenced thread, if any.
+     *
+     * @param[in] msg       the wakeup message
+     *
+     * @sclass
+     */
+    void resumeS(msg_t msg) {
+
+      chThdResumeS(&thread_ref, msg);
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::SynchronizationObject                                      *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief     Base class for all synchronization objects.
+   * @note      No other uses.
+   */
+  class SynchronizationObject {
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::ThreadsQueue                                               *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief     Threads queue class.
+   * @details   This class encapsulates a queue of threads.
+   */
+  class ThreadsQueue : public SynchronizationObject {
+    /**
+     * @brief   Pointer to the system thread.
+     */
+    threads_queue_t threads_queue;
+
+  public:
+    /**
+     * @brief   Threads queue constructor.
+     *
+     * @init
+     */
+    ThreadsQueue() {
+
+      chThdQueueObjectInit(&threads_queue);
+    }
+
+    /* Prohibit copy construction and assignment.*/
+    ThreadsQueue(const ThreadsQueue &) = delete;
+    ThreadsQueue &operator=(const ThreadsQueue &) = delete;
+
+    /**
+     * @brief   Enqueues the caller thread on a threads queue object.
+     * @details The caller thread is enqueued and put to sleep until it is
+     *          dequeued or the specified timeouts expires.
+     *
+     * @param[in] timeout   the timeout in system ticks, the special values are
+     *                      handled as follow:
+     *                      - @a TIME_INFINITE the thread enters an infinite sleep
+     *                        state.
+     *                      - @a TIME_IMMEDIATE the thread is not enqueued and
+     *                        the function returns @p MSG_TIMEOUT as if a timeout
+     *                        occurred.
+     *                      .
+     * @return              The message from @p osalQueueWakeupOneI() or
+     *                      @p osalQueueWakeupAllI() functions.
+     * @retval MSG_TIMEOUT  if the thread has not been dequeued within the
+     *                      specified timeout or if the function has been
+     *                      invoked with @p TIME_IMMEDIATE as timeout
+     *                      specification.
+     *
+     * @sclass
+     */
+    msg_t enqueueSelfS(sysinterval_t timeout) {
+
+      return chThdEnqueueTimeoutS(&threads_queue, timeout);
+    }
+
+    /**
+     * @brief   Dequeues and wakes up one thread from the threads queue object,
+     *          if any.
+     *
+     * @param[in] msg       the message code
+     *
+     * @iclass
+     */
+    void dequeueNextI(msg_t msg) {
+
+      chThdDequeueNextI(&threads_queue, msg);
+    }
+
+    /**
+     * @brief   Dequeues and wakes up all threads from the threads queue object.
+     *
+     * @param[in] msg       the message code
+     *
+     * @iclass
+     */
+    void chdequeueAllI(msg_t msg) {
+
+      chThdDequeueAllI(&threads_queue, msg);
+    }
+};
+
+#if (CH_CFG_USE_SEMAPHORES == TRUE) || defined(__DOXYGEN__)
+  /*------------------------------------------------------------------------*
+   * chibios_rt::CounterSemaphore                                           *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Class encapsulating a semaphore.
+   */
+  class CounterSemaphore : public SynchronizationObject {
+    /**
+     * @brief   Embedded @p semaphore_t structure.
+     */
+    semaphore_t sem;
+
+  public:
+    /**
+     * @brief   CounterSemaphore constructor.
+     * @details The embedded @p Semaphore structure is initialized.
+     *
+     * @param[in] n             the semaphore counter value, must be greater
+     *                          or equal to zero
+     *
+     * @init
+     */
+    CounterSemaphore(cnt_t n) {
+
+      chSemObjectInit(&sem, n);
+    }
+
+    /**
+     * @brief   Performs a reset operation on the semaphore.
+     * @post    After invoking this function all the threads waiting on the
+     *          semaphore, if any, are released and the semaphore counter is
+     *          set to the specified, non negative, value.
+     * @note    The released threads can recognize they were waked up by a
+     *          reset rather than a signal because the @p chSemWait() will
+     *          return @p MSG_RESET instead of @p MSG_OK.
+     *
+     * @param[in] n         the new value of the semaphore counter. The value
+     *                      must be non-negative.
+     *
+     * @api
+     */
+    void reset(cnt_t n) {
+
+      chSemReset(&sem, n);
+    }
+
+    /**
+     * @brief   Performs a reset operation on the semaphore.
+     * @post    After invoking this function all the threads waiting on the
+     *          semaphore, if any, are released and the semaphore counter is
+     *          set to the specified, non negative, value.
+     * @post    This function does not reschedule so a call to a rescheduling
+     *          function must be performed before unlocking the kernel. Note
+     *          that interrupt handlers always reschedule on exit so an
+     *          explicit reschedule must not be performed in ISRs.
+     * @note    The released threads can recognize they were waked up by a
+     *          reset rather than a signal because the @p chSemWait() will
+     *          return @p MSG_RESET instead of @p MSG_OK.
+     *
+     * @param[in] n         the new value of the semaphore counter. The value
+     *                      must be non-negative.
+     *
+     * @iclass
+     */
+    void resetI(cnt_t n) {
+
+      chSemResetI(&sem, n);
+    }
+
+    /**
+     * @brief   Performs a wait operation on a semaphore.
+     *
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the semaphore.
+     * @retval MSG_OK       if the thread has not stopped on the semaphore or
+     *                      the semaphore has been signaled.
+     * @retval MSG_RESET    if the semaphore has been reset using
+     *                      @p chSemReset().
+     *
+     * @api
+     */
+    msg_t wait(void) {
+
+      return chSemWait(&sem);
+    }
+
+    /**
+     * @brief   Performs a wait operation on a semaphore.
+     *
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the semaphore.
+     * @retval MSG_OK       if the thread has not stopped on the semaphore or
+     *                      the semaphore has been signaled.
+     * @retval MSG_RESET    if the semaphore has been reset using
+     *                      @p chSemReset().
+     *
+     * @sclass
+     */
+    msg_t waitS(void) {
+
+      return chSemWaitS(&sem);
+    }
+
+    /**
+     * @brief   Performs a wait operation on a semaphore with timeout
+     *          specification.
+     *
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the semaphore.
+     * @retval MSG_OK       if the thread has not stopped on the semaphore or
+     *                      the semaphore has been signaled.
+     * @retval MSG_RESET    if the semaphore has been reset using
+     *                      @p chSemReset().
+     * @retval MSG_TIMEOUT  if the semaphore has not been signaled or reset
+     *                      within the specified timeout.
+     *
+     * @api
+     */
+    msg_t wait(sysinterval_t timeout) {
+
+      return chSemWaitTimeout(&sem, timeout);
+    }
+
+    /**
+     * @brief   Performs a wait operation on a semaphore with timeout
+     *          specification.
+     *
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the semaphore.
+     * @retval MSG_OK       if the thread has not stopped on the semaphore or
+     *                      the semaphore has been signaled.
+     * @retval MSG_RESET    if the semaphore has been reset using
+     *                      @p chSemReset().
+     * @retval MSG_TIMEOUT  if the semaphore has not been signaled or reset
+     *                      within the specified timeout.
+     *
+     * @sclass
+     */
+    msg_t waitS(sysinterval_t timeout) {
+
+      return chSemWaitTimeoutS(&sem, timeout);
+    }
+
+    /**
+     * @brief   Performs a signal operation on a semaphore.
+     *
+     * @api
+     */
+    void signal(void) {
+
+      chSemSignal(&sem);
+    }
+
+    /**
+     * @brief   Performs a signal operation on a semaphore.
+     * @post    This function does not reschedule so a call to a rescheduling
+     *          function must be performed before unlocking the kernel. Note
+     *          that interrupt handlers always reschedule on exit so an
+     *          explicit reschedule must not be performed in ISRs.
+     *
+     * @iclass
+     */
+    void signalI(void) {
+
+      chSemSignalI(&sem);
+    }
+
+    /**
+     * @brief   Adds the specified value to the semaphore counter.
+     * @post    This function does not reschedule so a call to a rescheduling
+     *          function must be performed before unlocking the kernel. Note
+     *          that interrupt handlers always reschedule on exit so an explicit
+     *          reschedule must not be performed in ISRs.
+     *
+     * @param[in] n         value to be added to the semaphore counter. The
+     *                      value must be positive.
+     *
+     * @iclass
+     */
+    void addCounterI(cnt_t n) {
+
+      chSemAddCounterI(&sem, n);
+    }
+
+    /**
+     * @brief   Returns the semaphore counter value.
+     *
+     * @return                  The semaphore counter value.
+     *
+     * @iclass
+     */
+    cnt_t getCounterI(void) const {
+
+      return chSemGetCounterI(&sem);
+    }
+
+    /**
+     * @brief   Atomic signal and wait operations.
+     *
+     * @param[in] ssem          @p Semaphore object to be signaled
+     * @param[in] wsem          @p Semaphore object to wait on
+     * @return                  A message specifying how the invoking thread
+     *                          has been released from the semaphore.
+     * @retval MSG_OK           if the thread has not stopped on the semaphore
+     *                          or the semaphore has been signaled.
+     * @retval MSG_RESET        if the semaphore has been reset using
+     *                          @p chSemReset().
+     *
+     * @api
+     */
+    static msg_t signalWait(CounterSemaphore *ssem,
+                            CounterSemaphore *wsem) {
+
+      return chSemSignalWait(&ssem->sem, &wsem->sem);
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::BinarySemaphore                                            *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Class encapsulating a binary semaphore.
+   */
+  class BinarySemaphore : public SynchronizationObject {
+    /**
+     * @brief   Embedded @p binary_semaphore_t structure.
+     */
+    binary_semaphore_t bsem;
+
+  public:
+    /**
+     * @brief   BinarySemaphore constructor.
+     * @details The embedded @p ::BinarySemaphore structure is initialized.
+     *
+     * @param[in] taken     initial state of the binary semaphore:
+     *                      - @a false, the initial state is not taken.
+     *                      - @a true, the initial state is taken.
+     *                      .
+     *
+     * @init
+     */
+    BinarySemaphore(bool taken) {
+
+      chBSemObjectInit(&bsem, taken);
+    }
+
+    /**
+     * @brief   Wait operation on the binary semaphore.
+     *
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the semaphore.
+     * @retval MSG_OK       if the binary semaphore has been successfully
+     *                      taken.
+     * @retval MSG_RESET    if the binary semaphore has been reset using
+     *                      @p bsemReset().
+     *
+     * @api
+     */
+    msg_t wait(void) {
+
+      return chBSemWait(&bsem);
+    }
+
+    /**
+     * @brief   Wait operation on the binary semaphore.
+     *
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the semaphore.
+     * @retval MSG_OK       if the binary semaphore has been successfully
+     *                      taken.
+     * @retval MSG_RESET    if the binary semaphore has been reset using
+     *                      @p bsemReset().
+     *
+     * @sclass
+     */
+    msg_t waitS(void) {
+
+      return chBSemWaitS(&bsem);
+    }
+
+    /**
+     * @brief   Wait operation on the binary semaphore.
+     *
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the semaphore.
+     * @retval MSG_OK       if the binary semaphore has been successfully
+     *                      taken.
+     * @retval MSG_RESET    if the binary semaphore has been reset using
+     *                      @p bsemReset().
+     * @retval MSG_TIMEOUT  if the binary semaphore has not been signaled
+     *                      or reset within the specified timeout.
+     *
+     * @api
+     */
+    msg_t wait(sysinterval_t timeout) {
+
+      return chBSemWaitTimeout(&bsem, timeout);
+    }
+
+    /**
+     * @brief   Wait operation on the binary semaphore.
+     *
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the semaphore.
+     * @retval MSG_OK       if the binary semaphore has been successfully
+     *                      taken.
+     * @retval MSG_RESET    if the binary semaphore has been reset using
+     *                      @p bsemReset().
+     * @retval MSG_TIMEOUT  if the binary semaphore has not been signaled
+     *                      or reset within the specified timeout.
+     *
+     * @sclass
+     */
+    msg_t waitS(sysinterval_t timeout) {
+
+      return chBSemWaitTimeoutS(&bsem, timeout);
+    }
+
+    /**
+     * @brief   Reset operation on the binary semaphore.
+     * @note    The released threads can recognize they were waked up by a
+     *          reset rather than a signal because the @p bsemWait() will
+     *          return @p MSG_RESET instead of @p MSG_OK.
+     *
+     * @param[in] taken     new state of the binary semaphore
+     *                      - @a FALSE, the new state is not taken.
+     *                      - @a TRUE, the new state is taken.
+     *                      .
+     *
+     * @api
+     */
+    void reset(bool taken) {
+
+      chBSemReset(&bsem, taken);
+    }
+
+    /**
+     * @brief   Reset operation on the binary semaphore.
+     * @note    The released threads can recognize they were waked up by a
+     *          reset rather than a signal because the @p bsemWait() will
+     *          return @p MSG_RESET instead of @p MSG_OK.
+     * @note    This function does not reschedule.
+     *
+     * @param[in] taken     new state of the binary semaphore
+     *                      - @a FALSE, the new state is not taken.
+     *                      - @a TRUE, the new state is taken.
+     *                      .
+     *
+     * @iclass
+     */
+    void resetI(bool taken) {
+
+      chBSemResetI(&bsem, taken);
+    }
+
+    /**
+     * @brief   Performs a signal operation on a binary semaphore.
+     *
+     * @api
+     */
+    void signal(void) {
+
+      chBSemSignal(&bsem);
+    }
+
+    /**
+     * @brief   Performs a signal operation on a binary semaphore.
+     * @note    This function does not reschedule.
+     *
+     * @iclass
+     */
+    void signalI(void) {
+
+      chBSemSignalI(&bsem);
+    }
+
+    /**
+     * @brief   Returns the binary semaphore current state.
+     *
+     * @return              The binary semaphore current state.
+     * @retval false        if the binary semaphore is not taken.
+     * @retval true         if the binary semaphore is taken.
+     *
+     * @iclass
+     */
+    bool getStateI(void) const {
+
+      return (bool)chBSemGetStateI(&bsem);
+    }
+};
+#endif /* CH_CFG_USE_SEMAPHORES == TRUE */
+
+#if (CH_CFG_USE_MUTEXES == TRUE) || defined(__DOXYGEN__)
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Mutex                                                      *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Class encapsulating a mutex.
+   */
+  class Mutex : public SynchronizationObject {
+    /**
+     * @brief   Embedded @p mutex_t structure.
+     */
+    mutex_t mutex;
+
+  public:
+    /**
+     * @brief   Mutex object constructor.
+     * @details The embedded @p mutex_t structure is initialized.
+     *
+     * @init
+     */
+    Mutex(void) {
+
+      chMtxObjectInit(&mutex);
+    }
+
+    /**
+     * @brief   Tries to lock a mutex.
+     * @details This function attempts to lock a mutex, if the mutex is already
+     *          locked by another thread then the function exits without
+     *          waiting.
+     * @post    The mutex is locked and inserted in the per-thread stack of
+     *          owned mutexes.
+     * @note    This function does not have any overhead related to the
+     *          priority inheritance mechanism because it does not try to
+     *          enter a sleep state.
+     *
+     * @return              The operation status.
+     * @retval TRUE         if the mutex has been successfully acquired
+     * @retval FALSE        if the lock attempt failed.
+     *
+     * @api
+     */
+    bool tryLock(void) {
+
+      return chMtxTryLock(&mutex);
+    }
+
+    /**
+     * @brief   Tries to lock a mutex.
+     * @details This function attempts to lock a mutex, if the mutex is already
+     *          taken by another thread then the function exits without
+     *          waiting.
+     * @post    The mutex is locked and inserted in the per-thread stack of
+     *          owned mutexes.
+     * @note    This function does not have any overhead related to the
+     *          priority inheritance mechanism because it does not try to
+     *          enter a sleep state.
+     *
+     * @return              The operation status.
+     * @retval TRUE         if the mutex has been successfully acquired
+     * @retval FALSE        if the lock attempt failed.
+     *
+     * @sclass
+     */
+    bool tryLockS(void) {
+
+      return chMtxTryLockS(&mutex);
+    }
+
+    /**
+     * @brief   Locks the specified mutex.
+     * @post    The mutex is locked and inserted in the per-thread stack of
+     *          owned mutexes.
+     *
+     * @api
+     */
+    void lock(void) {
+
+      chMtxLock(&mutex);
+    }
+
+    /**
+     * @brief   Locks the specified mutex.
+     * @post    The mutex is locked and inserted in the per-thread stack of
+     *          owned mutexes.
+     *
+     * @sclass
+     */
+    void lockS(void) {
+
+      chMtxLockS(&mutex);
+    }
+
+    /**
+     * @brief   Unlocks the next owned mutex in reverse lock order.
+     * @pre     The invoking thread <b>must</b> have at least one owned mutex.
+     * @post    The mutex is unlocked and removed from the per-thread stack of
+     *          owned mutexes.
+     *
+     * @api
+     */
+    void unlock(void) {
+
+      chMtxUnlock(&mutex);
+    }
+
+    /**
+     * @brief   Unlocks the next owned mutex in reverse lock order.
+     * @pre     The invoking thread <b>must</b> have at least one owned mutex.
+     * @post    The mutex is unlocked and removed from the per-thread stack of
+     *          owned mutexes.
+     * @post    This function does not reschedule so a call to a rescheduling
+     *          function must be performed before unlocking the kernel.
+     *
+     * @sclass
+     */
+    void unlockS(void) {
+
+      chMtxUnlockS(&mutex);
+    }
+
+    /**
+     * @brief   Unlocks the next owned mutex in reverse lock order.
+     * @pre     The invoking thread <b>must</b> have at least one owned mutex.
+     * @post    The mutex is unlocked and removed from the per-thread stack of
+     *          owned mutexes.
+     *
+     * @return              A pointer to the unlocked mutex.
+     *
+     * @api
+     */
+    void unlockMutex(void) {
+
+      chMtxUnlock(&mutex);
+    }
+
+    /**
+     * @brief   Unlocks the next owned mutex in reverse lock order.
+     * @pre     The invoking thread <b>must</b> have at least one owned mutex.
+     * @post    The mutex is unlocked and removed from the per-thread stack of
+     *          owned mutexes.
+     * @post    This function does not reschedule so a call to a rescheduling
+     *          function must be performed before unlocking the kernel.
+     *
+     * @return              A pointer to the unlocked mutex.
+     *
+     * @sclass
+     */
+    void unlockMutexS(void) {
+
+      chMtxUnlockS(&mutex);
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::MutexLocker                                                *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   RAII helper for mutexes.
+   */
+  class MutexLocker
+  {
+    Mutex& mutex;
+
+  public:
+      MutexLocker(Mutex& m) : mutex(m) {
+
+        mutex.lock();
+      }
+
+      ~MutexLocker() {
+
+        mutex.unlock();
+      }
+  };
+
+#if (CH_CFG_USE_CONDVARS == TRUE) || defined(__DOXYGEN__)
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Monitor                                                    *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Template class to be used for implementing a monitor.
+   */
+  template <unsigned N>
+  class Monitor: protected Mutex {
+    condition_variable_t condvars[N];
+
+  protected:
+    /**
+     * @brief   Waits on the condition variable releasing the mutex lock.
+     *
+     * @param[in] var       the condition variable index
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the condition variable.
+     * @retval MSG_OK       if the condition variable has been signaled using
+     *                      @p signal().
+     * @retval MSG_RESET    if the condition variable has been signaled using
+     *                      @p broadcast().
+     *
+     * @api
+     */
+    msg_t wait(unsigned var) {
+
+      chDbgCheck(var < N);
+
+      return chCondWait(&condvars[var]);
+    }
+
+    /**
+     * @brief   Waits on the condition variable releasing the mutex lock.
+     *
+     * @param[in] var       the condition variable index
+     * @return              A message specifying how the invoking thread has
+     *                      been released from the condition variable.
+     * @retval MSG_OK       if the condition variable has been signaled using
+     *                      @p signal().
+     * @retval MSG_RESET    if the condition variable has been signaled using
+     *                      @p broadcast().
+     *
+     * @sclass
+     */
+    msg_t waitS(unsigned var) {
+
+      chDbgCheck(var < N);
+
+      return chCondWaitS(&condvars[var]);
+    }
+
+#if (CH_CFG_USE_CONDVARS_TIMEOUT == TRUE) || defined(__DOXYGEN__)
+    /**
+     * @brief   Waits on the CondVar while releasing the controlling mutex.
+     *
+     * @param[in] var       the condition variable index
+     * @param[in] timeout   the number of ticks before the operation fails
+     * @return              The wakep mode.
+     * @retval MSG_OK       if the condition variable was signaled using
+     *                      @p signal().
+     * @retval MSG_RESET    if the condition variable was signaled using
+     *                      @p broadcast().
+     * @retval MSG_TIMEOUT  if the condition variable was not signaled
+     *                      within the specified timeout.
+     *
+     * @api
+     */
+    msg_t wait(unsigned var, sysinterval_t timeout) {
+
+      chDbgCheck(var < N);
+
+      return chCondWaitTimeout(&condvars[var], timeout);
+    }
+
+    /**
+     * @brief   Waits on the CondVar while releasing the controlling mutex.
+     *
+     * @param[in] var       the condition variable index
+     * @param[in] timeout   the number of ticks before the operation fails
+     * @return              The wakep mode.
+     * @retval MSG_OK       if the condition variable was signaled using
+     *                      @p signal().
+     * @retval MSG_RESET    if the condition variable was signaled using
+     *                      @p broadcast().
+     * @retval MSG_TIMEOUT  if the condition variable was not signaled
+     *                      within the specified timeout.
+     *
+     * @sclass
+     */
+    msg_t waitS(unsigned var, sysinterval_t timeout) {
+
+      chDbgCheck(var < N);
+
+      return chCondWaitTimeoutS(&condvars[var], timeout);
+    }
+#endif /* CH_CFG_USE_CONDVARS_TIMEOUT == TRUE */
+
+  public:
+    /**
+     * @brief   Monitor object constructor.
+     *
+     * @init
+     */
+    Monitor(void) : Mutex() {
+
+      for (unsigned i = 0; i < N; i++) {
+        chCondObjectInit(&condvars[i]);
+      }
+    }
+
+    /**
+     * @brief   Signals one thread that is waiting on the condition variable.
+     *
+     * @param[in] var       the condition variable index
+     *
+     * @api
+     */
+    void signal(unsigned var) {
+
+      chDbgCheck(var < N);
+
+      chCondSignal(&condvars[var]);
+    }
+
+    /**
+     * @brief   Signals one thread that is waiting on the condition variable.
+     * @post    This function does not reschedule so a call to a rescheduling
+     *          function must be performed before unlocking the kernel. Note
+     *          that interrupt handlers always reschedule on exit so an
+     *          explicit reschedule must not be performed in ISRs.
+     *
+     * @param[in] var       the condition variable index
+     *
+     * @iclass
+     */
+    void signalI(unsigned var) {
+
+      chDbgCheck(var < N);
+
+      chCondSignalI(&condvars[var]);
+    }
+
+    /**
+     * @brief   Signals all threads that are waiting on the condition variable.
+     *
+     * @param[in] var       the condition variable index
+     *
+     * @api
+     */
+    void broadcast(unsigned var) {
+
+      chDbgCheck(var < N);
+
+      chCondBroadcast(&condvars[var]);
+    }
+
+    /**
+     * @brief   Signals all threads that are waiting on the condition variable.
+     * @post    This function does not reschedule so a call to a rescheduling
+     *          function must be performed before unlocking the kernel. Note
+     *          that interrupt handlers always reschedule on exit so an
+     *          explicit reschedule must not be performed in ISRs.
+     *
+     * @param[in] var       the condition variable index
+     *
+     * @iclass
+     */
+    void broadcastI(unsigned var) {
+
+      chDbgCheck(var < N);
+
+      chCondBroadcastI(&condvars[var]);
+    }
+  };
+
+#endif /* CH_CFG_USE_CONDVARS == TRUE */
+#endif /* CH_CFG_USE_MUTEXES == TRUE */
+
+#if (CH_CFG_USE_EVENTS == TRUE) || defined(__DOXYGEN__)
+  /*------------------------------------------------------------------------*
+   * chibios_rt::EvtListener                                                *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Class encapsulating an event listener.
+   */
+  class EventListener {
+  public:
+    /**
+     * @brief   Embedded @p event_listener_t structure.
+     */
+    event_listener_t ev_listener;
+
+    /**
+     * @brief   Returns the pending flags from the listener and clears them.
+     *
+     * @return              The flags added to the listener by the
+     *                      associated event source.
+     *
+     * @api
+     */
+    eventflags_t getAndClearFlags(void) {
+
+      return chEvtGetAndClearFlags(&ev_listener);
+    }
+
+    /**
+     * @brief   Returns the flags associated to an @p event_listener_t.
+     * @details The flags are returned and the @p event_listener_t flags mask is
+     *          cleared.
+     *
+     * @return              The flags added to the listener by the associated
+     *                      event source.
+     *
+     * @iclass
+     */
+    eventflags_t getAndClearFlagsI(void) {
+
+      return chEvtGetAndClearFlagsI(&ev_listener);
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::EvtSource                                                  *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Class encapsulating an event source.
+   */
+  class EventSource {
+    /**
+     * @brief   Embedded @p event_source_t structure.
+     */
+    event_source_t ev_source;
+
+   public:
+   /**
+     * @brief   EvtSource object constructor.
+     * @details The embedded @p event_source_t structure is initialized.
+     *
+     * @init
+     */
+    EventSource(void) {
+
+      chEvtObjectInit(&ev_source);
+    }
+
+    /**
+     * @brief   Registers a listener on the event source.
+     *
+     * @param[in] elp       pointer to the @p EvtListener object
+     * @param[in] eid       numeric identifier assigned to the Event
+     *                      Listener
+     *
+     * @api
+     */
+    void registerOne(EventListener *elp,
+                     eventid_t eid) {
+
+      chEvtRegister(&ev_source, &elp->ev_listener, eid);
+    }
+
+    /**
+     * @brief   Registers an Event Listener on an Event Source.
+     * @note    Multiple Event Listeners can specify the same bits to be added.
+     *
+     * @param[in] elp       pointer to the @p EvtListener object
+     * @param[in] emask     the mask of event flags to be pended to the
+     *                      thread when the event source is broadcasted
+     *
+     * @api
+     */
+    void registerMask(EventListener *elp,
+                      eventmask_t emask) {
+
+      chEvtRegisterMask(&ev_source, &elp->ev_listener, emask);
+    }
+
+    /**
+     * @brief   Unregisters a listener.
+     * @details The specified listeners is no more signaled by the event
+     *          source.
+     *
+     * @param[in] elp       the listener to be unregistered
+     *
+     * @api
+     */
+    void unregister(EventListener *elp) {
+
+      chEvtUnregister(&ev_source, &elp->ev_listener);
+    }
+
+    /**
+     * @brief   Broadcasts on an event source.
+     * @details All the listeners registered on the event source are signaled
+     *          and the flags are added to the listener's flags mask.
+     *
+     * @param[in] flags     the flags set to be added to the listener
+     *                      flags mask
+     *
+     * @api
+     */
+    void broadcastFlags(eventflags_t flags) {
+
+      chEvtBroadcastFlags(&ev_source, flags);
+    }
+
+    /**
+     * @brief   Broadcasts on an event source.
+     * @details All the listeners registered on the event source are signaled
+     *          and the flags are added to the listener's flags mask.
+     *
+     * @param[in] flags     the flags set to be added to the listener
+     *                      flags mask
+     *
+     * @iclass
+     */
+    void broadcastFlagsI(eventflags_t flags) {
+
+      chEvtBroadcastFlagsI(&ev_source, flags);
+    }
+  };
+#endif /* CH_CFG_USE_EVENTS == TRUE */
+
+#if (CH_CFG_USE_MAILBOXES == TRUE) || defined(__DOXYGEN__)
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Mailbox                                                    *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Base mailbox class.
+   *
+   * @param T               type of objects that mailbox able to handle
+   */
+  template <typename T>
+  class MailboxBase {
+
+    /**
+     * @brief   Embedded @p mailbox_t structure.
+     */
+    mailbox_t mb;
+
+   public:
+   /**
+     * @brief   Mailbox constructor.
+     * @details The embedded @p mailbox_t structure is initialized.
+     *
+     * @param[in] buf       pointer to the messages buffer as an array of
+     *                      @p msg_t
+     * @param[in] n         number of elements in the buffer array
+     *
+     * @init
+     */
+    MailboxBase(msg_t *buf, cnt_t n) {
+
+      chMBObjectInit(&mb, buf, n);
+    }
+
+    /**
+     * @brief   Resets a Mailbox object.
+     * @details All the waiting threads are resumed with status @p MSG_RESET
+     *          and the queued messages are lost.
+     *
+     * @api
+     */
+    void reset(void) {
+
+      chMBReset(&mb);
+    }
+
+    /**
+     * @brief   Terminates the reset state.
+     *
+     * @xclass
+     */
+    void resumeX(void) {
+
+      chMBResumeX(&mb);
+    }
+
+    /**
+     * @brief   Posts a message into a mailbox.
+     * @details The invoking thread waits until a empty slot in the mailbox
+     *          becomes available or the specified time runs out.
+     *
+     * @param[in] msg       the message to be posted on the mailbox
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              The operation status.
+     * @retval MSG_OK       if a message has been correctly posted.
+     * @retval MSG_RESET    if the mailbox has been reset while waiting.
+     * @retval MSG_TIMEOUT  if the operation has timed out.
+     *
+     * @api
+     */
+    msg_t post(T msg, sysinterval_t timeout) {
+
+      return chMBPostTimeout(&mb, reinterpret_cast<msg_t>(msg), timeout);
+    }
+
+    /**
+     * @brief   Posts a message into a mailbox.
+     * @details The invoking thread waits until a empty slot in the mailbox
+     *          becomes available or the specified time runs out.
+     *
+     * @param[in] msg       the message to be posted on the mailbox
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              The operation status.
+     * @retval MSG_OK       if a message has been correctly posted.
+     * @retval MSG_RESET    if the mailbox has been reset while waiting.
+     * @retval MSG_TIMEOUT  if the operation has timed out.
+     *
+     * @sclass
+     */
+    msg_t postS(T msg, sysinterval_t timeout) {
+
+      return chMBPostTimeoutS(&mb, reinterpret_cast<msg_t>(msg), timeout);
+    }
+
+    /**
+     * @brief   Posts a message into a mailbox.
+     * @details This variant is non-blocking, the function returns a timeout
+     *          condition if the queue is full.
+     *
+     * @param[in] msg       the message to be posted on the mailbox
+     * @return              The operation status.
+     * @retval MSG_OK       if a message has been correctly posted.
+     * @retval MSG_TIMEOUT  if the mailbox is full and the message cannot be
+     *                      posted.
+     *
+     * @iclass
+     */
+    msg_t postI(T msg) {
+
+      return chMBPostI(&mb, reinterpret_cast<msg_t>(msg));
+    }
+
+    /**
+     * @brief   Posts an high priority message into a mailbox.
+     * @details The invoking thread waits until a empty slot in the mailbox
+     *          becomes available or the specified time runs out.
+     *
+     * @param[in] msg       the message to be posted on the mailbox
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              The operation status.
+     * @retval MSG_OK       if a message has been correctly posted.
+     * @retval MSG_RESET    if the mailbox has been reset while waiting.
+     * @retval MSG_TIMEOUT  if the operation has timed out.
+     *
+     * @api
+     */
+    msg_t postAhead(T msg, sysinterval_t timeout) {
+
+      return chMBPostAheadTimeout(&mb, reinterpret_cast<msg_t>(msg), timeout);
+    }
+
+    /**
+     * @brief   Posts an high priority message into a mailbox.
+     * @details The invoking thread waits until a empty slot in the mailbox
+     *          becomes available or the specified time runs out.
+     *
+     * @param[in] msg       the message to be posted on the mailbox
+     * @param[in] timeout   the number of ticks before the operation timeouts,
+     *                      the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              The operation status.
+     * @retval MSG_OK       if a message has been correctly posted.
+     * @retval MSG_RESET    if the mailbox has been reset while waiting.
+     * @retval MSG_TIMEOUT  if the operation has timed out.
+     *
+     * @sclass
+     */
+    msg_t postAheadS(T msg, sysinterval_t timeout) {
+
+      return chMBPostAheadTimeoutS(&mb, reinterpret_cast<msg_t>(msg), timeout);
+    }
+
+    /**
+     * @brief   Posts an high priority message into a mailbox.
+     * @details This variant is non-blocking, the function returns a timeout
+     *          condition if the queue is full.
+     *
+     * @param[in] msg       the message to be posted on the mailbox
+     * @return              The operation status.
+     * @retval MSG_OK       if a message has been correctly posted.
+     * @retval MSG_TIMEOUT  if the mailbox is full and the message cannot be
+     *                      posted.
+     *
+     * @iclass
+     */
+    msg_t postAheadI(T msg) {
+
+      return chMBPostAheadI(&mb, reinterpret_cast<msg_t>(msg));
+    }
+
+    /**
+     * @brief   Retrieves a message from a mailbox.
+     * @details The invoking thread waits until a message is posted in the
+     *          mailbox or the specified time runs out.
+     *
+     * @param[out] msgp     pointer to a message variable for the received
+     * @param[in] timeout   message the number of ticks before the operation
+     *                      timeouts, the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              The operation status.
+     * @retval MSG_OK       if a message has been correctly fetched.
+     * @retval MSG_RESET    if the mailbox has been reset while waiting.
+     * @retval MSG_TIMEOUT  if the operation has timed out.
+     *
+     * @api
+     */
+    msg_t fetch(T *msgp, sysinterval_t timeout) {
+
+      return chMBFetchTimeout(&mb, reinterpret_cast<msg_t*>(msgp), timeout);
+    }
+
+    /**
+     * @brief   Retrieves a message from a mailbox.
+     * @details The invoking thread waits until a message is posted in the
+     *          mailbox or the specified time runs out.
+     *
+     * @param[out] msgp     pointer to a message variable for the received
+     * @param[in] timeout   message the number of ticks before the operation
+     *                      timeouts, the following special values are allowed:
+     *                      - @a TIME_IMMEDIATE immediate timeout.
+     *                      - @a TIME_INFINITE no timeout.
+     *                      .
+     * @return              The operation status.
+     * @retval MSG_OK       if a message has been correctly fetched.
+     * @retval MSG_RESET    if the mailbox has been reset while waiting.
+     * @retval MSG_TIMEOUT  if the operation has timed out.
+     *
+     * @sclass
+     */
+    msg_t fetchS(T *msgp, sysinterval_t timeout) {
+
+      return chMBFetchTimeoutS(&mb, reinterpret_cast<msg_t*>(msgp), timeout);
+    }
+
+    /**
+     * @brief   Retrieves a message from a mailbox.
+     * @details This variant is non-blocking, the function returns a timeout
+     *          condition if the queue is empty.
+     *
+     * @param[out] msgp     pointer to a message variable for the received
+     *                      message
+     * @return              The operation status.
+     * @retval MSG_OK       if a message has been correctly fetched.
+     * @retval MSG_TIMEOUT  if the mailbox is empty and a message cannot be
+     *                      fetched.
+     *
+     * @iclass
+     */
+    msg_t fetchI(T *msgp) {
+
+      return chMBFetchI(&mb, reinterpret_cast<msg_t*>(msgp));
+    }
+
+    /**
+     * @brief   Returns the next message in the queue without removing it.
+     * @pre     A message must be waiting in the queue for this function to work
+     *          or it would return garbage. The correct way to use this macro is
+     *          to use @p getUsedCountI() and then use this macro, all within
+     *          a lock state.
+     *
+     * @return              The next message in queue.
+     *
+     * @iclass
+     */
+    T peekI(const mailbox_t *mbp) const {
+
+      return chMBPeekI(&mb);
+    }
+
+    /**
+     * @brief   Returns the number of free message slots into a mailbox.
+     * @note    Can be invoked in any system state but if invoked out of a
+     *          locked state then the returned value may change after reading.
+     * @note    The returned value can be less than zero when there are waiting
+     *          threads on the internal semaphore.
+     *
+     * @return              The number of empty message slots.
+     *
+     * @iclass
+     */
+    cnt_t getFreeCountI(void) const {
+
+      return chMBGetFreeCountI(&mb);
+    }
+
+    /**
+     * @brief   Returns the number of used message slots into a mailbox.
+     * @note    Can be invoked in any system state but if invoked out of a
+     *          locked state then the returned value may change after reading.
+     * @note    The returned value can be less than zero when there are waiting
+     *          threads on the internal semaphore.
+     *
+     * @return              The number of queued messages.
+     *
+     * @iclass
+     */
+    cnt_t getUsedCountI(void) const {
+
+      return chMBGetUsedCountI(&mb);
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Mailbox                                                    *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief     Template class encapsulating a mailbox and its messages buffer.
+   *
+   * @param N               length of the mailbox buffer
+   */
+  template <typename T, int N>
+  class Mailbox : public MailboxBase<T> {
+
+    static_assert(sizeof(T) <= sizeof(msg_t),
+                  "Mailbox type does not fit in msg_t");
+
+  private:
+    msg_t   mb_buf[N];
+
+  public:
+    /**
+     * @brief   Mailbox constructor.
+     *
+     * @init
+     */
+    Mailbox(void) :
+      MailboxBase<T>(mb_buf, (cnt_t)(sizeof mb_buf / sizeof (msg_t))) {
+    }
+  };
+#endif /* CH_CFG_USE_MAILBOXES == TRUE */
+
+#if (CH_CFG_USE_MEMPOOLS == TRUE) || defined(__DOXYGEN__)
+  /*------------------------------------------------------------------------*
+   * chibios_rt::MemoryPool                                                 *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Class encapsulating a memory pool.
+   */
+  class MemoryPool {
+    /**
+     * @brief   Embedded @p memory_pool_t structure.
+     */
+    memory_pool_t pool;
+
+  public:
+    /**
+     * @brief   MemoryPool constructor.
+     *
+     * @param[in] size      the size of the objects contained in this memory
+     *                      pool, the minimum accepted size is the size of
+     *                      a pointer to void.
+     * @param[in] provider  memory provider function for the memory pool or
+     *                      @p nullptr if the pool is not allowed to grow
+     *                      automatically
+     *
+     * @init
+     */
+    MemoryPool(size_t size, memgetfunc_t provider=0) : pool() {
+
+      chPoolObjectInit(&pool, size, provider);
+    }
+
+    /**
+     * @brief   MemoryPool constructor.
+     *
+     * @param[in] size      the size of the objects contained in this memory
+     *                      pool, the minimum accepted size is the size of
+     *                      a pointer to void.
+     * @param[in] provider  memory provider function for the memory pool or
+     *                      @p nullptr if the pool is not allowed to grow
+     *                      automatically
+     * @param[in] p         pointer to the array first element
+     * @param[in] n         number of elements in the array
+     *
+     * @init
+     */
+    MemoryPool(size_t size, void* p, size_t n,
+               memgetfunc_t provider=0) : pool() {
+
+      chPoolObjectInit(&pool, size, provider);
+      chPoolLoadArray(&pool, p, n);
+    }
+
+    /* Prohibit copy construction and assignment, but allow move.*/
+    MemoryPool(const MemoryPool &) = delete;
+    MemoryPool &operator=(const MemoryPool &) = delete;
+    MemoryPool(MemoryPool &&) = default;
+    MemoryPool &operator=(MemoryPool &&) = default;
+
+    /**
+     * @brief   Loads a memory pool with an array of static objects.
+     * @pre     The memory pool must be already been initialized.
+     * @pre     The array elements must be of the right size for the specified
+     *          memory pool.
+     * @post    The memory pool contains the elements of the input array.
+     *
+     * @param[in] p         pointer to the array first element
+     * @param[in] n         number of elements in the array
+     *
+     * @api
+     */
+    void loadArray(void *p, size_t n) {
+
+      chPoolLoadArray(&pool, p, n);
+    }
+
+    /**
+     * @brief   Allocates an object from a memory pool.
+     * @pre     The memory pool must be already been initialized.
+     *
+     * @return              The pointer to the allocated object.
+     * @retval nullptr      if pool is empty.
+     *
+     * @iclass
+     */
+    void *allocI(void) {
+
+      return chPoolAllocI(&pool);
+    }
+
+    /**
+     * @brief   Allocates an object from a memory pool.
+     * @pre     The memory pool must be already been initialized.
+     *
+     * @return              The pointer to the allocated object.
+     * @retval nullptr      if pool is empty.
+     *
+     * @api
+     */
+    void *alloc(void) {
+
+      return chPoolAlloc(&pool);
+    }
+
+    /**
+     * @brief   Releases an object into a memory pool.
+     * @pre     The memory pool must be already been initialized.
+     * @pre     The freed object must be of the right size for the specified
+     *          memory pool.
+     * @pre     The object must be properly aligned to contain a pointer to
+     *          void.
+     *
+     * @param[in] objp      the pointer to the object to be released
+     *
+     * @iclass
+     */
+    void free(void *objp) {
+
+      chPoolFree(&pool, objp);
+    }
+
+    /**
+     * @brief   Adds an object to a memory pool.
+     * @pre     The memory pool must be already been initialized.
+     * @pre     The added object must be of the right size for the specified
+     *          memory pool.
+     * @pre     The added object must be memory aligned to the size of
+     *          @p stkalign_t type.
+     * @note    This function is just an alias for @p chPoolFree() and has been
+     *          added for clarity.
+     *
+     * @param[in] objp      the pointer to the object to be added
+     *
+     * @iclass
+     */
+    void freeI(void *objp) {
+
+      chPoolFreeI(&pool, objp);
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::ObjectsPool                                                *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Template class encapsulating a memory pool and its elements.
+   */
+  template<class T, size_t N>
+  class ObjectsPool : public MemoryPool {
+    /* The buffer is declared as an array of pointers to void for two
+       reasons:
+       1) The objects must be properly aligned to hold a pointer as
+          first field.
+       2) Objects are dirtied when loaded in the pool.*/
+    void *pool_buf[(N * sizeof (T)) / sizeof (void *)];
+
+  public:
+    /**
+     * @brief   ObjectsPool constructor.
+     *
+     * @init
+     */
+    ObjectsPool(void) : MemoryPool(sizeof (T), nullptr) {
+
+      loadArray(pool_buf, N);
+    }
+  };
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::ThreadsPool                                                *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Template class encapsulating a pool of threads.
+   */
+  template<size_t S, size_t N, const char *C>
+  class ThreadsPool : public BaseDynamicThread {
+    THD_WORKING_AREA(working_areas, S)[N];
+    MemoryPool threads_pool;
+
+  public:
+    /**
+     * @brief   ThreadsPool constructor.
+     *
+     * @init
+     */
+    ThreadsPool(void) : threads_pool(THD_WORKING_AREA_SIZE(S)) {
+
+      threads_pool.loadArray(working_areas, N);
+    }
+
+    /**
+     * @brief   Starts a dynamic thread from the pool.
+     *
+     * @param[in] prio          thread priority
+     * @return                  A reference to the created thread with
+     *                          reference counter set to one.
+     *
+     * @api
+     */
+    ThreadReference start(tprio_t prio) override {
+      void _thd_start(void *arg);
+
+      return ThreadReference(chThdCreateFromMemoryPool(&threads_pool.pool,
+                                                       C,
+                                                       prio,
+                                                       _thd_start,
+                                                       this));
+     }
+   };
+#endif /* CH_CFG_USE_MEMPOOLS == TRUE */
+
+#if (CH_CFG_USE_HEAP == TRUE) || defined(__DOXYGEN__)
+  /*------------------------------------------------------------------------*
+   * chibios_rt::Heap                                                       *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Class encapsulating a heap.
+   */
+  class Heap {
+    /**
+     * @brief   Embedded @p memory_heap_t structure.
+     */
+    memory_heap_t heap;
+
+  public:
+    /**
+     * @brief   Heap constructor.
+     * @pre     Both the heap buffer base and the heap size must be aligned to
+     *          the @p stkalign_t type size.
+     *
+     * @param[in] buffer    heap buffer base
+     * @param[in] size      the size of the memory area located at \e buffer
+     * @init
+     */
+    Heap(void *buffer, const size_t size) : heap() {
+
+      chHeapObjectInit(&heap, buffer, size);
+    }
+
+    /* Prohibit copy construction and assignment, but allow move.*/
+    Heap(const Heap &) = delete;
+    Heap &operator=(const Heap &) = delete;
+    Heap(Heap &&) = default;
+    Heap &operator=(Heap &&) = default;
+
+    /**
+     * @brief   Allocates an object from a heap.
+     * @pre     The heap must be already been initialized.
+     *
+     * @return              The pointer to the allocated object.
+     * @retval nullptr      if pool is empty.
+     *
+     * @api
+     */
+    void *alloc(const size_t size) {
+
+      return chHeapAlloc(&heap, size);
+    }
+
+    /**
+     * @brief   Releases an object into the heap.
+     *
+     * @param[in] objp      the pointer to the object to be released
+     *
+     * @api
+     */
+    void free(void *objp) {
+
+      chHeapFree(objp);
+    }
+
+    /**
+     * @brief   Reports the heap status.
+     *
+     * @param[out] frag     the size of total fragmented free space
+     * @param[in] largestp  pointer to a variable that will receive the largest
+     *                      free free block found space or @p nullptr
+     * @return              the number of fragments in the heap
+     *
+     * @api
+     */
+    size_t status(size_t &frag, size_t *largestp=0) {
+
+      return chHeapStatus(&heap, &frag, largestp);
+    }
+  };
+#endif /* CH_CFG_USE_MEMPOOLS == TRUE */
+
+  /*------------------------------------------------------------------------*
+   * chibios_rt::BaseSequentialStreamInterface                              *
+   *------------------------------------------------------------------------*/
+  /**
+   * @brief   Interface of a BaseSequentialStream.
+   * @note    You can cast a BaseSequentialStream to this interface and use
+   *          it, the memory layout is the same.
+   */
+  class BaseSequentialStreamInterface {
+  public:
+    /**
+     * @brief   Sequential Stream write.
+     * @details The function writes data from a buffer to a stream.
+     *
+     * @param[in] bp        pointer to the data buffer
+     * @param[in] n         the maximum amount of data to be transferred
+     * @return              The number of bytes transferred. The return value
+     *                      can be less than the specified number of bytes if
+     *                      an end-of-file condition has been met.
+     *
+     * @api
+     */
+    virtual size_t write(const uint8_t *bp, const size_t n) = 0;
+
+    /**
+     * @brief   Sequential Stream read.
+     * @details The function reads data from a stream into a buffer.
+     *
+     * @param[out] bp       pointer to the data buffer
+     * @param[in] n         the maximum amount of data to be transferred
+     * @return              The number of bytes transferred. The return value
+     *                      can be less than the specified number of bytes if
+     *                      an end-of-file condition has been met.
+     *
+     * @api
+     */
+    virtual size_t read(uint8_t *bp, const size_t n) = 0;
+
+    /**
+     * @brief   Sequential Stream blocking byte write.
+     * @details This function writes a byte value to a channel. If the channel
+     *          is not ready to accept data then the calling thread is
+     *          suspended.
+     *
+     * @param[in] b         the byte value to be written to the channel
+     *
+     * @return              The operation status.
+     * @retval Q_OK         if the operation succeeded.
+     * @retval Q_RESET      if an end-of-file condition has been met.
+     *
+     * @api
+     */
+    virtual msg_t put(const uint8_t b) = 0;
+
+    /**
+     * @brief   Sequential Stream blocking byte read.
+     * @details This function reads a byte value from a channel. If the data
+     *          is not available then the calling thread is suspended.
+     *
+     * @return              A byte value from the queue.
+     * @retval Q_RESET      if an end-of-file condition has been met.
+     *
+     * @api
+     */
+    virtual msg_t get(void) = 0;
+  };
+}
+
+#endif /* _CH_HPP_ */
+
+/** @} */
diff --git a/lib/chibios/os/various/cpp_wrappers/chcpp.mk b/lib/chibios/os/various/cpp_wrappers/chcpp.mk
new file mode 100644
index 000000000..b32334e29
--- /dev/null
+++ b/lib/chibios/os/various/cpp_wrappers/chcpp.mk
@@ -0,0 +1,9 @@
+# C++ wrapper files.
+CHCPPSRC = $(CHIBIOS)/os/various/cpp_wrappers/ch.cpp \
+           $(CHIBIOS)/os/various/cpp_wrappers/syscalls_cpp.cpp
+
+CHCPPINC = $(CHIBIOS)/os/various/cpp_wrappers
+
+# Shared variables
+ALLCPPSRC += $(CHCPPSRC)
+ALLINC    += $(CHCPPINC)
diff --git a/lib/chibios/os/various/cpp_wrappers/syscalls_cpp.cpp b/lib/chibios/os/various/cpp_wrappers/syscalls_cpp.cpp
new file mode 100644
index 000000000..486461a76
--- /dev/null
+++ b/lib/chibios/os/various/cpp_wrappers/syscalls_cpp.cpp
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <errno.h>
+
+#include "osal.h"
+
+#include "syscalls_cpp.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void _exit(int status){
+   (void) status;
+   osalSysHalt("Unrealized");
+   while(TRUE){}
+}
+
+pid_t _getpid(void){
+   return 1;
+}
+
+#undef errno
+extern int errno;
+int _kill(int pid, int sig) {
+  (void)pid;
+  (void)sig;
+  errno = EINVAL;
+  return -1;
+}
+
+void _open_r(void){
+  return;
+}
+
+void __cxa_pure_virtual() {
+  osalSysHalt("Pure virtual function call.");
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/chibios/os/various/cpp_wrappers/syscalls_cpp.hpp b/lib/chibios/os/various/cpp_wrappers/syscalls_cpp.hpp
new file mode 100644
index 000000000..cd78a9c5d
--- /dev/null
+++ b/lib/chibios/os/various/cpp_wrappers/syscalls_cpp.hpp
@@ -0,0 +1,13 @@
+#ifndef SYSCALLS_CPP_HPP_
+#define SYSCALLS_CPP_HPP_
+
+/* The ABI requires a 32-bit type.*/
+typedef int __guard;
+
+int __cxa_guard_acquire(__guard *);
+void __cxa_guard_release (__guard *);
+void __cxa_guard_abort (__guard *);
+
+void *__dso_handle = NULL;
+
+#endif /* SYSCALLS_CPP_HPP_ */
diff --git a/lib/chibios/os/various/evtimer.c b/lib/chibios/os/various/evtimer.c
new file mode 100644
index 000000000..310a339c6
--- /dev/null
+++ b/lib/chibios/os/various/evtimer.c
@@ -0,0 +1,85 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+/**
+ * @file    evtimer.c
+ * @brief   Events Generator Timer code.
+ *
+ * @addtogroup event_timer
+ * @{
+ */
+
+#include "ch.h"
+#include "evtimer.h"
+
+/*===========================================================================*/
+/* Module local definitions.                                                 */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module exported variables.                                                */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local types.                                                       */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local variables.                                                   */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local functions.                                                   */
+/*===========================================================================*/
+
+static void tmrcb(void *p) {
+  event_timer_t *etp = p;
+
+  chSysLockFromISR();
+  chEvtBroadcastI(&etp->et_es);
+  chVTDoSetI(&etp->et_vt, etp->et_interval, tmrcb, etp);
+  chSysUnlockFromISR();
+}
+
+/*===========================================================================*/
+/* Module exported functions.                                                */
+/*===========================================================================*/
+
+/**
+ * @brief Initializes an @p event_timer_t structure.
+ *
+ * @param[out] etp      the @p event_timer_t structure to be initialized
+ * @param[in] time      the interval in system ticks
+ */
+void evtObjectInit(event_timer_t *etp, systime_t time) {
+
+  chEvtObjectInit(&etp->et_es);
+  chVTObjectInit(&etp->et_vt);
+  etp->et_interval = time;
+}
+
+/**
+ * @brief   Starts the timer
+ * @details If the timer was already running then the function has no effect.
+ *
+ * @param[in] etp       pointer to an initialized @p event_timer_t structure.
+ */
+void evtStart(event_timer_t *etp) {
+
+  chVTSet(&etp->et_vt, etp->et_interval, tmrcb, etp);
+}
+
+/** @} */
diff --git a/lib/chibios/os/various/evtimer.h b/lib/chibios/os/various/evtimer.h
new file mode 100644
index 000000000..60e9939cf
--- /dev/null
+++ b/lib/chibios/os/various/evtimer.h
@@ -0,0 +1,94 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+/**
+ * @file    evtimer.h
+ * @brief   Events Generator Timer structures and macros.
+ *
+ * @addtogroup event_timer
+ * @{
+ */
+
+#ifndef EVTIMER_H
+#define EVTIMER_H
+
+/*===========================================================================*/
+/* Module constants.                                                         */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module pre-compile time settings.                                         */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Derived constants and error checks.                                       */
+/*===========================================================================*/
+
+/*
+ * Module dependencies check.
+ */
+#if !CH_CFG_USE_EVENTS
+#error "Event Timers require CH_CFG_USE_EVENTS"
+#endif
+
+/*===========================================================================*/
+/* Module data structures and types.                                         */
+/*===========================================================================*/
+
+/**
+ * @brief   Type of a event timer structure.
+ */
+typedef struct {
+  virtual_timer_t       et_vt;
+  event_source_t        et_es;
+  systime_t             et_interval;
+} event_timer_t;
+
+/*===========================================================================*/
+/* Module macros.                                                            */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  void evtObjectInit(event_timer_t *etp, systime_t time);
+  void evtStart(event_timer_t *etp);
+#ifdef __cplusplus
+}
+#endif
+
+/*===========================================================================*/
+/* Module inline functions.                                                  */
+/*===========================================================================*/
+
+/**
+ * @brief   Stops the timer.
+ * @details If the timer was already stopped then the function has no effect.
+ *
+ * @param[in] etp       pointer to an initialized @p event_timer_t structure.
+ */
+static inline void evtStop(event_timer_t *etp) {
+
+  chVTReset(&etp->et_vt);
+}
+
+#endif /* EVTIMER_H */
+
+/** @} */
diff --git a/lib/chibios/os/various/fatfs_bindings/fatfs.mk b/lib/chibios/os/various/fatfs_bindings/fatfs.mk
new file mode 100644
index 000000000..02f1c8e38
--- /dev/null
+++ b/lib/chibios/os/various/fatfs_bindings/fatfs.mk
@@ -0,0 +1,11 @@
+# FATFS files.
+FATFSSRC = $(CHIBIOS)/os/various/fatfs_bindings/fatfs_diskio.c \
+           $(CHIBIOS)/os/various/fatfs_bindings/fatfs_syscall.c \
+           $(CHIBIOS)/ext/fatfs/source/ff.c \
+           $(CHIBIOS)/ext/fatfs/source/ffunicode.c
+
+FATFSINC = $(CHIBIOS)/ext/fatfs/source
+
+# Shared variables
+ALLCSRC += $(FATFSSRC)
+ALLINC  += $(FATFSINC)
diff --git a/lib/chibios/os/various/fatfs_bindings/fatfs_diskio.c b/lib/chibios/os/various/fatfs_bindings/fatfs_diskio.c
new file mode 100644
index 000000000..941943a90
--- /dev/null
+++ b/lib/chibios/os/various/fatfs_bindings/fatfs_diskio.c
@@ -0,0 +1,267 @@
+/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2007        */
+/*-----------------------------------------------------------------------*/
+/* This is a stub disk I/O module that acts as front end of the existing */
+/* disk I/O modules and attach it to FatFs module with common interface. */
+/*-----------------------------------------------------------------------*/
+
+#include "hal.h"
+#include "ffconf.h"
+#include "ff.h"
+#include "diskio.h"
+
+#if HAL_USE_MMC_SPI && HAL_USE_SDC
+#error "cannot specify both MMC_SPI and SDC drivers"
+#endif
+
+#if !defined(FATFS_HAL_DEVICE)
+#if HAL_USE_MMC_SPI
+#define FATFS_HAL_DEVICE MMCD1
+#else
+#define FATFS_HAL_DEVICE SDCD1
+#endif
+#endif
+
+#if HAL_USE_MMC_SPI
+extern MMCDriver FATFS_HAL_DEVICE;
+#elif HAL_USE_SDC
+extern SDCDriver FATFS_HAL_DEVICE;
+#else
+#error "MMC_SPI or SDC driver must be specified"
+#endif
+
+#if HAL_USE_RTC
+extern RTCDriver RTCD1;
+#endif
+
+/*-----------------------------------------------------------------------*/
+/* Correspondence between physical drive number and physical drive.      */
+
+#define MMC     0
+#define SDC     0
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Inidialize a Drive                                                    */
+
+DSTATUS disk_initialize (
+    BYTE pdrv         /* Physical drive number (0..) */
+)
+{
+  DSTATUS stat;
+
+  switch (pdrv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    stat = 0;
+    /* It is initialized externally, just reads the status.*/
+    if (blkGetDriverState(&FATFS_HAL_DEVICE) != BLK_READY)
+      stat |= STA_NOINIT;
+    if (mmcIsWriteProtected(&FATFS_HAL_DEVICE))
+      stat |=  STA_PROTECT;
+    return stat;
+#else
+  case SDC:
+    stat = 0;
+    /* It is initialized externally, just reads the status.*/
+    if (blkGetDriverState(&FATFS_HAL_DEVICE) != BLK_READY)
+      stat |= STA_NOINIT;
+    if (sdcIsWriteProtected(&FATFS_HAL_DEVICE))
+      stat |=  STA_PROTECT;
+    return stat;
+#endif
+  }
+  return STA_NOINIT;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Return Disk Status                                                    */
+
+DSTATUS disk_status (
+    BYTE pdrv         /* Physical drive number (0..) */
+)
+{
+  DSTATUS stat;
+
+  switch (pdrv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    stat = 0;
+    /* It is initialized externally, just reads the status.*/
+    if (blkGetDriverState(&FATFS_HAL_DEVICE) != BLK_READY)
+      stat |= STA_NOINIT;
+    if (mmcIsWriteProtected(&FATFS_HAL_DEVICE))
+      stat |= STA_PROTECT;
+    return stat;
+#else
+  case SDC:
+    stat = 0;
+    /* It is initialized externally, just reads the status.*/
+    if (blkGetDriverState(&FATFS_HAL_DEVICE) != BLK_READY)
+      stat |= STA_NOINIT;
+    if (sdcIsWriteProtected(&FATFS_HAL_DEVICE))
+      stat |= STA_PROTECT;
+    return stat;
+#endif
+  }
+  return STA_NOINIT;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Sector(s)                                                        */
+
+DRESULT disk_read (
+    BYTE pdrv,        /* Physical drive number (0..) */
+    BYTE *buff,       /* Data buffer to store read data */
+    DWORD sector,     /* Sector address (LBA) */
+    UINT count        /* Number of sectors to read (1..255) */
+)
+{
+  switch (pdrv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    if (blkGetDriverState(&FATFS_HAL_DEVICE) != BLK_READY)
+      return RES_NOTRDY;
+    if (mmcStartSequentialRead(&FATFS_HAL_DEVICE, sector))
+      return RES_ERROR;
+    while (count > 0) {
+      if (mmcSequentialRead(&FATFS_HAL_DEVICE, buff))
+        return RES_ERROR;
+      buff += MMCSD_BLOCK_SIZE;
+      count--;
+    }
+    if (mmcStopSequentialRead(&FATFS_HAL_DEVICE))
+        return RES_ERROR;
+    return RES_OK;
+#else
+  case SDC:
+    if (blkGetDriverState(&FATFS_HAL_DEVICE) != BLK_READY)
+      return RES_NOTRDY;
+    if (sdcRead(&FATFS_HAL_DEVICE, sector, buff, count))
+      return RES_ERROR;
+    return RES_OK;
+#endif
+  }
+  return RES_PARERR;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Write Sector(s)                                                       */
+
+#if !FF_FS_READONLY
+DRESULT disk_write (
+    BYTE pdrv,        /* Physical drive number (0..) */
+    const BYTE *buff, /* Data to be written */
+    DWORD sector,     /* Sector address (LBA) */
+    UINT count        /* Number of sectors to write (1..255) */
+)
+{
+  switch (pdrv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    if (blkGetDriverState(&FATFS_HAL_DEVICE) != BLK_READY)
+        return RES_NOTRDY;
+    if (mmcIsWriteProtected(&FATFS_HAL_DEVICE))
+        return RES_WRPRT;
+    if (mmcStartSequentialWrite(&FATFS_HAL_DEVICE, sector))
+        return RES_ERROR;
+    while (count > 0) {
+        if (mmcSequentialWrite(&FATFS_HAL_DEVICE, buff))
+            return RES_ERROR;
+        buff += MMCSD_BLOCK_SIZE;
+        count--;
+    }
+    if (mmcStopSequentialWrite(&FATFS_HAL_DEVICE))
+        return RES_ERROR;
+    return RES_OK;
+#else
+  case SDC:
+    if (blkGetDriverState(&FATFS_HAL_DEVICE) != BLK_READY)
+      return RES_NOTRDY;
+    if (sdcWrite(&FATFS_HAL_DEVICE, sector, buff, count))
+      return RES_ERROR;
+    return RES_OK;
+#endif
+  }
+  return RES_PARERR;
+}
+#endif /* _FS_READONLY */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous Functions                                               */
+
+DRESULT disk_ioctl (
+    BYTE pdrv,        /* Physical drive number (0..) */
+    BYTE cmd,         /* Control code */
+    void *buff        /* Buffer to send/receive control data */
+)
+{
+  (void)buff;
+
+  switch (pdrv) {
+#if HAL_USE_MMC_SPI
+  case MMC:
+    switch (cmd) {
+    case CTRL_SYNC:
+        return RES_OK;
+#if FF_MAX_SS > FF_MIN_SS
+    case GET_SECTOR_SIZE:
+        *((WORD *)buff) = MMCSD_BLOCK_SIZE;
+        return RES_OK;
+#endif
+#if FF_USE_TRIM
+    case CTRL_TRIM:
+        mmcErase(&FATFS_HAL_DEVICE, *((DWORD *)buff), *((DWORD *)buff + 1));
+        return RES_OK;
+#endif
+    default:
+        return RES_PARERR;
+    }
+#else
+  case SDC:
+    switch (cmd) {
+    case CTRL_SYNC:
+        return RES_OK;
+    case GET_SECTOR_COUNT:
+        *((DWORD *)buff) = mmcsdGetCardCapacity(&FATFS_HAL_DEVICE);
+        return RES_OK;
+#if FF_MAX_SS > FF_MIN_SS
+    case GET_SECTOR_SIZE:
+        *((WORD *)buff) = MMCSD_BLOCK_SIZE;
+        return RES_OK;
+#endif
+    case GET_BLOCK_SIZE:
+        *((DWORD *)buff) = 256; /* 512b blocks in one erase block */
+        return RES_OK;
+#if FF_USE_TRIM
+    case CTRL_TRIM:
+        sdcErase(&FATFS_HAL_DEVICE, *((DWORD *)buff), *((DWORD *)buff + 1));
+        return RES_OK;
+#endif
+    default:
+        return RES_PARERR;
+    }
+#endif
+  }
+  return RES_PARERR;
+}
+
+DWORD get_fattime(void) {
+#if HAL_USE_RTC
+    RTCDateTime timespec;
+
+    rtcGetTime(&RTCD1, &timespec);
+    return rtcConvertDateTimeToFAT(&timespec);
+#else
+    return ((uint32_t)0 | (1 << 16)) | (1 << 21); /* wrong but valid time */
+#endif
+}
diff --git a/lib/chibios/os/various/fatfs_bindings/fatfs_syscall.c b/lib/chibios/os/various/fatfs_bindings/fatfs_syscall.c
new file mode 100644
index 000000000..51bfec127
--- /dev/null
+++ b/lib/chibios/os/various/fatfs_bindings/fatfs_syscall.c
@@ -0,0 +1,84 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+/*------------------------------------------------------------------------*/
+/* Sample code of OS dependent controls for FatFs                         */
+/* (C)ChaN, 2014                                                          */
+/*------------------------------------------------------------------------*/
+
+#include "hal.h"
+#include "ff.h"
+
+#if FF_FS_REENTRANT
+/*------------------------------------------------------------------------*/
+/* Static array of Synchronization Objects                                */
+/*------------------------------------------------------------------------*/
+static semaphore_t ff_sem[FF_VOLUMES];
+
+/*------------------------------------------------------------------------*/
+/* Create a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+int ff_cre_syncobj(BYTE vol, FF_SYNC_t *sobj) {
+
+  *sobj = &ff_sem[vol];
+  chSemObjectInit(*sobj, 1);
+  return TRUE;
+}
+
+/*------------------------------------------------------------------------*/
+/* Delete a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+int ff_del_syncobj(FF_SYNC_t sobj) {
+
+  chSemReset(sobj, 0);
+  return TRUE;
+}
+
+/*------------------------------------------------------------------------*/
+/* Request Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+int ff_req_grant(FF_SYNC_t sobj) {
+
+  msg_t msg = chSemWaitTimeout(sobj, (systime_t)FF_FS_TIMEOUT);
+  return msg == MSG_OK;
+}
+
+/*------------------------------------------------------------------------*/
+/* Release Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+void ff_rel_grant(FF_SYNC_t sobj) {
+
+  chSemSignal(sobj);
+}
+#endif /* FF_FS_REENTRANT */
+
+#if FF_USE_LFN == 3     /* LFN with a working buffer on the heap */
+/*------------------------------------------------------------------------*/
+/* Allocate a memory block                                                */
+/*------------------------------------------------------------------------*/
+void *ff_memalloc(UINT size) {
+
+  return chHeapAlloc(NULL, size);
+}
+
+/*------------------------------------------------------------------------*/
+/* Free a memory block                                                    */
+/*------------------------------------------------------------------------*/
+void ff_memfree(void *mblock) {
+
+  chHeapFree(mblock);
+}
+#endif /* FF_USE_LFN == 3 */
diff --git a/lib/chibios/os/various/fatfs_bindings/readme.txt b/lib/chibios/os/various/fatfs_bindings/readme.txt
new file mode 100644
index 000000000..7f57b8ace
--- /dev/null
+++ b/lib/chibios/os/various/fatfs_bindings/readme.txt
@@ -0,0 +1,12 @@
+This directory contains the ChibiOS/RT "official" bindings with the FatFS
+library by ChaN: http://elm-chan.org
+
+In order to use FatFS within ChibiOS/RT project:
+1. unzip FatFS under ./ext/fatfs  [See Note 2]
+2. include $(CHIBIOS)/os/various/fatfs_bindings/fatfs.mk in your makefile.
+3. Add $(FATFSSRC) to $(CSRC)
+4. Add $(FATFSINC) to $(INCDIR)
+
+Note:
+1. These files modified for use with version 0.13 of fatfs.
+2. In the original distribution, the source directory is called 'source' rather than 'src'
diff --git a/lib/chibios/os/various/lwip_bindings/arch/cc.h b/lib/chibios/os/various/lwip_bindings/arch/cc.h
new file mode 100644
index 000000000..67371e828
--- /dev/null
+++ b/lib/chibios/os/various/lwip_bindings/arch/cc.h
@@ -0,0 +1,89 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+/*
+ * **** This file incorporates work covered by the following copyright and ****
+ * **** permission notice:                                                 ****
+ *
+ * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Adam Dunkels <[email protected]>
+ *
+ */
+
+#ifndef __CC_H__
+#define __CC_H__
+
+#include <hal.h>
+
+/* Use errno provided by system. */
+#define LWIP_ERRNO_INCLUDE <errno.h>
+
+/**
+ * @brief   Use system provided struct timeval by default.
+ */
+#ifndef LWIP_TIMEVAL_PRIVATE
+#define LWIP_TIMEVAL_PRIVATE        0
+#include <sys/time.h>
+#endif
+
+/**
+ * @brief   Use a no-op diagnostic output macro by default.
+ */
+#if !defined(LWIP_PLATFORM_DIAG)
+#define LWIP_PLATFORM_DIAG(x)
+#endif
+
+/**
+ * @brief   Halt the system on lwIP assert failure by default.
+ */
+#if !defined(LWIP_PLATFORM_ASSERT)
+#define LWIP_PLATFORM_ASSERT(x)     osalSysHalt(x)
+#endif
+
+/**
+ * @brief   The NETIF API is required by lwipthread.
+ */
+#ifdef LWIP_NETIF_API
+#undef LWIP_NETIF_API
+#endif
+#define LWIP_NETIF_API              1
+
+#endif /* __CC_H__ */
diff --git a/lib/chibios/os/various/lwip_bindings/arch/perf.h b/lib/chibios/os/various/lwip_bindings/arch/perf.h
new file mode 100644
index 000000000..dc786cade
--- /dev/null
+++ b/lib/chibios/os/various/lwip_bindings/arch/perf.h
@@ -0,0 +1,57 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+/*
+ * **** This file incorporates work covered by the following copyright and ****
+ * **** permission notice:                                                 ****
+ *
+ * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Adam Dunkels <[email protected]>
+ *
+ */
+
+#ifndef __PERF_H__
+#define __PERF_H__
+
+#define PERF_START
+#define PERF_STOP(x)
+
+#endif /* __PERF_H__ */
diff --git a/lib/chibios/os/various/lwip_bindings/arch/sys_arch.c b/lib/chibios/os/various/lwip_bindings/arch/sys_arch.c
new file mode 100644
index 000000000..12e4fba13
--- /dev/null
+++ b/lib/chibios/os/various/lwip_bindings/arch/sys_arch.c
@@ -0,0 +1,239 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+/*
+ * **** This file incorporates work covered by the following copyright and ****
+ * **** permission notice:                                                 ****
+ *
+ * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Adam Dunkels <[email protected]>
+ *
+ */
+
+/*
+ * See http://lwip.wikia.com/wiki/Porting_for_an_OS for instructions.
+ */
+
+#include "hal.h"
+
+#include "lwip/opt.h"
+#include "lwip/mem.h"
+#include "lwip/sys.h"
+#include "lwip/stats.h"
+
+#include "arch/cc.h"
+#include "arch/sys_arch.h"
+
+void sys_init(void) {
+
+}
+
+err_t sys_sem_new(sys_sem_t *sem, u8_t count) {
+
+  *sem = chHeapAlloc(NULL, sizeof(semaphore_t));
+  if (*sem == 0) {
+    SYS_STATS_INC(sem.err);
+    return ERR_MEM;
+  }
+  else {
+    chSemObjectInit(*sem, (cnt_t)count);
+    SYS_STATS_INC_USED(sem);
+    return ERR_OK;
+  }
+}
+
+void sys_sem_free(sys_sem_t *sem) {
+
+  chHeapFree(*sem);
+  *sem = SYS_SEM_NULL;
+  SYS_STATS_DEC(sem.used);
+}
+
+void sys_sem_signal(sys_sem_t *sem) {
+
+  chSemSignal(*sem);
+}
+
+/* CHIBIOS FIX: specific variant of this call to be called from within
+   a lock.*/
+void sys_sem_signal_S(sys_sem_t *sem) {
+
+  chSemSignalI(*sem);
+  chSchRescheduleS();
+}
+
+u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) {
+  systime_t start;
+  sysinterval_t tmo, remaining;
+
+  chSysLock();
+  tmo = timeout > 0 ? TIME_MS2I((time_msecs_t)timeout) : TIME_INFINITE;
+  start = chVTGetSystemTimeX();
+  if (chSemWaitTimeoutS(*sem, tmo) != MSG_OK) {
+    chSysUnlock();
+    return SYS_ARCH_TIMEOUT;
+  }
+  remaining = chTimeDiffX(start, chVTGetSystemTimeX());
+  chSysUnlock();
+  return (u32_t)TIME_I2MS(remaining);
+}
+
+int sys_sem_valid(sys_sem_t *sem) {
+  return *sem != SYS_SEM_NULL;
+}
+
+// typically called within lwIP after freeing a semaphore
+// to make sure the pointer is not left pointing to invalid data
+void sys_sem_set_invalid(sys_sem_t *sem) {
+  *sem = SYS_SEM_NULL;
+}
+
+err_t sys_mbox_new(sys_mbox_t *mbox, int size) {
+
+  *mbox = chHeapAlloc(NULL, sizeof(mailbox_t) + sizeof(msg_t) * size);
+  if (*mbox == 0) {
+    SYS_STATS_INC(mbox.err);
+    return ERR_MEM;
+  }
+  else {
+    chMBObjectInit(*mbox, (void *)(((uint8_t *)*mbox) + sizeof(mailbox_t)), size);
+    SYS_STATS_INC(mbox.used);
+    return ERR_OK;
+  }
+}
+
+void sys_mbox_free(sys_mbox_t *mbox) {
+  cnt_t tmpcnt;
+
+  chSysLock();
+  tmpcnt = chMBGetUsedCountI(*mbox);
+  chSysUnlock();
+
+  if (tmpcnt != 0) {
+    // If there are messages still present in the mailbox when the mailbox
+    // is deallocated, it is an indication of a programming error in lwIP
+    // and the developer should be notified.
+    SYS_STATS_INC(mbox.err);
+    chMBReset(*mbox);
+  }
+  chHeapFree(*mbox);
+  *mbox = SYS_MBOX_NULL;
+  SYS_STATS_DEC(mbox.used);
+}
+
+void sys_mbox_post(sys_mbox_t *mbox, void *msg) {
+
+  chMBPostTimeout(*mbox, (msg_t)msg, TIME_INFINITE);
+}
+
+err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg) {
+
+  if (chMBPostTimeout(*mbox, (msg_t)msg, TIME_IMMEDIATE) == MSG_TIMEOUT) {
+    SYS_STATS_INC(mbox.err);
+    return ERR_MEM;
+  }
+  return ERR_OK;
+}
+
+u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout) {
+  systime_t start;
+  sysinterval_t tmo, remaining;
+
+  chSysLock();
+  tmo = timeout > 0 ? TIME_MS2I((time_msecs_t)timeout) : TIME_INFINITE;
+  start = chVTGetSystemTimeX();
+  if (chMBFetchTimeoutS(*mbox, (msg_t *)msg, tmo) != MSG_OK) {
+    chSysUnlock();
+    return SYS_ARCH_TIMEOUT;
+  }
+  remaining = chTimeDiffX(start, chVTGetSystemTimeX());
+  chSysUnlock();
+  return (u32_t)TIME_I2MS(remaining);
+}
+
+u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg) {
+
+  if (chMBFetchTimeout(*mbox, (msg_t *)msg, TIME_IMMEDIATE) == MSG_TIMEOUT)
+    return SYS_MBOX_EMPTY;
+  return 0;
+}
+
+int sys_mbox_valid(sys_mbox_t *mbox) {
+  return *mbox != SYS_MBOX_NULL;
+}
+
+// typically called within lwIP after freeing an mbox
+// to make sure the pointer is not left pointing to invalid data
+void sys_mbox_set_invalid(sys_mbox_t *mbox) {
+  *mbox = SYS_MBOX_NULL;
+}
+
+sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread,
+                            void *arg, int stacksize, int prio) {
+  thread_t *tp;
+
+  tp = chThdCreateFromHeap(NULL, THD_WORKING_AREA_SIZE(stacksize),
+                           name, prio, (tfunc_t)thread, arg);
+  return (sys_thread_t)tp;
+}
+
+sys_prot_t sys_arch_protect(void) {
+
+  return chSysGetStatusAndLockX();
+}
+
+void sys_arch_unprotect(sys_prot_t pval) {
+
+  chSysRestoreStatusX((syssts_t)pval);
+}
+
+u32_t sys_now(void) {
+
+#if OSAL_ST_FREQUENCY == 1000
+  return (u32_t)chVTGetSystemTimeX();
+#elif (OSAL_ST_FREQUENCY / 1000) >= 1 && (OSAL_ST_FREQUENCY % 1000) == 0
+  return ((u32_t)chVTGetSystemTimeX() - 1) / (OSAL_ST_FREQUENCY / 1000) + 1;
+#elif (1000 / OSAL_ST_FREQUENCY) >= 1 && (1000 % OSAL_ST_FREQUENCY) == 0
+  return ((u32_t)chVTGetSystemTimeX() - 1) * (1000 / OSAL_ST_FREQUENCY) + 1;
+#else
+  return (u32_t)(((u64_t)(chVTGetSystemTimeX() - 1) * 1000) / OSAL_ST_FREQUENCY) + 1;
+#endif
+}
diff --git a/lib/chibios/os/various/lwip_bindings/arch/sys_arch.h b/lib/chibios/os/various/lwip_bindings/arch/sys_arch.h
new file mode 100644
index 000000000..0c5938ce2
--- /dev/null
+++ b/lib/chibios/os/various/lwip_bindings/arch/sys_arch.h
@@ -0,0 +1,68 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+/*
+ * **** This file incorporates work covered by the following copyright and ****
+ * **** permission notice:                                                 ****
+ *
+ * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Adam Dunkels <[email protected]>
+ *
+ */
+
+#include <hal.h>
+
+#ifndef __SYS_ARCH_H__
+#define __SYS_ARCH_H__
+
+typedef semaphore_t *   sys_sem_t;
+typedef mailbox_t *     sys_mbox_t;
+typedef thread_t *      sys_thread_t;
+typedef syssts_t        sys_prot_t;
+
+#define SYS_MBOX_NULL   (mailbox_t *)0
+#define SYS_THREAD_NULL (thread_t *)0
+#define SYS_SEM_NULL    (semaphore_t *)0
+
+/* let sys.h use binary semaphores for mutexes */
+#define LWIP_COMPAT_MUTEX 1
+
+#endif /* __SYS_ARCH_H__ */
diff --git a/lib/chibios/os/various/lwip_bindings/lwip.mk b/lib/chibios/os/various/lwip_bindings/lwip.mk
new file mode 100644
index 000000000..ec1f44cf9
--- /dev/null
+++ b/lib/chibios/os/various/lwip_bindings/lwip.mk
@@ -0,0 +1,23 @@
+# List of the required lwIP files.
+LWIPDIR = $(CHIBIOS)/ext/lwip/src
+
+# The various blocks of files are outlined in Filelists.mk.
+include $(LWIPDIR)/Filelists.mk
+
+LWBINDSRC = \
+        $(CHIBIOS)/os/various/lwip_bindings/lwipthread.c \
+        $(CHIBIOS)/os/various/lwip_bindings/arch/sys_arch.c
+
+
+# Add blocks of files from Filelists.mk as required for enabled options
+LWSRC_REQUIRED = $(COREFILES) $(CORE4FILES) $(APIFILES) $(LWBINDSRC) $(NETIFFILES)
+LWSRC_EXTRAS ?= $(HTTPFILES)
+
+LWINC = \
+        $(CHIBIOS)/os/various/lwip_bindings \
+        $(LWIPDIR)/include
+
+# Shared variables
+ALLCSRC += $(LWSRC_REQUIRED) $(LWSRC_EXTRAS)
+ALLINC  += $(LWINC) \
+           $(CHIBIOS)/os/various
diff --git a/lib/chibios/os/various/lwip_bindings/lwipthread.c b/lib/chibios/os/various/lwip_bindings/lwipthread.c
new file mode 100644
index 000000000..0260ae61b
--- /dev/null
+++ b/lib/chibios/os/various/lwip_bindings/lwipthread.c
@@ -0,0 +1,530 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+/*
+ * **** This file incorporates work covered by the following copyright and ****
+ * **** permission notice:                                                 ****
+ *
+ * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Adam Dunkels <adam@sic