diff options
| author | Clyne Sullivan <clyne@bitgloo.com> | 2021-01-22 21:43:36 -0500 |
|---|---|---|
| committer | Clyne Sullivan <clyne@bitgloo.com> | 2021-01-22 21:43:36 -0500 |
| commit | 48026bb824fd2d9cfb00ecd040db6ef3a416bae9 (patch) | |
| tree | c14713aedfe78ee8b34f2e1252408782e2e2ff5d /ChibiOS_20.3.2/os/various | |
| parent | e080a26651f90c88176140d63a74c93c2f4041a2 (diff) | |
upload initial port
Diffstat (limited to 'ChibiOS_20.3.2/os/various')
31 files changed, 7124 insertions, 0 deletions
diff --git a/ChibiOS_20.3.2/os/various/cpp_wrappers/ch.cpp b/ChibiOS_20.3.2/os/various/cpp_wrappers/ch.cpp new file mode 100644 index 0000000..0f7ae05 --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/cpp_wrappers/ch.hpp b/ChibiOS_20.3.2/os/various/cpp_wrappers/ch.hpp new file mode 100644 index 0000000..49d33a4 --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/cpp_wrappers/chcpp.mk b/ChibiOS_20.3.2/os/various/cpp_wrappers/chcpp.mk new file mode 100644 index 0000000..b1a5466 --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/cpp_wrappers/syscalls_cpp.cpp b/ChibiOS_20.3.2/os/various/cpp_wrappers/syscalls_cpp.cpp new file mode 100644 index 0000000..d7d6d92 --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/cpp_wrappers/syscalls_cpp.hpp b/ChibiOS_20.3.2/os/various/cpp_wrappers/syscalls_cpp.hpp new file mode 100644 index 0000000..681ce2c --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/evtimer.c b/ChibiOS_20.3.2/os/various/evtimer.c new file mode 100644 index 0000000..e9dcb93 --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/evtimer.h b/ChibiOS_20.3.2/os/various/evtimer.h new file mode 100644 index 0000000..f0591a8 --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/fatfs_bindings/fatfs.mk b/ChibiOS_20.3.2/os/various/fatfs_bindings/fatfs.mk new file mode 100644 index 0000000..9da59e0 --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/fatfs_bindings/fatfs_diskio.c b/ChibiOS_20.3.2/os/various/fatfs_bindings/fatfs_diskio.c new file mode 100644 index 0000000..ef04746 --- /dev/null +++ b/ChibiOS_20.3.2/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, ×pec);
+ return rtcConvertDateTimeToFAT(×pec);
+#else
+ return ((uint32_t)0 | (1 << 16)) | (1 << 21); /* wrong but valid time */
+#endif
+}
diff --git a/ChibiOS_20.3.2/os/various/fatfs_bindings/fatfs_syscall.c b/ChibiOS_20.3.2/os/various/fatfs_bindings/fatfs_syscall.c new file mode 100644 index 0000000..dbe569e --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/fatfs_bindings/readme.txt b/ChibiOS_20.3.2/os/various/fatfs_bindings/readme.txt new file mode 100644 index 0000000..b6000ae --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/lwip_bindings/arch/cc.h b/ChibiOS_20.3.2/os/various/lwip_bindings/arch/cc.h new file mode 100644 index 0000000..5258a84 --- /dev/null +++ b/ChibiOS_20.3.2/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 <adam@sics.se>
+ *
+ */
+
+#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/ChibiOS_20.3.2/os/various/lwip_bindings/arch/sys_arch.c b/ChibiOS_20.3.2/os/various/lwip_bindings/arch/sys_arch.c new file mode 100644 index 0000000..7a7d5ea --- /dev/null +++ b/ChibiOS_20.3.2/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 <adam@sics.se>
+ *
+ */
+
+/*
+ * 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/ChibiOS_20.3.2/os/various/lwip_bindings/arch/sys_arch.h b/ChibiOS_20.3.2/os/various/lwip_bindings/arch/sys_arch.h new file mode 100644 index 0000000..bbb3531 --- /dev/null +++ b/ChibiOS_20.3.2/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 <adam@sics.se>
+ *
+ */
+
+#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/ChibiOS_20.3.2/os/various/lwip_bindings/lwip.mk b/ChibiOS_20.3.2/os/various/lwip_bindings/lwip.mk new file mode 100644 index 0000000..961e710 --- /dev/null +++ b/ChibiOS_20.3.2/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/ChibiOS_20.3.2/os/various/lwip_bindings/lwipthread.c b/ChibiOS_20.3.2/os/various/lwip_bindings/lwipthread.c new file mode 100644 index 0000000..ee4303f --- /dev/null +++ b/ChibiOS_20.3.2/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@sics.se>
+ *
+ */
+
+/**
+ * @file lwipthread.c
+ * @brief LWIP wrapper thread code.
+ * @addtogroup LWIP_THREAD
+ * @{
+ */
+
+#include "hal.h"
+#include "evtimer.h"
+
+#include "lwipthread.h"
+
+#include <lwip/opt.h>
+#include <lwip/def.h>
+#include <lwip/mem.h>
+#include <lwip/pbuf.h>
+#include <lwip/sys.h>
+#include <lwip/stats.h>
+#include <lwip/snmp.h>
+#include <lwip/tcpip.h>
+#include <netif/etharp.h>
+#include <lwip/netifapi.h>
+
+#if LWIP_DHCP
+#include <lwip/dhcp.h>
+#endif
+
+#if LWIP_AUTOIP
+#include <lwip/autoip.h>
+#endif
+
+#define PERIODIC_TIMER_ID 1
+#define FRAME_RECEIVED_ID 2
+
+/*
+ * Suspension point for initialization procedure.
+ */
+thread_reference_t lwip_trp = NULL;
+
+/*
+ * Stack area for the LWIP-MAC thread.
+ */
+static THD_WORKING_AREA(wa_lwip_thread, LWIP_THREAD_STACK_SIZE);
+
+/*
+ * Initialization.
+ */
+static void low_level_init(struct netif *netif) {
+ /* set MAC hardware address length */
+ netif->hwaddr_len = ETHARP_HWADDR_LEN;
+
+ /* maximum transfer unit */
+ netif->mtu = LWIP_NETIF_MTU;
+
+ /* device capabilities */
+ /* don't set NETIF_FLAG_ETHARP if this device is not an Ethernet one */
+ netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
+
+ /* Do whatever else is needed to initialize interface. */
+}
+
+/*
+ * This function does the actual transmission of the packet. The packet is
+ * contained in the pbuf that is passed to the function. This pbuf
+ * might be chained.
+ *
+ * @param netif the lwip network interface structure for this ethernetif
+ * @param p the MAC packet to send (e.g. IP packet including MAC addresses and type)
+ * @return ERR_OK if the packet could be sent
+ * an err_t value if the packet couldn't be sent
+ *
+ * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
+ * strange results. You might consider waiting for space in the DMA queue
+ * to become available since the stack doesn't retry to send a packet
+ * dropped because of memory failure (except for the TCP timers).
+ */
+static err_t low_level_output(struct netif *netif, struct pbuf *p) {
+ struct pbuf *q;
+ MACTransmitDescriptor td;
+
+ (void)netif;
+ if (macWaitTransmitDescriptor(ÐD1, &td, TIME_MS2I(LWIP_SEND_TIMEOUT)) != MSG_OK)
+ return ERR_TIMEOUT;
+
+#if ETH_PAD_SIZE
+ pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
+#endif
+
+ /* Iterates through the pbuf chain. */
+ for(q = p; q != NULL; q = q->next)
+ macWriteTransmitDescriptor(&td, (uint8_t *)q->payload, (size_t)q->len);
+ macReleaseTransmitDescriptor(&td);
+
+ MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len);
+ if (((u8_t*)p->payload)[0] & 1) {
+ /* broadcast or multicast packet*/
+ MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts);
+ }
+ else {
+ /* unicast packet */
+ MIB2_STATS_NETIF_INC(netif, ifoutucastpkts);
+ }
+ /* increase ifoutdiscards or ifouterrors on error */
+
+#if ETH_PAD_SIZE
+ pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
+#endif
+
+ LINK_STATS_INC(link.xmit);
+
+ return ERR_OK;
+}
+
+/*
+ * Receives a frame.
+ * Allocates a pbuf and transfers the bytes of the incoming
+ * packet from the interface into the pbuf.
+ *
+ * @param netif the lwip network interface structure for this ethernetif
+ * @return a pbuf filled with the received packet (including MAC header)
+ * NULL on memory error
+ */
+static bool low_level_input(struct netif *netif, struct pbuf **pbuf) {
+ MACReceiveDescriptor rd;
+ struct pbuf *q;
+ u16_t len;
+
+ (void)netif;
+
+ osalDbgAssert(pbuf != NULL, "invalid null pointer");
+
+ if (macWaitReceiveDescriptor(ÐD1, &rd, TIME_IMMEDIATE) != MSG_OK)
+ return false;
+
+ len = (u16_t)rd.size;
+
+#if ETH_PAD_SIZE
+ len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
+#endif
+
+ /* We allocate a pbuf chain of pbufs from the pool. */
+ *pbuf = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
+
+ if (*pbuf != NULL) {
+#if ETH_PAD_SIZE
+ pbuf_header(*pbuf, -ETH_PAD_SIZE); /* drop the padding word */
+#endif
+
+ /* Iterates through the pbuf chain. */
+ for(q = *pbuf; q != NULL; q = q->next)
+ macReadReceiveDescriptor(&rd, (uint8_t *)q->payload, (size_t)q->len);
+ macReleaseReceiveDescriptor(&rd);
+
+ MIB2_STATS_NETIF_ADD(netif, ifinoctets, (*pbuf)->tot_len);
+
+ if (*(uint8_t *)((*pbuf)->payload) & 1) {
+ /* broadcast or multicast packet*/
+ MIB2_STATS_NETIF_INC(netif, ifinnucastpkts);
+ }
+ else {
+ /* unicast packet*/
+ MIB2_STATS_NETIF_INC(netif, ifinucastpkts);
+ }
+
+#if ETH_PAD_SIZE
+ pbuf_header(*pbuf, ETH_PAD_SIZE); /* reclaim the padding word */
+#endif
+
+ LINK_STATS_INC(link.recv);
+ }
+ else {
+ macReleaseReceiveDescriptor(&rd); // Drop packet
+ LINK_STATS_INC(link.memerr);
+ LINK_STATS_INC(link.drop);
+ MIB2_STATS_NETIF_INC(netif, ifindiscards);
+ }
+
+ return true;
+}
+
+/*
+ * Called at the beginning of the program to set up the
+ * network interface. It calls the function low_level_init() to do the
+ * actual setup of the hardware.
+ *
+ * This function should be passed as a parameter to netifapi_netif_add().
+ *
+ * @param netif the lwip network interface structure for this ethernetif
+ * @return ERR_OK if the loopif is initialised
+ * ERR_MEM if private data couldn't be allocated
+ * any other err_t on error
+ */
+static err_t ethernetif_init(struct netif *netif) {
+ osalDbgAssert((netif != NULL), "netif != NULL");
+
+ /*
+ * Initialize the snmp variables and counters inside the struct netif.
+ * The last argument should be replaced with your link speed, in units
+ * of bits per second.
+ */
+ MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, LWIP_LINK_SPEED);
+
+ netif->state = NULL;
+ netif->name[0] = LWIP_IFNAME0;
+ netif->name[1] = LWIP_IFNAME1;
+ /* We directly use etharp_output() here to save a function call.
+ * You can instead declare your own function an call etharp_output()
+ * from it if you have to do some checks before sending (e.g. if link
+ * is available...) */
+ netif->output = etharp_output;
+ netif->linkoutput = low_level_output;
+
+ /* initialize the hardware */
+ low_level_init(netif);
+
+ return ERR_OK;
+}
+
+static net_addr_mode_t addressMode;
+static ip4_addr_t ip, gateway, netmask;
+static struct netif thisif;
+
+void lwipDefaultLinkUpCB(void *p)
+{
+ struct netif *ifc = (struct netif*) p;
+ (void) ifc;
+#if LWIP_AUTOIP
+ if (addressMode == NET_ADDRESS_AUTO)
+ autoip_start(ifc);
+#endif
+#if LWIP_DHCP
+ if (addressMode == NET_ADDRESS_DHCP)
+ dhcp_start(ifc);
+#endif
+}
+
+void lwipDefaultLinkDownCB(void *p)
+{
+ struct netif *ifc = (struct netif*) p;
+ (void) ifc;
+#if LWIP_AUTOIP
+ if (addressMode == NET_ADDRESS_AUTO)
+ autoip_stop(ifc);
+#endif
+#if LWIP_DHCP
+ if (addressMode == NET_ADDRESS_DHCP)
+ dhcp_stop(ifc);
+#endif
+}
+
+/**
+ * @brief LWIP handling thread.
+ *
+ * @param[in] p pointer to a @p lwipthread_opts structure or @p NULL
+ * @return The function does not return.
+ */
+static THD_FUNCTION(lwip_thread, p) {
+ event_timer_t evt;
+ event_listener_t el0, el1;
+ static const MACConfig mac_config = {thisif.hwaddr};
+ err_t result;
+ tcpip_callback_fn link_up_cb = NULL;
+ tcpip_callback_fn link_down_cb = NULL;
+
+ chRegSetThreadName(LWIP_THREAD_NAME);
+
+ /* Initializes the thing.*/
+ tcpip_init(NULL, NULL);
+
+ /* TCP/IP parameters, runtime or compile time.*/
+ if (p) {
+ lwipthread_opts_t *opts = p;
+ unsigned i;
+
+ for (i = 0; i < 6; i++)
+ thisif.hwaddr[i] = opts->macaddress[i];
+ ip.addr = opts->address;
+ gateway.addr = opts->gateway;
+ netmask.addr = opts->netmask;
+ addressMode = opts->addrMode;
+#if LWIP_NETIF_HOSTNAME
+ thisif.hostname = opts->ourHostName;
+#endif
+ link_up_cb = opts->link_up_cb;
+ link_down_cb = opts->link_down_cb;
+ }
+ else {
+ thisif.hwaddr[0] = LWIP_ETHADDR_0;
+ thisif.hwaddr[1] = LWIP_ETHADDR_1;
+ thisif.hwaddr[2] = LWIP_ETHADDR_2;
+ thisif.hwaddr[3] = LWIP_ETHADDR_3;
+ thisif.hwaddr[4] = LWIP_ETHADDR_4;
+ thisif.hwaddr[5] = LWIP_ETHADDR_5;
+ LWIP_IPADDR(&ip);
+ LWIP_GATEWAY(&gateway);
+ LWIP_NETMASK(&netmask);
+#if LWIP_DHCP
+ addressMode = NET_ADDRESS_DHCP;
+#elif LWIP_AUTOIP
+ addressMode = NET_ADDRESS_AUTO;
+#else
+ addressMode = NET_ADDRESS_STATIC;
+#endif
+#if LWIP_NETIF_HOSTNAME
+ thisif.hostname = NULL;
+#endif
+ }
+
+ if (!link_up_cb)
+ link_up_cb = lwipDefaultLinkUpCB;
+ if (!link_down_cb)
+ link_down_cb = lwipDefaultLinkDownCB;
+
+#if LWIP_NETIF_HOSTNAME
+ if (thisif.hostname == NULL)
+ thisif.hostname = LWIP_NETIF_HOSTNAME_STRING;
+#endif
+
+ macStart(ÐD1, &mac_config);
+
+ MIB2_INIT_NETIF(&thisif, snmp_ifType_ethernet_csmacd, 0);
+
+ /* Add interface. */
+ result = netifapi_netif_add(&thisif, &ip, &netmask, &gateway, NULL, ethernetif_init, tcpip_input);
+ if (result != ERR_OK)
+ {
+ chThdSleepMilliseconds(1000); // Give some time to print any other diagnostics.
+ osalSysHalt("netif_add error"); // Not sure what else we can do if an error occurs here.
+ };
+
+ netifapi_netif_set_default(&thisif);
+ netifapi_netif_set_up(&thisif);
+
+ /* Setup event sources.*/
+ evtObjectInit(&evt, LWIP_LINK_POLL_INTERVAL);
+ evtStart(&evt);
+ chEvtRegisterMask(&evt.et_es, &el0, PERIODIC_TIMER_ID);
+ chEvtRegisterMask(macGetReceiveEventSource(ÐD1), &el1, FRAME_RECEIVED_ID);
+ chEvtAddEvents(PERIODIC_TIMER_ID | FRAME_RECEIVED_ID);
+
+ /* Resumes the caller and goes to the final priority.*/
+ chThdResume(&lwip_trp, MSG_OK);
+ chThdSetPriority(LWIP_THREAD_PRIORITY);
+
+ while (true) {
+ eventmask_t mask = chEvtWaitAny(ALL_EVENTS);
+ if (mask & PERIODIC_TIMER_ID) {
+ bool current_link_status = macPollLinkStatus(ÐD1);
+ if (current_link_status != netif_is_link_up(&thisif)) {
+ if (current_link_status) {
+ tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_up,
+ &thisif, 0);
+ tcpip_callback_with_block(link_up_cb, &thisif, 0);
+ }
+ else {
+ tcpip_callback_with_block((tcpip_callback_fn) netif_set_link_down,
+ &thisif, 0);
+ tcpip_callback_with_block(link_down_cb, &thisif, 0);
+ }
+ }
+ }
+
+ if (mask & FRAME_RECEIVED_ID) {
+ struct pbuf *p;
+ while (low_level_input(&thisif, &p)) {
+ if (p != NULL) {
+ struct eth_hdr *ethhdr = p->payload;
+ switch (htons(ethhdr->type)) {
+ /* IP or ARP packet? */
+ case ETHTYPE_IP:
+ case ETHTYPE_ARP:
+ /* full packet send to tcpip_thread to process */
+ if (thisif.input(p, &thisif) == ERR_OK)
+ break;
+ LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
+ /* Falls through */
+ default:
+ pbuf_free(p);
+ }
+ }
+ }
+ }
+ }
+}
+
+/**
+ * @brief Initializes the lwIP subsystem.
+ * @note The function exits after the initialization is finished.
+ *
+ * @param[in] opts pointer to the configuration structure, if @p NULL
+ * then the static configuration is used.
+ */
+void lwipInit(const lwipthread_opts_t *opts) {
+
+ /* Creating the lwIP thread (it changes priority internally).*/
+ chThdCreateStatic(wa_lwip_thread, sizeof (wa_lwip_thread),
+ chThdGetPriorityX() - 1, lwip_thread, (void *)opts);
+
+ /* Waiting for the lwIP thread complete initialization. Note,
+ this thread reaches the thread reference object first because
+ the relative priorities.*/
+ chSysLock();
+ chThdSuspendS(&lwip_trp);
+ chSysUnlock();
+}
+
+typedef struct lwip_reconf_params {
+ const lwipreconf_opts_t *opts;
+ semaphore_t completion;
+} lwip_reconf_params_t;
+
+static void do_reconfigure(void *p)
+{
+ lwip_reconf_params_t *reconf = (lwip_reconf_params_t*) p;
+
+ switch (addressMode) {
+#if LWIP_DHCP
+ case NET_ADDRESS_DHCP: {
+ if (netif_is_up(&thisif))
+ dhcp_stop(&thisif);
+ break;
+ }
+#endif
+ case NET_ADDRESS_STATIC: {
+ ip4_addr_t zero = { 0 };
+ netif_set_ipaddr(&thisif, &zero);
+ netif_set_netmask(&thisif, &zero);
+ netif_set_gw(&thisif, &zero);
+ break;
+ }
+#if LWIP_AUTOIP
+ case NET_ADDRESS_AUTO: {
+ if (netif_is_up(&thisif))
+ autoip_stop(&thisif);
+ break;
+ }
+#endif
+ }
+
+ ip.addr = reconf->opts->address;
+ gateway.addr = reconf->opts->gateway;
+ netmask.addr = reconf->opts->netmask;
+ addressMode = reconf->opts->addrMode;
+
+ switch (addressMode) {
+#if LWIP_DHCP
+ case NET_ADDRESS_DHCP: {
+ if (netif_is_up(&thisif))
+ dhcp_start(&thisif);
+ break;
+ }
+#endif
+ case NET_ADDRESS_STATIC: {
+ netif_set_ipaddr(&thisif, &ip);
+ netif_set_netmask(&thisif, &netmask);
+ netif_set_gw(&thisif, &gateway);
+ break;
+ }
+#if LWIP_AUTOIP
+ case NET_ADDRESS_AUTO: {
+ if (netif_is_up(&thisif))
+ autoip_start(&thisif);
+ break;
+ }
+#endif
+ }
+
+ chSemSignal(&reconf->completion);
+}
+
+void lwipReconfigure(const lwipreconf_opts_t *opts)
+{
+ lwip_reconf_params_t params;
+ params.opts = opts;
+ chSemObjectInit(¶ms.completion, 0);
+ tcpip_callback_with_block(do_reconfigure, ¶ms, 0);
+ chSemWait(¶ms.completion);
+}
+
+/** @} */
diff --git a/ChibiOS_20.3.2/os/various/lwip_bindings/lwipthread.h b/ChibiOS_20.3.2/os/various/lwip_bindings/lwipthread.h new file mode 100644 index 0000000..b40d05f --- /dev/null +++ b/ChibiOS_20.3.2/os/various/lwip_bindings/lwipthread.h @@ -0,0 +1,275 @@ +/*
+ 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 lwipthread.h
+ * @brief LWIP wrapper thread macros and structures.
+ * @addtogroup LWIP_THREAD
+ * @{
+ */
+
+#ifndef LWIPTHREAD_H
+#define LWIPTHREAD_H
+
+#include <lwip/opt.h>
+
+/**
+ * @brief lwIP default network interface maximum transmission unit (MTU).
+ */
+#if !defined(LWIP_NETIF_MTU) || defined(__DOXYGEN__)
+#define LWIP_NETIF_MTU 1500
+#endif
+
+/**
+ * @brief Default network interface hostname.
+ */
+#if !defined(LWIP_NETIF_HOSTNAME_STRING) || defined(__DOXYGEN__)
+#define LWIP_NETIF_HOSTNAME_STRING "lwip"
+#endif
+
+/**
+ * @brief Default network interface hostname.
+ */
+#if !defined(LWIP_THREAD_NAME) || defined(__DOXYGEN__)
+#define LWIP_THREAD_NAME "lwipthread"
+#endif
+
+/**
+ * @brief lwIP thread priority.
+ */
+#ifndef LWIP_THREAD_PRIORITY
+#define LWIP_THREAD_PRIORITY LOWPRIO
+#endif
+
+/**
+ * @brief lwIP thread stack size.
+ */
+#if !defined(LWIP_THREAD_STACK_SIZE) || defined(__DOXYGEN__)
+#define LWIP_THREAD_STACK_SIZE 672
+#endif
+
+/**
+ * @brief Link poll interval.
+ */
+#if !defined(LWIP_LINK_POLL_INTERVAL) || defined(__DOXYGEN__)
+#define LWIP_LINK_POLL_INTERVAL TIME_S2I(5)
+#endif
+
+/**
+ * @brief IP Address.
+ */
+#if !defined(LWIP_IPADDR) || defined(__DOXYGEN__)
+#define LWIP_IPADDR(p) IP4_ADDR(p, 192, 168, 1, 10)
+#endif
+
+/**
+ * @brief IP Gateway.
+ */
+#if !defined(LWIP_GATEWAY) || defined(__DOXYGEN__)
+#define LWIP_GATEWAY(p) IP4_ADDR(p, 192, 168, 1, 1)
+#endif
+
+/**
+ * @brief IP netmask.
+ */
+#if !defined(LWIP_NETMASK) || defined(__DOXYGEN__)
+#define LWIP_NETMASK(p) IP4_ADDR(p, 255, 255, 255, 0)
+#endif
+
+/**
+ * @brief Transmission timeout.
+ */
+#if !defined(LWIP_SEND_TIMEOUT) || defined(__DOXYGEN__)
+#define LWIP_SEND_TIMEOUT 50
+#endif
+
+/**
+ * @brief Link speed.
+ */
+#if !defined(LWIP_LINK_SPEED) || defined(__DOXYGEN__)
+#define LWIP_LINK_SPEED 100000000
+#endif
+
+/**
+ * @brief MAC Address byte 0.
+ */
+#if !defined(LWIP_ETHADDR_0) || defined(__DOXYGEN__)
+#define LWIP_ETHADDR_0 0xC2
+#endif
+
+/**
+ * @brief MAC Address byte 1.
+ */
+#if !defined(LWIP_ETHADDR_1) || defined(__DOXYGEN__)
+#define LWIP_ETHADDR_1 0xAF
+#endif
+
+/**
+ * @brief MAC Address byte 2.
+ */
+#if !defined(LWIP_ETHADDR_2) || defined(__DOXYGEN__)
+#define LWIP_ETHADDR_2 0x51
+#endif
+
+/**
+ * @brief MAC Address byte 3.
+ */
+#if !defined(LWIP_ETHADDR_3) || defined(__DOXYGEN__)
+#define LWIP_ETHADDR_3 0x03
+#endif
+
+/**
+ * @brief MAC Address byte 4.
+ */
+#if !defined(LWIP_ETHADDR_4) || defined(__DOXYGEN__)
+#define LWIP_ETHADDR_4 0xCF
+#endif
+
+/**
+ * @brief MAC Address byte 5.
+ */
+#if !defined(LWIP_ETHADDR_5) || defined(__DOXYGEN__)
+#define LWIP_ETHADDR_5 0x46
+#endif
+
+/**
+ * @brief Interface name byte 0.
+ */
+#if !defined(LWIP_IFNAME0) || defined(__DOXYGEN__)
+#define LWIP_IFNAME0 'm'
+#endif
+
+/**
+ * @brief Interface name byte 1.
+ */
+#if !defined(LWIP_IFNAME1) || defined(__DOXYGEN__)
+#define LWIP_IFNAME1 's'
+#endif
+
+/**
+ * @brief Utility macro to define an IPv4 address.
+ *
+ * @note Within the networking subsystem, IPv4 network addresses are
+ * stored with LS byte of network address in MS byte of unsigned int.
+ */
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define IP4_ADDR_VALUE(a,b,c,d) \
+ (((u32_t)((d) & 0xff) << 24) | \
+ ((u32_t)((c) & 0xff) << 16) | \
+ ((u32_t)((b) & 0xff) << 8) | \
+ (u32_t)((a) & 0xff))
+#else
+#define IP4_ADDR_VALUE(a,b,c,d) \
+ (((u32_t)((a) & 0xff) << 24) | \
+ ((u32_t)((b) & 0xff) << 16) | \
+ ((u32_t)((c) & 0xff) << 8) | \
+ (u32_t)((d) & 0xff))
+#endif
+
+/**
+ * @brief Startup network assigning modes.
+ */
+typedef enum {
+#if LWIP_DHCP || defined(__DOXYGEN__)
+ /**
+ * @brief Assign a DHCP given address.
+ */
+ NET_ADDRESS_DHCP = 1,
+#endif
+ /**
+ * @brief Assign a statically IPv4 address.
+ */
+ NET_ADDRESS_STATIC = 2,
+#if LWIP_AUTOIP || defined(__DOXYGEN__)
+ /**
+ * @brief Assign an IPv4 link-Local address.
+ */
+ NET_ADDRESS_AUTO = 3
+#endif
+} net_addr_mode_t;
+
+/**
+ * @brief Runtime TCP/IP settings.
+ */
+typedef struct lwipthread_opts {
+ /**
+ * @brief Pointer to MAC address as an array of 6 unsigned bytes.
+ */
+ uint8_t *macaddress;
+ /**
+ * @brief Network address as 32-bit unsigned integer.
+ */
+ uint32_t address;
+ /**
+ * @brief Network subnet mask as 32-bit unsigned integer.
+ */
+ uint32_t netmask;
+ /**
+ * @brief Network gateway as 32-bit unsigned integer.
+ */
+ uint32_t gateway;
+ /**
+ * @brief Startup network addressing mode - static, DHCP, auto.
+ */
+ net_addr_mode_t addrMode;
+ /**
+ * @brief Host name. If NULL, a default string is used.
+ * @note Not checked for validity. In particular, spaces not allowed.
+ */
+#if LWIP_NETIF_HOSTNAME || defined(__DOXYGEN__)
+ const char *ourHostName;
+#endif
+ /**
+ * @brief Link up callback.
+ *
+ * @note Called from the tcpip thread when the link goes up.
+ * Can be NULL to default to lwipDefaultLinkUpCB.
+ */
+ void (*link_up_cb)(void*);
+ /**
+ * @brief Link down callback.
+ *
+ * @note Called from the tcpip thread when the link goes down.
+ * Can be NULL to default to lwipDefaultLinkDownCB.
+ */
+ void (*link_down_cb)(void*);
+} lwipthread_opts_t;
+
+/**
+ * @brief Parameters for lwipReconfigure.
+ * @note Same meaning as in lwipthread_opts_t.
+ */
+typedef struct lwipreconf_opts {
+ uint32_t address;
+ uint32_t netmask;
+ uint32_t gateway;
+ net_addr_mode_t addrMode;
+} lwipreconf_opts_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+ void lwipDefaultLinkUpCB(void *p);
+ void lwipDefaultLinkDownCB(void *p);
+ void lwipInit(const lwipthread_opts_t *opts);
+ void lwipReconfigure(const lwipreconf_opts_t *opts);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LWIPTHREAD_H */
+
+/** @} */
diff --git a/ChibiOS_20.3.2/os/various/lwip_bindings/readme.txt b/ChibiOS_20.3.2/os/various/lwip_bindings/readme.txt new file mode 100644 index 0000000..07544e2 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/lwip_bindings/readme.txt @@ -0,0 +1,6 @@ +This directory contains the ChibiOS "official" bindings with the lwIP
+TCP/IP stack: http://savannah.nongnu.org/projects/lwip
+
+In order to use lwIP within ChibiOS/RT project, unzip lwIP under
+./ext/lwip then include $(CHIBIOS)/os/various/lwip_bindings/lwip.mk
+in your makefile.
diff --git a/ChibiOS_20.3.2/os/various/lwip_bindings/static_lwipopts.h b/ChibiOS_20.3.2/os/various/lwip_bindings/static_lwipopts.h new file mode 100644 index 0000000..7baa387 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/lwip_bindings/static_lwipopts.h @@ -0,0 +1,42 @@ +/*
+ 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 static_lwipopts.h
+ *
+ * @addtogroup static_lwipopts
+ * @{
+ */
+
+#ifndef STATIC_LWIPOPTS_H
+#define STATIC_LWIPOPTS_H
+
+#define NO_SYS 0
+
+#define LWIP_TIMERS 1
+#define LWIP_TIMERS_CUSTOM 0
+
+#define LWIP_TCPIP_CORE_LOCKING 1
+#define LWIP_TCPIP_CORE_LOCKING_INPUT 0
+#define LWIP_COMPAT_MUTEX_ALLOWED
+
+#define SYS_LIGHTWEIGHT_PROT 1
+
+#define MEM_ALIGNMENT 4
+
+#endif /* STATIC_LWIPOPTS_H */
+
+/** @} */
diff --git a/ChibiOS_20.3.2/os/various/shell/shell.c b/ChibiOS_20.3.2/os/various/shell/shell.c new file mode 100644 index 0000000..19db9aa --- /dev/null +++ b/ChibiOS_20.3.2/os/various/shell/shell.c @@ -0,0 +1,604 @@ +/*
+ 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 shell.c
+ * @brief Simple CLI shell code.
+ *
+ * @addtogroup SHELL
+ * @{
+ */
+
+#include <string.h>
+
+#include "ch.h"
+#include "hal.h"
+#include "shell.h"
+#include "shell_cmd.h"
+#include "chprintf.h"
+
+/*===========================================================================*/
+/* Module local definitions. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module exported variables. */
+/*===========================================================================*/
+
+#if !defined(_CHIBIOS_NIL_) || defined(__DOXYGEN__)
+/**
+ * @brief Shell termination event source.
+ */
+event_source_t shell_terminated;
+#endif
+
+/*===========================================================================*/
+/* Module local types. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local variables. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local functions. */
+/*===========================================================================*/
+
+static char *parse_arguments(char *str, char **saveptr) {
+ char *p;
+
+ if (str != NULL)
+ *saveptr = str;
+
+ p = *saveptr;
+ if (!p) {
+ return NULL;
+ }
+
+ /* Skipping white space.*/
+ p += strspn(p, " \t");
+
+ if (*p == '"') {
+ /* If an argument starts with a double quote then its delimiter is another
+ quote.*/
+ p++;
+ *saveptr = strpbrk(p, "\"");
+ }
+ else {
+ /* The delimiter is white space.*/
+ *saveptr = strpbrk(p, " \t");
+ }
+
+ /* Replacing the delimiter with a zero.*/
+ if (*saveptr != NULL) {
+ *(*saveptr)++ = '\0';
+ }
+
+ return *p != '\0' ? p : NULL;
+}
+
+static void list_commands(BaseSequentialStream *chp, const ShellCommand *scp) {
+
+ while (scp->sc_name != NULL) {
+ chprintf(chp, "%s ", scp->sc_name);
+ scp++;
+ }
+}
+
+static bool cmdexec(const ShellCommand *scp, BaseSequentialStream *chp,
+ char *name, int argc, char *argv[]) {
+
+ while (scp->sc_name != NULL) {
+ if (strcmp(scp->sc_name, name) == 0) {
+ scp->sc_function(chp, argc, argv);
+ return false;
+ }
+ scp++;
+ }
+ return true;
+}
+
+#if (SHELL_USE_HISTORY == TRUE) || defined(__DOXYGEN__)
+static void del_histbuff_entry(ShellHistory *shp) {
+ int pos = shp->sh_beg + *(shp->sh_buffer + shp->sh_beg) + 1;
+
+ if (pos >= shp->sh_size)
+ pos -= shp->sh_size;
+
+ shp->sh_beg = pos;
+}
+
+static bool is_histbuff_space(ShellHistory *shp, int length) {
+
+ if (shp->sh_end >= shp->sh_beg) {
+ if (length < (shp->sh_size - (shp->sh_end - shp->sh_beg + 1)))
+ return true;
+ }
+ else {
+ if (length < (shp->sh_beg - shp->sh_end - 1))
+ return true;
+ }
+
+ return false;
+}
+
+static void save_history(ShellHistory *shp, char *line, int length) {
+
+ if (shp == NULL)
+ return;
+
+ if (length > shp->sh_size - 2)
+ return;
+
+ while ((*(line + length -1) == ' ') && (length > 0))
+ length--;
+
+ if (length <= 0)
+ return;
+
+ while (!is_histbuff_space(shp, length))
+ del_histbuff_entry(shp);
+
+ if (length < shp->sh_size - shp->sh_end - 1)
+ memcpy(shp->sh_buffer + shp->sh_end + 1, line, length);
+ else {
+ /*
+ * Since there isn't enough room left at the end of the buffer,
+ * split the line to save up to the end of the buffer and then
+ * wrap back to the beginning of the buffer.
+ */
+ int part_len = shp->sh_size - shp->sh_end - 1;
+ memcpy(shp->sh_buffer + shp->sh_end + 1, line, part_len);
+ memcpy(shp->sh_buffer, line + part_len, length - part_len);
+ }
+
+ /* Save the length of the current line and move the buffer end pointer */
+ *(shp->sh_buffer + shp->sh_end) = (char)length;
+ shp->sh_end += length + 1;
+ if (shp->sh_end >= shp->sh_size)
+ shp->sh_end -= shp->sh_size;
+ *(shp->sh_buffer + shp->sh_end) = 0;
+ shp->sh_cur = 0;
+}
+
+static int get_history(ShellHistory *shp, char *line, int dir) {
+ int count=0;
+
+ if (shp == NULL)
+ return -1;
+
+ /* Count the number of lines saved in the buffer */
+ int idx = shp->sh_beg;
+ while (idx != shp->sh_end) {
+ idx += *(shp->sh_buffer + idx) + 1;
+ if (idx >= shp->sh_size)
+ idx -= shp->sh_size;
+ count++;
+ }
+
+ if (dir == SHELL_HIST_DIR_FW) {
+ if (shp->sh_cur > 0)
+ shp->sh_cur -= 2;
+ else
+ return 0;
+ }
+
+ if (count >= shp->sh_cur) {
+ idx = shp->sh_beg;
+ int i = 0;
+ while (idx != shp->sh_end && shp->sh_cur != (count - i - 1)) {
+ idx += *(shp->sh_buffer + idx) + 1;
+ if (idx >= shp->sh_size)
+ idx -= shp->sh_size;
+ i++;
+ }
+
+ int length = *(shp->sh_buffer + idx);
+
+ if (length > 0) {
+ shp->sh_cur++;
+
+ memset(line, 0, SHELL_MAX_LINE_LENGTH);
+ if ((idx + length) < shp->sh_size) {
+ memcpy(line, (shp->sh_buffer + idx + 1), length);
+ }
+ else {
+ /*
+ * Since the saved line was split at the end of the buffer,
+ * get the line in two parts.
+ */
+ int part_len = shp->sh_size - idx - 1;
+ memcpy(line, shp->sh_buffer + idx + 1, part_len);
+ memcpy(line + part_len, shp->sh_buffer, length - part_len);
+ }
+ return length;
+ }
+ else if (dir == SHELL_HIST_DIR_FW) {
+ shp->sh_cur++;
+ return 0;
+ }
+ }
+ return -1;
+}
+#endif
+
+#if (SHELL_USE_COMPLETION == TRUE) || defined(__DOXYGEN__)
+static void get_completions(ShellConfig *scfg, char *line) {
+ const ShellCommand *lcp = shell_local_commands;
+ const ShellCommand *scp = scfg->sc_commands;
+ char **scmp = scfg->sc_completion;
+ char help_cmp[] = "help";
+
+ if (strstr(help_cmp, line) == help_cmp) {
+ *scmp++ = help_cmp;
+ }
+ while (lcp->sc_name != NULL) {
+ if (strstr(lcp->sc_name, line) == lcp->sc_name) {
+ *scmp++ = (char *)lcp->sc_name;
+ }
+ lcp++;
+ }
+ if (scp != NULL) {
+ while (scp->sc_name != NULL) {
+ if (strstr(scp->sc_name, line) == scp->sc_name) {
+ *scmp++ = (char *)scp->sc_name;
+ }
+ scp++;
+ }
+ }
+
+ *scmp = NULL;
+}
+
+static int process_completions(ShellConfig *scfg, char *line, int length, unsigned size) {
+ char **scmp = scfg->sc_completion;
+ char **cmp = scmp + 1;
+ char *c = line + length;
+ int clen = 0;
+
+ if (*scmp != NULL) {
+ if (*cmp == NULL) {
+ clen = strlen(*scmp);
+ int i = length;
+ while ((c < line + clen) && (c < line + size - 1))
+ *c++ = *(*scmp + i++);
+ if (c < line + size -1) {
+ *c = ' ';
+ clen++;
+ }
+ }
+ else {
+ while (*(*scmp + clen) != 0) {
+ while ((*(*scmp + clen) == *(*cmp + clen)) &&
+ (*(*cmp + clen) != 0) && (*cmp != NULL)) {
+ cmp++;
+ }
+ if (*cmp == NULL) {
+ if ((c < line + size - 1) && (clen >= length))
+ *c++ = *(*scmp + clen);
+ cmp = scmp + 1;
+ clen++;
+ }
+ else {
+ break;
+ }
+ }
+ }
+
+ *(line + clen) = 0;
+ }
+
+ return clen;
+}
+
+static void write_completions(ShellConfig *scfg, char *line, int pos) {
+ BaseSequentialStream *chp = scfg->sc_channel;
+ char **scmp = scfg->sc_completion;
+
+ if (*(scmp + 1) != NULL) {
+ chprintf(chp, SHELL_NEWLINE_STR);
+ while (*scmp != NULL)
+ chprintf(chp, " %s", *scmp++);
+ chprintf(chp, SHELL_NEWLINE_STR);
+
+ chprintf(chp, SHELL_PROMPT_STR);
+ chprintf(chp, "%s", line);
+ }
+ else {
+ chprintf(chp, "%s", line + pos);
+ }
+}
+#endif
+
+/*===========================================================================*/
+/* Module exported functions. */
+/*===========================================================================*/
+
+/**
+ * @brief Shell thread function.
+ *
+ * @param[in] p pointer to a @p BaseSequentialStream object
+ */
+THD_FUNCTION(shellThread, p) {
+ int n;
+ ShellConfig *scfg = p;
+ BaseSequentialStream *chp = scfg->sc_channel;
+ const ShellCommand *scp = scfg->sc_commands;
+ char *lp, *cmd, *tokp, line[SHELL_MAX_LINE_LENGTH];
+ char *args[SHELL_MAX_ARGUMENTS + 1];
+
+#if !defined(_CHIBIOS_NIL_)
+ chRegSetThreadName(SHELL_THREAD_NAME);
+#endif
+
+#if SHELL_USE_HISTORY == TRUE
+ *(scfg->sc_histbuf) = 0;
+ ShellHistory hist = {
+ scfg->sc_histbuf,
+ scfg->sc_histsize,
+ 0,
+ 0,
+ 0
+ };
+ ShellHistory *shp = &hist;
+#else
+ ShellHistory *shp = NULL;
+#endif
+
+ chprintf(chp, SHELL_NEWLINE_STR);
+ chprintf(chp, "ChibiOS/RT Shell" SHELL_NEWLINE_STR);
+#if !defined(_CHIBIOS_NIL_)
+ while (!chThdShouldTerminateX()) {
+#else
+ while (true) {
+#endif
+ chprintf(chp, SHELL_PROMPT_STR);
+ if (shellGetLine(scfg, line, sizeof(line), shp)) {
+#if (SHELL_CMD_EXIT_ENABLED == TRUE) && !defined(_CHIBIOS_NIL_)
+ chprintf(chp, SHELL_NEWLINE_STR);
+ chprintf(chp, "logout");
+ break;
+#else
+ /* Putting a delay in order to avoid an endless loop trying to read
+ an unavailable stream.*/
+ osalThreadSleepMilliseconds(100);
+#endif
+ }
+ lp = parse_arguments(line, &tokp);
+ cmd = lp;
+ n = 0;
+ while ((lp = parse_arguments(NULL, &tokp)) != NULL) {
+ if (n >= SHELL_MAX_ARGUMENTS) {
+ chprintf(chp, "too many arguments" SHELL_NEWLINE_STR);
+ cmd = NULL;
+ break;
+ }
+ args[n++] = lp;
+ }
+ args[n] = NULL;
+ if (cmd != NULL) {
+ if (strcmp(cmd, "help") == 0) {
+ if (n > 0) {
+ shellUsage(chp, "help");
+ continue;
+ }
+ chprintf(chp, "Commands: help ");
+ list_commands(chp, shell_local_commands);
+ if (scp != NULL)
+ list_commands(chp, scp);
+ chprintf(chp, SHELL_NEWLINE_STR);
+ }
+ else if (cmdexec(shell_local_commands, chp, cmd, n, args) &&
+ ((scp == NULL) || cmdexec(scp, chp, cmd, n, args))) {
+ chprintf(chp, "%s", cmd);
+ chprintf(chp, " ?" SHELL_NEWLINE_STR);
+ }
+ }
+ }
+#if !defined(_CHIBIOS_NIL_)
+ shellExit(MSG_OK);
+#endif
+}
+
+/**
+ * @brief Shell manager initialization.
+ *
+ * @api
+ */
+void shellInit(void) {
+
+#if !defined(_CHIBIOS_NIL_)
+ chEvtObjectInit(&shell_terminated);
+#endif
+}
+
+#if !defined(_CHIBIOS_NIL_) || defined(__DOXYGEN__)
+/**
+ * @brief Terminates the shell.
+ * @note Must be invoked from the command handlers.
+ * @note Does not return.
+ *
+ * @param[in] msg shell exit code
+ *
+ * @api
+ */
+void shellExit(msg_t msg) {
+
+ /* Atomically broadcasting the event source and terminating the thread,
+ there is not a chSysUnlock() because the thread terminates upon return.*/
+ chSysLock();
+ chEvtBroadcastI(&shell_terminated);
+ chThdExitS(msg);
+}
+#endif
+
+/**
+ * @brief Reads a whole line from the input channel.
+ * @note Input chars are echoed on the same stream object with the
+ * following exceptions:
+ * - DEL and BS are echoed as BS-SPACE-BS.
+ * - CR is echoed as CR-LF.
+ * - 0x4 is echoed as "^D".
+ * - Other values below 0x20 are not echoed.
+ * .
+ *
+ * @param[in] scfg pointer to a @p ShellConfig object
+ * @param[in] line pointer to the line buffer
+ * @param[in] size buffer maximum length
+ * @param[in] shp pointer to a @p ShellHistory object or NULL
+ * @return The operation status.
+ * @retval true the channel was reset or CTRL-D pressed.
+ * @retval false operation successful.
+ *
+ * @api
+ */
+bool shellGetLine(ShellConfig *scfg, char *line, unsigned size, ShellHistory *shp) {
+ char *p = line;
+ BaseSequentialStream *chp = scfg->sc_channel;
+#if SHELL_USE_ESC_SEQ == TRUE
+ bool escape = false;
+ bool bracket = false;
+#endif
+
+#if SHELL_USE_HISTORY != TRUE
+ (void) shp;
+#endif
+
+ while (true) {
+ char c;
+
+ if (streamRead(chp, (uint8_t *)&c, 1) == 0)
+ return true;
+#if SHELL_USE_ESC_SEQ == TRUE
+ if (c == 27) {
+ escape = true;
+ continue;
+ }
+ if (escape) {
+ escape = false;
+ if (c == '[') {
+ escape = true;
+ bracket = true;
+ continue;
+ }
+ if (bracket) {
+ bracket = false;
+#if SHELL_USE_HISTORY == TRUE
+ if (c == 'A') {
+ int len = get_history(shp, line, SHELL_HIST_DIR_BK);
+
+ if (len > 0) {
+ _shell_reset_cur(chp);
+ _shell_clr_line(chp);
+ chprintf(chp, "%s", line);
+ p = line + len;
+ }
+ continue;
+ }
+ if (c == 'B') {
+ int len = get_history(shp, line, SHELL_HIST_DIR_FW);
+
+ if (len == 0)
+ *line = 0;
+
+ if (len >= 0) {
+ _shell_reset_cur(chp);
+ _shell_clr_line(chp);
+ chprintf(chp, "%s", line);
+ p = line + len;
+ }
+ continue;
+ }
+#endif
+ }
+ continue;
+ }
+#endif
+#if (SHELL_CMD_EXIT_ENABLED == TRUE) && !defined(_CHIBIOS_NIL_)
+ if (c == 4) {
+ chprintf(chp, "^D");
+ return true;
+ }
+#endif
+ if ((c == 8) || (c == 127)) {
+ if (p != line) {
+ streamPut(chp, 0x08);
+ streamPut(chp, 0x20);
+ streamPut(chp, 0x08);
+ p--;
+ }
+ continue;
+ }
+ if (c == '\r') {
+ chprintf(chp, SHELL_NEWLINE_STR);
+#if SHELL_USE_HISTORY == TRUE
+ save_history(shp, line, p - line);
+#endif
+ *p = 0;
+ return false;
+ }
+#if SHELL_USE_COMPLETION == TRUE
+ if (c == '\t') {
+ if (p < line + size - 1) {
+ *p = 0;
+
+ get_completions(scfg, line);
+ int len = process_completions(scfg, line, p - line, size);
+ if (len > 0) {
+ write_completions(scfg, line, p - line);
+ p = line + len;
+ }
+ }
+ continue;
+ }
+#endif
+#if SHELL_USE_HISTORY == TRUE
+ if (c == 14) {
+ int len = get_history(shp, line, SHELL_HIST_DIR_FW);
+
+ if (len == 0)
+ *line = 0;
+
+ if (len >= 0) {
+ _shell_reset_cur(chp);
+ _shell_clr_line(chp);
+ chprintf(chp, "%s", line);
+ p = line + len;
+ }
+ continue;
+ }
+ if (c == 16) {
+ int len = get_history(shp, line, SHELL_HIST_DIR_BK);
+
+ if (len > 0) {
+ _shell_reset_cur(chp);
+ _shell_clr_line(chp);
+ chprintf(chp, "%s", line);
+ p = line + len;
+ }
+ continue;
+ }
+#endif
+ if (c < 0x20)
+ continue;
+ if (p < line + size - 1) {
+ streamPut(chp, c);
+ *p++ = (char)c;
+ }
+ }
+}
+
+/** @} */
diff --git a/ChibiOS_20.3.2/os/various/shell/shell.h b/ChibiOS_20.3.2/os/various/shell/shell.h new file mode 100644 index 0000000..d11adc0 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/shell/shell.h @@ -0,0 +1,235 @@ +/*
+ 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 shell.h
+ * @brief Simple CLI shell header.
+ *
+ * @addtogroup SHELL
+ * @{
+ */
+
+#ifndef SHELL_H
+#define SHELL_H
+
+#if defined(SHELL_CONFIG_FILE)
+#include "shellconf.h"
+#endif
+
+/*===========================================================================*/
+/* Module constants. */
+/*===========================================================================*/
+
+/**
+ * @brief Shell History Constants
+ */
+#define SHELL_HIST_DIR_BK 0
+#define SHELL_HIST_DIR_FW 1
+
+/*===========================================================================*/
+/* Module pre-compile time settings. */
+/*===========================================================================*/
+
+/**
+ * @brief Shell maximum input line length.
+ */
+#if !defined(SHELL_MAX_LINE_LENGTH) || defined(__DOXYGEN__)
+#define SHELL_MAX_LINE_LENGTH 64
+#endif
+
+/**
+ * @brief Shell maximum arguments per command.
+ */
+#if !defined(SHELL_MAX_ARGUMENTS) || defined(__DOXYGEN__)
+#define SHELL_MAX_ARGUMENTS 4
+#endif
+
+/**
+ * @brief Shell maximum command history.
+ */
+#if !defined(SHELL_MAX_HIST_BUFF) || defined(__DOXYGEN__)
+#define SHELL_MAX_HIST_BUFF 8 * SHELL_MAX_LINE_LENGTH
+#endif
+
+/**
+ * @brief Enable shell command history
+ */
+#if !defined(SHELL_USE_HISTORY) || defined(__DOXYGEN__)
+#define SHELL_USE_HISTORY FALSE
+#endif
+
+/**
+ * @brief Enable shell command completion
+ */
+#if !defined(SHELL_USE_COMPLETION) || defined(__DOXYGEN__)
+#define SHELL_USE_COMPLETION FALSE
+#endif
+
+/**
+ * @brief Shell Maximum Completions (Set to max commands with common prefix)
+ */
+#if !defined(SHELL_MAX_COMPLETIONS) || defined(__DOXYGEN__)
+#define SHELL_MAX_COMPLETIONS 8
+#endif
+
+/**
+ * @brief Enable shell escape sequence processing
+ */
+#if !defined(SHELL_USE_ESC_SEQ) || defined(__DOXYGEN__)
+#define SHELL_USE_ESC_SEQ FALSE
+#endif
+
+/**
+ * @brief Prompt string
+ */
+#if !defined(SHELL_PROMPT_STR) || defined(__DOXYGEN__)
+#define SHELL_PROMPT_STR "ch> "
+#endif
+
+/**
+ * @brief Newline string
+ */
+#if !defined(SHELL_NEWLINE_STR) || defined(__DOXYGEN__)
+#define SHELL_NEWLINE_STR "\r\n"
+#endif
+
+/**
+ * @brief Default shell thread name.
+ */
+#if !defined(SHELL_THREAD_NAME) || defined(__DOXYGEN__)
+#define SHELL_THREAD_NAME "shell"
+#endif
+
+/*===========================================================================*/
+/* Derived constants and error checks. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module data structures and types. */
+/*===========================================================================*/
+
+/**
+ * @brief Command handler function type.
+ */
+typedef void (*shellcmd_t)(BaseSequentialStream *chp, int argc, char *argv[]);
+
+/**
+ * @brief Custom command entry type.
+ */
+typedef struct {
+ const char *sc_name; /**< @brief Command name. */
+ shellcmd_t sc_function; /**< @brief Command function. */
+} ShellCommand;
+
+/**
+ * @brief Shell history type.
+ */
+typedef struct {
+ char *sh_buffer; /**< @brief Buffer to store command
+ history. */
+ const int sh_size; /**< @brief Shell history buffer
+ size. */
+ int sh_beg; /**< @brief Beginning command index
+ in buffer. */
+ int sh_end; /**< @brief Ending command index
+ in buffer. */
+ int sh_cur; /**< @brief Currently selected
+ command in buffer. */
+} ShellHistory;
+
+/**
+ * @brief Shell descriptor type.
+ */
+typedef struct {
+ BaseSequentialStream *sc_channel; /**< @brief I/O channel associated
+ to the shell. */
+ const ShellCommand *sc_commands; /**< @brief Shell extra commands
+ table. */
+#if (SHELL_USE_HISTORY == TRUE) || defined(__DOXYGEN__)
+ char *sc_histbuf; /**< @brief Shell command history
+ buffer. */
+ const int sc_histsize; /**< @brief Shell history buffer
+ size. */
+#endif
+#if (SHELL_USE_COMPLETION == TRUE) || defined(__DOXYGEN__)
+ char **sc_completion; /**< @brief Shell command completion
+ buffer. */
+#endif
+} ShellConfig;
+
+/*===========================================================================*/
+/* Module macros. */
+/*===========================================================================*/
+
+/**
+ * @brief Send escape codes to move cursor to the beginning of the line
+ *
+ * @param[in] stream pointer to a @p BaseSequentialStream object
+ *
+ * @notapi
+ */
+#define _shell_reset_cur(stream) chprintf(stream, "\033[%dD\033[%dC", \
+ SHELL_MAX_LINE_LENGTH + \
+ strlen(SHELL_PROMPT_STR) + 2, \
+ strlen(SHELL_PROMPT_STR))
+
+/**
+ * @brief Send escape codes to clear the rest of the line
+ *
+ * @param[in] stream pointer to a @p BaseSequentialStream object
+ *
+ * @notapi
+ */
+#define _shell_clr_line(stream) chprintf(stream, "\033[K")
+
+/**
+ * @brief Prints out usage message
+ *
+ * @param[in] stream pointer to a @p BaseSequentialStream object
+ * @param[in] message pointer to message string
+ *
+ * @api
+ */
+#define shellUsage(stream, message) \
+ chprintf(stream, "Usage: %s" SHELL_NEWLINE_STR, message)
+
+/*===========================================================================*/
+/* External declarations. */
+/*===========================================================================*/
+
+#if !defined(__DOXYGEN__)
+extern event_source_t shell_terminated;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+ void shellInit(void);
+ THD_FUNCTION(shellThread, p);
+ void shellExit(msg_t msg);
+ bool shellGetLine(ShellConfig *scfg, char *line,
+ unsigned size, ShellHistory *shp);
+#ifdef __cplusplus
+}
+#endif
+
+/*===========================================================================*/
+/* Module inline functions. */
+/*===========================================================================*/
+
+#endif /* SHELL_H */
+
+/** @} */
diff --git a/ChibiOS_20.3.2/os/various/shell/shell.mk b/ChibiOS_20.3.2/os/various/shell/shell.mk new file mode 100644 index 0000000..dfe901a --- /dev/null +++ b/ChibiOS_20.3.2/os/various/shell/shell.mk @@ -0,0 +1,9 @@ +# RT Shell files.
+SHELLSRC = $(CHIBIOS)/os/various/shell/shell.c \
+ $(CHIBIOS)/os/various/shell/shell_cmd.c
+
+SHELLINC = $(CHIBIOS)/os/various/shell
+
+# Shared variables
+ALLCSRC += $(SHELLSRC)
+ALLINC += $(SHELLINC)
diff --git a/ChibiOS_20.3.2/os/various/shell/shell_cmd.c b/ChibiOS_20.3.2/os/various/shell/shell_cmd.c new file mode 100644 index 0000000..525f269 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/shell/shell_cmd.c @@ -0,0 +1,247 @@ +/*
+ 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 shell_cmd.c
+ * @brief Simple CLI shell common commands code.
+ *
+ * @addtogroup SHELL
+ * @{
+ */
+
+#include <string.h>
+
+#include "ch.h"
+#include "hal.h"
+#include "shell.h"
+#include "shell_cmd.h"
+#include "chprintf.h"
+
+#if (SHELL_CMD_TEST_ENABLED == TRUE) || defined(__DOXYGEN__)
+#include "rt_test_root.h"
+#include "oslib_test_root.h"
+#endif
+
+/*===========================================================================*/
+/* Module local definitions. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module exported variables. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local types. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local variables. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module local functions. */
+/*===========================================================================*/
+
+#if ((SHELL_CMD_EXIT_ENABLED == TRUE) && !defined(_CHIBIOS_NIL_)) || \
+ defined(__DOXYGEN__)
+static void cmd_exit(BaseSequentialStream *chp, int argc, char *argv[]) {
+
+ (void)argv;
+ if (argc > 0) {
+ shellUsage(chp, "exit");
+ return;
+ }
+
+ shellExit(MSG_OK);
+}
+#endif
+
+#if (SHELL_CMD_INFO_ENABLED == TRUE) || defined(__DOXYGEN__)
+static void cmd_info(BaseSequentialStream *chp, int argc, char *argv[]) {
+
+ (void)argv;
+ if (argc > 0) {
+ shellUsage(chp, "info");
+ return;
+ }
+
+ chprintf(chp, "Kernel: %s" SHELL_NEWLINE_STR, CH_KERNEL_VERSION);
+#ifdef PORT_COMPILER_NAME
+ chprintf(chp, "Compiler: %s" SHELL_NEWLINE_STR, PORT_COMPILER_NAME);
+#endif
+ chprintf(chp, "Architecture: %s" SHELL_NEWLINE_STR, PORT_ARCHITECTURE_NAME);
+#ifdef PORT_CORE_VARIANT_NAME
+ chprintf(chp, "Core Variant: %s" SHELL_NEWLINE_STR, PORT_CORE_VARIANT_NAME);
+#endif
+#ifdef PORT_INFO
+ chprintf(chp, "Port Info: %s" SHELL_NEWLINE_STR, PORT_INFO);
+#endif
+#ifdef PLATFORM_NAME
+ chprintf(chp, "Platform: %s" SHELL_NEWLINE_STR, PLATFORM_NAME);
+#endif
+#ifdef BOARD_NAME
+ chprintf(chp, "Board: %s" SHELL_NEWLINE_STR, BOARD_NAME);
+#endif
+#ifdef __DATE__
+#ifdef __TIME__
+ chprintf(chp, "Build time: %s%s%s" SHELL_NEWLINE_STR, __DATE__, " - ", __TIME__);
+#endif
+#endif
+}
+#endif
+
+#if (SHELL_CMD_ECHO_ENABLED == TRUE) || defined(__DOXYGEN__)
+static void cmd_echo(BaseSequentialStream *chp, int argc, char *argv[]) {
+
+ (void)argv;
+ if (argc != 1) {
+ shellUsage(chp, "echo \"message\"");
+ return;
+ }
+ chprintf(chp, "%s" SHELL_NEWLINE_STR, argv[0]);
+}
+#endif
+
+#if (SHELL_CMD_SYSTIME_ENABLED == TRUE) || defined(__DOXYGEN__)
+static void cmd_systime(BaseSequentialStream *chp, int argc, char *argv[]) {
+
+ (void)argv;
+ if (argc > 0) {
+ shellUsage(chp, "systime");
+ return;
+ }
+ chprintf(chp, "%lu" SHELL_NEWLINE_STR, (unsigned long)chVTGetSystemTime());
+}
+#endif
+
+#if (SHELL_CMD_MEM_ENABLED == TRUE) || defined(__DOXYGEN__)
+static void cmd_mem(BaseSequentialStream *chp, int argc, char *argv[]) {
+ size_t n, total, largest;
+
+ (void)argv;
+ if (argc > 0) {
+ shellUsage(chp, "mem");
+ return;
+ }
+ n = chHeapStatus(NULL, &total, &largest);
+ chprintf(chp, "core free memory : %u bytes" SHELL_NEWLINE_STR, chCoreGetStatusX());
+ chprintf(chp, "heap fragments : %u" SHELL_NEWLINE_STR, n);
+ chprintf(chp, "heap free total : %u bytes" SHELL_NEWLINE_STR, total);
+ chprintf(chp, "heap free largest: %u bytes" SHELL_NEWLINE_STR, largest);
+}
+#endif
+
+#if (SHELL_CMD_THREADS_ENABLED == TRUE) || defined(__DOXYGEN__)
+static void cmd_threads(BaseSequentialStream *chp, int argc, char *argv[]) {
+ static const char *states[] = {CH_STATE_NAMES};
+ thread_t *tp;
+
+ (void)argv;
+ if (argc > 0) {
+ shellUsage(chp, "threads");
+ return;
+ }
+ chprintf(chp, "stklimit stack addr refs prio state name\r\n" SHELL_NEWLINE_STR);
+ tp = chRegFirstThread();
+ do {
+#if (CH_DBG_ENABLE_STACK_CHECK == TRUE) || (CH_CFG_USE_DYNAMIC == TRUE)
+ uint32_t stklimit = (uint32_t)tp->wabase;
+#else
+ uint32_t stklimit = 0U;
+#endif
+ chprintf(chp, "%08lx %08lx %08lx %4lu %4lu %9s %12s" SHELL_NEWLINE_STR,
+ stklimit, (uint32_t)tp->ctx.sp, (uint32_t)tp,
+ (uint32_t)tp->refs - 1, (uint32_t)tp->prio, states[tp->state],
+ tp->name == NULL ? "" : tp->name);
+ tp = chRegNextThread(tp);
+ } while (tp != NULL);
+}
+#endif
+
+#if (SHELL_CMD_TEST_ENABLED == TRUE) || defined(__DOXYGEN__)
+static THD_FUNCTION(test_rt, arg) {
+ BaseSequentialStream *chp = (BaseSequentialStream *)arg;
+ test_execute(chp, &rt_test_suite);
+}
+
+static THD_FUNCTION(test_oslib, arg) {
+ BaseSequentialStream *chp = (BaseSequentialStream *)arg;
+ test_execute(chp, &oslib_test_suite);
+}
+
+static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
+ thread_t *tp;
+ tfunc_t tfp;
+
+ (void)argv;
+ if (argc != 1) {
+ shellUsage(chp, "test rt|oslib");
+ return;
+ }
+ if (!strcmp(argv[0], "rt")) {
+ tfp = test_rt;
+ }
+ else if (!strcmp(argv[0], "oslib")) {
+ tfp = test_oslib;
+ }
+ else {
+ shellUsage(chp, "test rt|oslib");
+ return;
+ }
+ tp = chThdCreateFromHeap(NULL, SHELL_CMD_TEST_WA_SIZE,
+ "test", chThdGetPriorityX(),
+ tfp, chp);
+ if (tp == NULL) {
+ chprintf(chp, "out of memory" SHELL_NEWLINE_STR);
+ return;
+ }
+ chThdWait(tp);
+}
+#endif
+
+/*===========================================================================*/
+/* Module exported functions. */
+/*===========================================================================*/
+
+/**
+ * @brief Array of the default commands.
+ */
+const ShellCommand shell_local_commands[] = {
+#if (SHELL_CMD_EXIT_ENABLED == TRUE) && !defined(_CHIBIOS_NIL_)
+ {"exit", cmd_exit},
+#endif
+#if SHELL_CMD_INFO_ENABLED == TRUE
+ {"info", cmd_info},
+#endif
+#if SHELL_CMD_ECHO_ENABLED == TRUE
+ {"echo", cmd_echo},
+#endif
+#if SHELL_CMD_SYSTIME_ENABLED == TRUE
+ {"systime", cmd_systime},
+#endif
+#if SHELL_CMD_MEM_ENABLED == TRUE
+ {"mem", cmd_mem},
+#endif
+#if SHELL_CMD_THREADS_ENABLED == TRUE
+ {"threads", cmd_threads},
+#endif
+#if SHELL_CMD_TEST_ENABLED == TRUE
+ {"test", cmd_test},
+#endif
+ {NULL, NULL}
+};
+
+/** @} */
diff --git a/ChibiOS_20.3.2/os/various/shell/shell_cmd.h b/ChibiOS_20.3.2/os/various/shell/shell_cmd.h new file mode 100644 index 0000000..f913822 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/shell/shell_cmd.h @@ -0,0 +1,114 @@ +/*
+ 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 shell_cmd.h
+ * @brief Simple CLI shell common commands header.
+ *
+ * @addtogroup SHELL
+ * @{
+ */
+
+#ifndef SHELLCMD_H
+#define SHELLCMD_H
+
+/*===========================================================================*/
+/* Module constants. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module pre-compile time settings. */
+/*===========================================================================*/
+
+#if !defined(SHELL_CMD_EXIT_ENABLED) || defined(__DOXYGEN__)
+#define SHELL_CMD_EXIT_ENABLED TRUE
+#endif
+
+#if !defined(SHELL_CMD_INFO_ENABLED) || defined(__DOXYGEN__)
+#define SHELL_CMD_INFO_ENABLED TRUE
+#endif
+
+#if !defined(SHELL_CMD_ECHO_ENABLED) || defined(__DOXYGEN__)
+#define SHELL_CMD_ECHO_ENABLED TRUE
+#endif
+
+#if !defined(SHELL_CMD_SYSTIME_ENABLED) || defined(__DOXYGEN__)
+#define SHELL_CMD_SYSTIME_ENABLED TRUE
+#endif
+
+#if !defined(SHELL_CMD_MEM_ENABLED) || defined(__DOXYGEN__)
+#define SHELL_CMD_MEM_ENABLED TRUE
+#endif
+
+#if !defined(SHELL_CMD_THREADS_ENABLED) || defined(__DOXYGEN__)
+#define SHELL_CMD_THREADS_ENABLED TRUE
+#endif
+
+#if !defined(SHELL_CMD_TEST_ENABLED) || defined(__DOXYGEN__)
+#define SHELL_CMD_TEST_ENABLED TRUE
+#endif
+
+#if !defined(SHELL_CMD_TEST_WA_SIZE) || defined(__DOXYGEN__)
+#define SHELL_CMD_TEST_WA_SIZE THD_WORKING_AREA_SIZE(256)
+#endif
+
+/*===========================================================================*/
+/* Derived constants and error checks. */
+/*===========================================================================*/
+
+#if (SHELL_CMD_MEM_ENABLED == TRUE) && (CH_CFG_USE_MEMCORE == FALSE)
+#error "SHELL_CMD_MEM_ENABLED requires CH_CFG_USE_MEMCORE"
+#endif
+
+#if (SHELL_CMD_MEM_ENABLED == TRUE) && (CH_CFG_USE_HEAP == FALSE)
+#error "SHELL_CMD_MEM_ENABLED requires CH_CFG_USE_HEAP"
+#endif
+
+#if (SHELL_CMD_THREADS_ENABLED == TRUE) && (CH_CFG_USE_REGISTRY == FALSE)
+#error "SHELL_CMD_THREADS_ENABLED requires CH_CFG_USE_REGISTRY"
+#endif
+
+/*===========================================================================*/
+/* Module data structures and types. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* Module macros. */
+/*===========================================================================*/
+
+/*===========================================================================*/
+/* External declarations. */
+/*===========================================================================*/
+
+#if !defined(__DOXYGEN__)
+extern const ShellCommand shell_local_commands[];
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/*===========================================================================*/
+/* Module inline functions. */
+/*===========================================================================*/
+
+#endif /* SHELLCMD_H */
+
+/** @} */
diff --git a/ChibiOS_20.3.2/os/various/syscalls.c b/ChibiOS_20.3.2/os/various/syscalls.c new file mode 100644 index 0000000..8da8f75 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/syscalls.c @@ -0,0 +1,172 @@ +/*
+ 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) 2009 by Michael Fischer. 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. Neither the name of the author nor the names of its contributors may
+ * be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ *
+ ****************************************************************************
+ * History:
+ *
+ * 28.03.09 mifi First Version, based on the original syscall.c from
+ * newlib version 1.17.0
+ * 17.08.09 gdisirio Modified the file for use under ChibiOS/RT
+ * 15.11.09 gdisirio Added read and write handling
+ ****************************************************************************/
+
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "ch.h"
+#if defined(STDOUT_SD) || defined(STDIN_SD)
+#include "hal.h"
+#endif
+
+/***************************************************************************/
+
+__attribute__((used))
+int _read_r(struct _reent *r, int file, char * ptr, int len) {
+ (void)r;
+#if defined(STDIN_SD)
+ if (!len || (file != 0)) {
+ __errno_r(r) = EINVAL;
+ return -1;
+ }
+ len = sdRead(&STDIN_SD, (uint8_t *)ptr, (size_t)len);
+ return len;
+#else
+ (void)file;
+ (void)ptr;
+ (void)len;
+ __errno_r(r) = EINVAL;
+ return -1;
+#endif
+}
+
+/***************************************************************************/
+
+__attribute__((used))
+int _lseek_r(struct _reent *r, int file, int ptr, int dir) {
+ (void)r;
+ (void)file;
+ (void)ptr;
+ (void)dir;
+
+ return 0;
+}
+
+/***************************************************************************/
+
+__attribute__((used))
+int _write_r(struct _reent *r, int file, char * ptr, int len) {
+ (void)r;
+ (void)file;
+ (void)ptr;
+#if defined(STDOUT_SD)
+ if (file != 1) {
+ __errno_r(r) = EINVAL;
+ return -1;
+ }
+ sdWrite(&STDOUT_SD, (uint8_t *)ptr, (size_t)len);
+#endif
+ return len;
+}
+
+/***************************************************************************/
+
+__attribute__((used))
+int _close_r(struct _reent *r, int file) {
+ (void)r;
+ (void)file;
+
+ return 0;
+}
+
+/***************************************************************************/
+
+__attribute__((used))
+caddr_t _sbrk_r(struct _reent *r, int incr) {
+#if CH_CFG_USE_MEMCORE
+ void *p;
+
+ chDbgCheck(incr >= 0);
+
+ p = chCoreAllocFromBase((size_t)incr, 1U, 0U);
+ if (p == NULL) {
+ __errno_r(r) = ENOMEM;
+ return (caddr_t)-1;
+ }
+ return (caddr_t)p;
+#else
+ (void)incr;
+ __errno_r(r) = ENOMEM;
+ return (caddr_t)-1;
+#endif
+}
+
+/***************************************************************************/
+
+__attribute__((used))
+int _fstat_r(struct _reent *r, int file, struct stat * st) {
+ (void)r;
+ (void)file;
+
+ memset(st, 0, sizeof(*st));
+ st->st_mode = S_IFCHR;
+ return 0;
+}
+
+/***************************************************************************/
+
+__attribute__((used))
+int _isatty_r(struct _reent *r, int fd) {
+ (void)r;
+ (void)fd;
+
+ return 1;
+}
+
+/*** EOF ***/
diff --git a/ChibiOS_20.3.2/os/various/various.dox b/ChibiOS_20.3.2/os/various/various.dox new file mode 100644 index 0000000..0c8540e --- /dev/null +++ b/ChibiOS_20.3.2/os/various/various.dox @@ -0,0 +1,91 @@ +/*
+ 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.
+*/
+
+/**
+ * @defgroup various Various
+ *
+ * @brief Utilities Library.
+ * @details This is a collection of useful library code that is not part of
+ * the base kernel services.
+ * <h2>Notes</h2>
+ * The library code does not follow the same naming convention of the
+ * system APIs in order to make very clear that it is not "core" code.<br>
+ * The main difference is that library code is not formally tested in the
+ * test suite but through usage in the various demo applications.
+ */
+
+/**
+ * @defgroup cpp_library C++ Wrapper
+ *
+ * @brief C++ wrapper module.
+ * @details This module allows to use the ChibiOS/RT functionalities
+ * from C++ as classes and objects rather the traditional "C" APIs.
+ *
+ * @ingroup various
+ */
+
+/**
+ * @defgroup memory_streams Memory Streams
+ *
+ * @brief Memory Streams.
+ * @details This module allows to use a memory area (RAM or ROM) using a
+ * @ref data_streams interface.
+ *
+ * @ingroup various
+ */
+
+/**
+ * @defgroup event_timer Periodic Events Timer
+ *
+ * @brief Periodic Event Timer.
+ * @details This timer generates an event at regular intervals. The
+ * listening threads can use the event to perform time related
+ * activities. Multiple threads can listen to the same timer.
+ *
+ * @ingroup various
+ */
+
+/**
+ * @defgroup SHELL Command Shell
+ *
+ * @brief Small extendible command line shell.
+ * @details This module implements a generic extendible command line interface.
+ * The CLI just requires an I/O channel (@p BaseChannel), more
+ * commands can be added to the shell using the configuration
+ * structure.
+ *
+ * @ingroup various
+ */
+
+/**
+ * @defgroup chprintf System formatted print
+ *
+ * @brief System formatted print service.
+ * @details This module implements printf()-like function able to send data
+ * to any module implementing a @p BaseSequentialStream interface.
+ *
+ * @ingroup various
+ */
+
+/**
+ * @defgroup LWIP_THREAD LWIP bindings
+ *
+ * @brief lwIP port and wrapper thread.
+ * @details This module implements the lwIP system abstraction and wrapper
+ * thread.
+ *
+ * @ingroup various
+ */
diff --git a/ChibiOS_20.3.2/os/various/wolfssl_bindings/hwrng.c b/ChibiOS_20.3.2/os/various/wolfssl_bindings/hwrng.c new file mode 100644 index 0000000..ca11e48 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/wolfssl_bindings/hwrng.c @@ -0,0 +1,80 @@ +/*
+ 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) 2006-2017 wolfSSL Inc.
+ *
+ * This file is part of wolfSSL.
+ *
+ * wolfSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ *
+ */
+#include <ch.h>
+#include <stdint.h>
+#include "wolfssl_chibios.h"
+#include "user_settings.h"
+
+unsigned int chibios_rand_generate(void)
+{
+ static unsigned int last_value=0;
+ static unsigned int new_value=0;
+ unsigned int error_bits = 0;
+ error_bits = RNG_SR_SEIS | RNG_SR_CEIS;
+ while (new_value==last_value) {
+ /* Check for error flags and if data is ready. */
+ if ( ((RNG->SR & error_bits) == 0) && ( (RNG->SR & RNG_SR_DRDY) == 1 ) )
+ new_value=RNG->DR;
+ }
+ last_value=new_value;
+ return new_value;
+}
+
+int custom_rand_generate_block(unsigned char* output, unsigned int sz)
+{
+ uint32_t i = 0;
+
+ while (i < sz)
+ {
+ /* If not aligned or there is odd/remainder */
+ if( (i + sizeof(CUSTOM_RAND_TYPE)) > sz ||
+ ((uint32_t)&output[i] % sizeof(CUSTOM_RAND_TYPE)) != 0
+ ) {
+ /* Single byte at a time */
+ output[i++] = (unsigned char)chibios_rand_generate();
+ }
+ else {
+ /* Use native 8, 16, 32 or 64 copy instruction */
+ *((CUSTOM_RAND_TYPE*)&output[i]) = chibios_rand_generate();
+ i += sizeof(CUSTOM_RAND_TYPE);
+ }
+ }
+ return 0;
+}
+
diff --git a/ChibiOS_20.3.2/os/various/wolfssl_bindings/user_settings.h b/ChibiOS_20.3.2/os/various/wolfssl_bindings/user_settings.h new file mode 100644 index 0000000..03be06b --- /dev/null +++ b/ChibiOS_20.3.2/os/various/wolfssl_bindings/user_settings.h @@ -0,0 +1,86 @@ +#include <stdint.h> + +/* Configuration */ + +#define WOLFSSL_GENERAL_ALIGNMENT 4 +#define HAVE_TM_TYPE +#define WORD64_AVAILABLE + + +/* ChibiOS + Lwip */ +#define HAVE_LWIP_NATIVE +#define WOLFSSL_CHIBIOS + +#define USER_TICKS +#define WOLFSSL_USER_CURRTIME +#define XMALLOC_OVERRIDE +//#define USE_WOLF_TIME_T +#define XTIME(tl) (LowResTimer()) + + +/* ARM */ + +#define RSA_LOW_MEM +#define NO_OLD_RNGNAME +#define SMALL_SESSION_CACHE +#define WOLFSSL_SMALL_STACK + +#define TFM_ARM +#define SINGLE_THREADED +#define NO_SIG_WRAPPER + +/* Cipher features */ +//#define USE_FAST_MATH +//#define ALT_ECC_SIZE + +#define HAVE_FFDHE_2048 +#define HAVE_CHACHA +#define HAVE_POLY1305 +#define HAVE_ECC +#define HAVE_CURVE25519 +#define CURVED25519_SMALL +#define HAVE_ONE_TIME_AUTH +#define WOLFSSL_DH_CONST + +/* HW RNG support */ + +unsigned int chibios_rand_generate(void); +int custom_rand_generate_block(unsigned char* output, unsigned int sz); + +#define CUSTOM_RAND_GENERATE chibios_rand_generate +#define CUSTOM_RAND_TYPE uint32_t + +#define HAVE_ED25519 +#define HAVE_POLY1305 +#define HAVE_SHA512 +#define WOLFSSL_SHA512 + + +/* Size/speed config */ +#define USE_SLOW_SHA2 +#define USE_SLOW_SHA512 + +/* Robustness */ +#define TFM_TIMING_RESISTANT +#define ECC_TIMING_RESISTANT +#define WC_RSA_BLINDING + +/* Remove Features */ +#define NO_WRITEV +#define NO_DEV_RANDOM +#define NO_FILESYSTEM +#define NO_MAIN_DRIVER +#define NO_MD4 +#define NO_RABBIT +#define NO_HC128 +#define NO_DSA +#define NO_PWDBASED +#define NO_PSK +#define NO_DES3 +#define NO_RC4 + + +/* Realloc (to use without USE_FAST_MATH) */ + +void *chHeapRealloc (void *addr, uint32_t size); +#define XREALLOC(p,n,h,t) chHeapRealloc( (p) , (n) ) diff --git a/ChibiOS_20.3.2/os/various/wolfssl_bindings/wolfssl.mk b/ChibiOS_20.3.2/os/various/wolfssl_bindings/wolfssl.mk new file mode 100644 index 0000000..00ef082 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/wolfssl_bindings/wolfssl.mk @@ -0,0 +1,98 @@ +# List of the required lwIP files. +WOLFSSL = $(CHIBIOS)/ext/wolfssl + +WOLFBINDSRC = \ + $(CHIBIOS)/os/various/wolfssl_bindings/wolfssl_chibios.c \ + $(CHIBIOS)/os/various/wolfssl_bindings/hwrng.c + +WOLFCRYPTSRC = \ + $(WOLFSSL)/wolfcrypt/src/sha.c \ + $(WOLFSSL)/wolfcrypt/src/ge_low_mem.c \ + $(WOLFSSL)/wolfcrypt/src/compress.c \ + $(WOLFSSL)/wolfcrypt/src/chacha20_poly1305.c \ + $(WOLFSSL)/wolfcrypt/src/des3.c \ + $(WOLFSSL)/wolfcrypt/src/fe_low_mem.c \ + $(WOLFSSL)/wolfcrypt/src/hmac.c \ + $(WOLFSSL)/wolfcrypt/src/asm.c \ + $(WOLFSSL)/wolfcrypt/src/camellia.c \ + $(WOLFSSL)/wolfcrypt/src/ecc.c \ + $(WOLFSSL)/wolfcrypt/src/ecc_fp.c \ + $(WOLFSSL)/wolfcrypt/src/ripemd.c \ + $(WOLFSSL)/wolfcrypt/src/rsa.c \ + $(WOLFSSL)/wolfcrypt/src/wc_port.c \ + $(WOLFSSL)/wolfcrypt/src/arc4.c \ + $(WOLFSSL)/wolfcrypt/src/srp.c \ + $(WOLFSSL)/wolfcrypt/src/random.c \ + $(WOLFSSL)/wolfcrypt/src/idea.c \ + $(WOLFSSL)/wolfcrypt/src/blake2b.c \ + $(WOLFSSL)/wolfcrypt/src/error.c \ + $(WOLFSSL)/wolfcrypt/src/dh.c \ + $(WOLFSSL)/wolfcrypt/src/asn.c \ + $(WOLFSSL)/wolfcrypt/src/cmac.c \ + $(WOLFSSL)/wolfcrypt/src/signature.c \ + $(WOLFSSL)/wolfcrypt/src/pwdbased.c \ + $(WOLFSSL)/wolfcrypt/src/chacha.c \ + $(WOLFSSL)/wolfcrypt/src/md5.c \ + $(WOLFSSL)/wolfcrypt/src/aes.c \ + $(WOLFSSL)/wolfcrypt/src/wolfmath.c \ + $(WOLFSSL)/wolfcrypt/src/memory.c \ + $(WOLFSSL)/wolfcrypt/src/logging.c \ + $(WOLFSSL)/wolfcrypt/src/tfm.c \ + $(WOLFSSL)/wolfcrypt/src/coding.c \ + $(WOLFSSL)/wolfcrypt/src/rabbit.c \ + $(WOLFSSL)/wolfcrypt/src/pkcs12.c \ + $(WOLFSSL)/wolfcrypt/src/md2.c \ + $(WOLFSSL)/wolfcrypt/src/ge_operations.c \ + $(WOLFSSL)/wolfcrypt/src/sha512.c \ + $(WOLFSSL)/wolfcrypt/src/sha3.c \ + $(WOLFSSL)/wolfcrypt/src/port/nrf51.c \ + $(WOLFSSL)/wolfcrypt/src/port/pic32/pic32mz-crypt.c \ + $(WOLFSSL)/wolfcrypt/src/port/atmel/atmel.c \ + $(WOLFSSL)/wolfcrypt/src/port/nxp/ksdk_port.c \ + $(WOLFSSL)/wolfcrypt/src/port/ti/ti-des3.c \ + $(WOLFSSL)/wolfcrypt/src/port/ti/ti-ccm.c \ + $(WOLFSSL)/wolfcrypt/src/port/ti/ti-hash.c \ + $(WOLFSSL)/wolfcrypt/src/port/ti/ti-aes.c \ + $(WOLFSSL)/wolfcrypt/src/port/arm/armv8-aes.c \ + $(WOLFSSL)/wolfcrypt/src/port/arm/armv8-sha256.c \ + $(WOLFSSL)/wolfcrypt/src/port/xilinx/xil-aesgcm.c \ + $(WOLFSSL)/wolfcrypt/src/port/xilinx/xil-sha3.c \ + $(WOLFSSL)/wolfcrypt/src/hash.c \ + $(WOLFSSL)/wolfcrypt/src/curve25519.c \ + $(WOLFSSL)/wolfcrypt/src/integer.c \ + $(WOLFSSL)/wolfcrypt/src/wolfevent.c \ + $(WOLFSSL)/wolfcrypt/src/dsa.c \ + $(WOLFSSL)/wolfcrypt/src/pkcs7.c \ + $(WOLFSSL)/wolfcrypt/src/wc_encrypt.c \ + $(WOLFSSL)/wolfcrypt/src/cpuid.c \ + $(WOLFSSL)/wolfcrypt/src/sha256.c \ + $(WOLFSSL)/wolfcrypt/src/md4.c \ + $(WOLFSSL)/wolfcrypt/src/fe_operations.c \ + $(WOLFSSL)/wolfcrypt/src/ed25519.c \ + $(WOLFSSL)/wolfcrypt/src/poly1305.c \ + $(WOLFSSL)/wolfcrypt/src/hc128.c \ + +WOLFSSLSRC = \ + $(WOLFSSL)/src/internal.c \ + $(WOLFSSL)/src/tls.c \ + $(WOLFSSL)/src/keys.c \ + $(WOLFSSL)/src/crl.c \ + $(WOLFSSL)/src/ssl.c \ + $(WOLFSSL)/src/wolfio.c \ + $(WOLFSSL)/src/sniffer.c \ + $(WOLFSSL)/src/ocsp.c \ + $(WOLFSSL)/src/tls13.c + + +WOLFSRC = $(WOLFBINDSRC) $(WOLFCRYPTSRC) $(WOLFSSLSRC) + +WOLFINC = \ + $(CHIBIOS)/os/various/wolfssl_bindings \ + $(WOLFSSL)/wolfcrypt/include \ + $(WOLFSSL)/wolfssl/include \ + $(WOLFSSL) + +# Shared variables +ALLCSRC += $(WOLFSRC) +ALLINC += $(WOLFINC) + diff --git a/ChibiOS_20.3.2/os/various/wolfssl_bindings/wolfssl_chibios.c b/ChibiOS_20.3.2/os/various/wolfssl_bindings/wolfssl_chibios.c new file mode 100644 index 0000000..4b6cff3 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/wolfssl_bindings/wolfssl_chibios.c @@ -0,0 +1,252 @@ +/*
+ 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) 2006-2017 wolfSSL Inc.
+ *
+ * This file is part of wolfSSL.
+ *
+ * wolfSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ *
+ */
+
+#include "ch.h"
+#include "wolfssl_chibios.h"
+#include "lwip/opt.h"
+#include "lwip/arch.h"
+#include "lwip/api.h"
+#include "lwip/mem.h"
+#include "lwip/sockets.h"
+#include "lwip/tcp.h"
+#include <string.h>
+static int wolfssl_is_initialized = 0;
+
+sslconn *sslconn_accept(sslconn *sk)
+{
+ sslconn *new;
+ struct netconn *newconn = NULL;
+ err_t err;
+ err = netconn_accept(sk->conn, &newconn);
+ if (err != ERR_OK) {
+ return NULL;
+ }
+ new = chHeapAlloc(NULL, sizeof(sslconn));
+ if (!new)
+ return NULL;
+ new->conn = newconn;
+ new->ctx = sk->ctx;
+ new->ssl = wolfSSL_new(new->ctx);
+ wolfSSL_SetIOReadCtx(new->ssl, new);
+ wolfSSL_SetIOWriteCtx(new->ssl, new);
+
+ if (wolfSSL_accept(new->ssl) == SSL_SUCCESS) {
+ wolfSSL_set_using_nonblock(new->ssl, 1);
+ newconn->pcb.tcp->mss = 1480;
+ return new;
+ } else {
+ wolfSSL_free(new->ssl);
+ chHeapFree(new);
+ return NULL;
+ }
+}
+
+sslconn *sslconn_new(enum netconn_type t, WOLFSSL_METHOD* method)
+{
+ sslconn *sk;
+ if (!wolfssl_is_initialized) {
+ wolfSSL_Init();
+ wolfssl_is_initialized++;
+ }
+
+ sk = chHeapAlloc(NULL, sizeof(sslconn));
+ if (!sk)
+ return NULL;
+ memset(sk, 0, sizeof(sslconn));
+ sk->ctx = wolfSSL_CTX_new(method);
+ if (!sk->ctx)
+ goto error;
+ sk->conn = netconn_new(t);
+ if (!sk->conn)
+ goto error;
+ wolfSSL_SetIORecv(sk->ctx, wolfssl_recv_cb);
+ wolfSSL_SetIOSend(sk->ctx, wolfssl_send_cb);
+ return sk;
+
+error:
+ if (sk->ctx)
+ wolfSSL_CTX_free(sk->ctx);
+ chHeapFree(sk);
+ return NULL;
+}
+
+void sslconn_close(sslconn *sk)
+{
+ netconn_delete(sk->conn);
+ wolfSSL_free(sk->ssl);
+ chHeapFree(sk);
+}
+
+
+/* IO Callbacks */
+int wolfssl_send_cb(WOLFSSL* ssl, char *buf, int sz, void *ctx)
+{
+ sslconn *sk = (sslconn *)ctx;
+ int err;
+ (void)ssl;
+ err = netconn_write(sk->conn, buf, sz, NETCONN_COPY);
+ if (err == ERR_OK)
+ return sz;
+ else
+ return -2;
+}
+
+
+#define MAX_SSL_BUF 1460
+static uint8_t ssl_recv_buffer[MAX_SSL_BUF];
+static int ssl_rb_len = 0;
+static int ssl_rb_off = 0;
+
+int wolfssl_recv_cb(WOLFSSL *ssl, char *buf, int sz, void *ctx)
+{
+ sslconn *sk = (sslconn *)ctx;
+ struct netbuf *inbuf = NULL;
+ uint8_t *net_buf;
+ uint16_t buflen;
+ (void)ssl;
+ err_t err;
+
+ if (ssl_rb_len > 0) {
+ if (sz > ssl_rb_len - ssl_rb_off)
+ sz = ssl_rb_len - ssl_rb_off;
+ memcpy(buf, ssl_recv_buffer + ssl_rb_off, sz);
+ ssl_rb_off += sz;
+ if (ssl_rb_off >= ssl_rb_len) {
+ ssl_rb_len = 0;
+ ssl_rb_off = 0;
+ }
+ return sz;
+ }
+
+
+ err = netconn_recv(sk->conn, &inbuf);
+ if (err == ERR_OK) {
+ netbuf_data(inbuf, (void **)&net_buf, &buflen);
+ ssl_rb_len = buflen;
+ if (ssl_rb_len > MAX_SSL_BUF)
+ ssl_rb_len = MAX_SSL_BUF;
+ memcpy(ssl_recv_buffer, net_buf, ssl_rb_len);
+ ssl_rb_off = 0;
+ if (sz > ssl_rb_len)
+ sz = ssl_rb_len;
+ memcpy(buf, ssl_recv_buffer, sz);
+ ssl_rb_off += sz;
+ if (ssl_rb_off >= ssl_rb_len) {
+ ssl_rb_len = 0;
+ ssl_rb_off = 0;
+ }
+ netbuf_delete(inbuf);
+ return sz;
+ }
+ else
+ return 0;
+ //return WOLFSSL_CBIO_ERR_WANT_READ;
+}
+
+#ifndef ST2S
+# define ST2S(n) (((n) + CH_CFG_ST_FREQUENCY - 1UL) / CH_CFG_ST_FREQUENCY)
+#endif
+
+#ifndef ST2MS
+#define ST2MS(n) (((n) * 1000UL + CH_CFG_ST_FREQUENCY - 1UL) / CH_CFG_ST_FREQUENCY)
+#endif
+
+
+word32 LowResTimer(void)
+{
+ systime_t t = chVTGetSystemTimeX();
+ return ST2S(t);
+}
+
+uint32_t TimeNowInMilliseconds(void)
+{
+ systime_t t = chVTGetSystemTimeX();
+ return ST2MS(t);
+}
+
+void *chHeapRealloc (void *addr, uint32_t size)
+{
+ union heap_header *hp;
+ uint32_t prev_size, new_size;
+
+ void *ptr;
+
+ if(addr == NULL) {
+ return chHeapAlloc(NULL, size);
+ }
+
+ /* previous allocated segment is preceded by an heap_header */
+ hp = addr - sizeof(union heap_header);
+ prev_size = hp->used.size; /* size is always multiple of 8 */
+
+ /* check new size memory alignment */
+ if(size % 8 == 0) {
+ new_size = size;
+ }
+ else {
+ new_size = ((int) (size / 8)) * 8 + 8;
+ }
+
+ if(prev_size >= new_size) {
+ return addr;
+ }
+
+ ptr = chHeapAlloc(NULL, size);
+ if(ptr == NULL) {
+ return NULL;
+ }
+
+ memcpy(ptr, addr, prev_size);
+
+ chHeapFree(addr);
+
+ return ptr;
+}
+
+void *chibios_alloc(void *heap, int size)
+{
+ return chHeapAlloc(heap, size);
+}
+
+void chibios_free(void *ptr)
+{
+ if (ptr)
+ chHeapFree(ptr);
+}
+
diff --git a/ChibiOS_20.3.2/os/various/wolfssl_bindings/wolfssl_chibios.h b/ChibiOS_20.3.2/os/various/wolfssl_bindings/wolfssl_chibios.h new file mode 100644 index 0000000..42b1809 --- /dev/null +++ b/ChibiOS_20.3.2/os/various/wolfssl_bindings/wolfssl_chibios.h @@ -0,0 +1,70 @@ +/*
+ 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) 2006-2017 wolfSSL Inc.
+ *
+ * This file is part of wolfSSL.
+ *
+ * wolfSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ *
+ */
+#ifndef WOLFSSL_SK_H
+#define WOLFSSL_SK_H
+#include "user_settings.h"
+#include "wolfssl/wolfcrypt/settings.h"
+#include "wolfssl/wolfcrypt/types.h"
+#include "wolfssl/ssl.h"
+#include "lwip/opt.h"
+#include "lwip/arch.h"
+#include "lwip/api.h"
+#define XMALLOC(s,h,t) chibios_alloc(h,s)
+#define XFREE(p,h,t) chibios_free(p)
+
+struct sslconn {
+ WOLFSSL_CTX *ctx;
+ WOLFSSL *ssl;
+ struct netconn *conn;
+};
+
+typedef struct sslconn sslconn;
+
+sslconn *sslconn_accept(struct sslconn *sk);
+sslconn *sslconn_new(enum netconn_type t, WOLFSSL_METHOD *method);
+void sslconn_close(sslconn *sk);
+
+int wolfssl_send_cb(WOLFSSL* ssl, char *buf, int sz, void *ctx);
+int wolfssl_recv_cb(WOLFSSL *ssl, char *buf, int sz, void *ctx);
+
+void *chibios_alloc(void *heap, int size);
+void chibios_free(void *ptr);
+word32 LowResTimer(void);
+
+#endif
|