kemonine/keyboard
kemonine/keyboard
1
0
Fork 0
Code Issues Pull requests Releases 2 Activity
keyboard/qmk/lib/chibios/os/various/cpp_wrappers/ch.hpp

3134 lines
100 KiB
C++
Raw Normal View History

Add back qmk firmware that's been updated for kemonine setups
2020-09-25 03:24:14 +00:00
/*
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_ */
/** @} */
Reference in a new issue Copy permalink